averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

[stdlib] De-underscore Unicode "namespace"

Browse Source
This commit is contained in:
Dave Abrahams
2017-05-10 15:00:22 -07:00
parent 02dbc0f34f
commit 97f875ad84
11 changed files with 65 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
stdlib/public/core/ASCII.swift
View File

@@ -9,12 +9,12 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
@_fixed_layout
public enum ASCII {}
}
extension _Unicode.ASCII : UnicodeEncoding {
extension Unicode.ASCII : UnicodeEncoding {
public typealias CodeUnit = UInt8
public typealias EncodedScalar = CollectionOfOne<CodeUnit>
@@ -69,19 +69,19 @@ extension _Unicode.ASCII : UnicodeEncoding {
public typealias ReverseParser = Parser
}
extension _Unicode.ASCII.Parser : UnicodeParser {
public typealias Encoding = _Unicode.ASCII
extension Unicode.ASCII.Parser : UnicodeParser {
public typealias Encoding = Unicode.ASCII
/// Parses a single Unicode scalar value from `input`.
public mutating func parseScalar<I : IteratorProtocol>(
from input: inout I
) -> _Unicode.ParseResult<Encoding.EncodedScalar>
) -> Unicode.ParseResult<Encoding.EncodedScalar>
where I.Element == Encoding.CodeUnit {
let n = input.next()
if _fastPath(n != nil), let x = n {
guard _fastPath(Int8(extendingOrTruncating: x) >= 0)
else { return .error(length: 1) }
return .valid(_Unicode.ASCII.EncodedScalar(x))
return .valid(Unicode.ASCII.EncodedScalar(x))
}
return .emptyInput
}

6
stdlib/public/core/String.swift
View File

@@ -160,7 +160,7 @@ extension _StringCore {
return try Swift._withCStringAndLength(
encodedAs: targetEncoding,
from: UnsafeBufferPointer(start: startASCII, count: count)[bounds],
encodedAs: _Unicode.ASCII.self,
encodedAs: Unicode.ASCII.self,
execute: body
)
}
@@ -168,7 +168,7 @@ extension _StringCore {
return try Swift._withCStringAndLength(
encodedAs: targetEncoding,
from: UnsafeBufferPointer(start: startUTF16, count: count)[bounds],
encodedAs: _Unicode.UTF16.self,
encodedAs: Unicode.UTF16.self,
execute: body
)
}
@@ -176,7 +176,7 @@ extension _StringCore {
return try Swift._withCStringAndLength(
encodedAs: targetEncoding,
from: self[bounds],
encodedAs: _Unicode.UTF16.self,
encodedAs: Unicode.UTF16.self,
execute: body
)
}

14
stdlib/public/core/StringCore.swift
View File

@@ -336,7 +336,7 @@ public struct _StringCore {
}
}
var _unmanagedASCII : UnsafeBufferPointer<_Unicode.ASCII.CodeUnit>? {
var _unmanagedASCII : UnsafeBufferPointer<Unicode.ASCII.CodeUnit>? {
@inline(__always)
get {
guard _fastPath(_baseAddress != nil && elementWidth == 1) else {
@@ -344,7 +344,7 @@ public struct _StringCore {
}
return UnsafeBufferPointer(
start: _baseAddress!.assumingMemoryBound(
to: _Unicode.ASCII.CodeUnit.self),
to: Unicode.ASCII.CodeUnit.self),
count: count
)
}
@@ -370,10 +370,10 @@ public struct _StringCore {
{
defer { _fixLifetime(self) }
if let bytes = _unmanagedASCII {
if encoding == _Unicode.ASCII.self
|| encoding == _Unicode.UTF8.self
|| encoding == _Unicode.UTF16.self
|| encoding == _Unicode.UTF32.self {
if encoding == Unicode.ASCII.self
|| encoding == Unicode.UTF8.self
|| encoding == Unicode.UTF16.self
|| encoding == Unicode.UTF32.self {
bytes.forEach {
processCodeUnit(Encoding.CodeUnit(extendingOrTruncating: $0))
}
@@ -388,7 +388,7 @@ public struct _StringCore {
}
else if let content = _unmanagedUTF16 {
var i = content.makeIterator()
_Unicode.UTF16.ForwardParser._parse(&i) {
Unicode.UTF16.ForwardParser._parse(&i) {
Encoding._transcode($0, from: UTF16.self).forEach(processCodeUnit)
}
}

6
stdlib/public/core/StringHashable.swift
View File

@@ -23,7 +23,7 @@ func _stdlib_NSStringHashValuePointer(_ str: OpaquePointer, _ isASCII: Bool) ->
func _stdlib_CFStringHashCString(_ str: OpaquePointer, _ len: Int) -> Int
#endif
extension _Unicode {
extension Unicode {
internal static func hashASCII(
_ string: UnsafeBufferPointer<UInt8>
) -> Int {
@@ -97,11 +97,11 @@ internal func _hashString(_ string: String) -> Int {
}
#else
if let asciiBuffer = core.asciiBuffer {
return _Unicode.hashASCII(UnsafeBufferPointer(
return Unicode.hashASCII(UnsafeBufferPointer(
start: asciiBuffer.baseAddress!,
count: asciiBuffer.count))
} else {
return _Unicode.hashUTF16(
return Unicode.hashUTF16(
UnsafeBufferPointer(start: core.startUTF16, count: core.count))
}
#endif

12
stdlib/public/core/UTF16.swift
View File

@@ -9,13 +9,13 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
public enum UTF16 {
case _swift3Buffer(_Unicode.UTF16.ForwardParser)
case _swift3Buffer(Unicode.UTF16.ForwardParser)
}
}
extension _Unicode.UTF16 : UnicodeEncoding {
extension Unicode.UTF16 : UnicodeEncoding {
public typealias CodeUnit = UInt16
public typealias EncodedScalar = _UIntBuffer<UInt32, UInt16>
@@ -108,7 +108,7 @@ extension _Unicode.UTF16 : UnicodeEncoding {
}
extension UTF16.ReverseParser : UnicodeParser, _UTFParser {
public typealias Encoding = _Unicode.UTF16
public typealias Encoding = Unicode.UTF16
public func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8) {
_sanityCheck( // this case handled elsewhere
@@ -128,8 +128,8 @@ extension UTF16.ReverseParser : UnicodeParser, _UTFParser {
}
}
extension _Unicode.UTF16.ForwardParser : UnicodeParser, _UTFParser {
public typealias Encoding = _Unicode.UTF16
extension Unicode.UTF16.ForwardParser : UnicodeParser, _UTFParser {
public typealias Encoding = Unicode.UTF16
public func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8) {
_sanityCheck( // this case handled elsewhere

8
stdlib/public/core/UTF32.swift
View File

@@ -9,13 +9,13 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
public enum UTF32 {
case _swift3Codec
}
}
extension _Unicode.UTF32 : UnicodeEncoding {
extension Unicode.UTF32 : UnicodeEncoding {
public typealias CodeUnit = UInt32
public typealias EncodedScalar = CollectionOfOne<UInt32>
@@ -49,12 +49,12 @@ extension _Unicode.UTF32 : UnicodeEncoding {
}
extension UTF32.Parser : UnicodeParser {
public typealias Encoding = _Unicode.UTF32
public typealias Encoding = Unicode.UTF32
/// Parses a single Unicode scalar value from `input`.
public mutating func parseScalar<I : IteratorProtocol>(
from input: inout I
) -> _Unicode.ParseResult<Encoding.EncodedScalar>
) -> Unicode.ParseResult<Encoding.EncodedScalar>
where I.Element == Encoding.CodeUnit {
let n = input.next()
if _fastPath(n != nil), let x = n {

12
stdlib/public/core/UTF8.swift
View File

@@ -9,14 +9,14 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
@_fixed_layout
public enum UTF8 {
case _swift3Buffer(_Unicode.UTF8.ForwardParser)
case _swift3Buffer(Unicode.UTF8.ForwardParser)
}
}
extension _Unicode.UTF8 : UnicodeEncoding {
extension Unicode.UTF8 : UnicodeEncoding {
public typealias CodeUnit = UInt8
public typealias EncodedScalar = _UIntBuffer<UInt32, UInt8>
@@ -141,7 +141,7 @@ extension _Unicode.UTF8 : UnicodeEncoding {
}
extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
public typealias Encoding = _Unicode.UTF8
public typealias Encoding = Unicode.UTF8
@inline(__always)
@_inlineable
public func _parseMultipleCodeUnits() -> (isValid: Bool, bitCount: UInt8) {
@@ -217,8 +217,8 @@ extension UTF8.ReverseParser : UnicodeParser, _UTFParser {
}
}
extension _Unicode.UTF8.ForwardParser : UnicodeParser, _UTFParser {
public typealias Encoding = _Unicode.UTF8
extension Unicode.UTF8.ForwardParser : UnicodeParser, _UTFParser {
public typealias Encoding = Unicode.UTF8
@inline(__always)
@_inlineable

2
stdlib/public/core/UTFEncoding.swift
View File

@@ -31,7 +31,7 @@ where Encoding.EncodedScalar == _UIntBuffer<UInt32, Encoding.CodeUnit> {
@inline(__always)
public mutating func parseScalar<I : IteratorProtocol>(
from input: inout I
) -> _Unicode.ParseResult<Encoding.EncodedScalar>
) -> Unicode.ParseResult<Encoding.EncodedScalar>
where I.Element == Encoding.CodeUnit {
// Bufferless single-scalar fastpath.

16
stdlib/public/core/Unicode.swift
View File

@@ -142,7 +142,7 @@ public protocol UnicodeCodec : UnicodeEncoding {
/// A codec for translating between Unicode scalar values and UTF-8 code
/// units.
extension _Unicode.UTF8 : UnicodeCodec {
extension Unicode.UTF8 : UnicodeCodec {
/// Creates an instance of the UTF-8 codec.
public init() { self = ._swift3Buffer(ForwardParser()) }
@@ -308,11 +308,11 @@ extension _Unicode.UTF8 : UnicodeCodec {
return Int(_swift_stdlib_strlen(input))
}
}
public typealias UTF8 = _Unicode.UTF8
public typealias UTF8 = Unicode.UTF8
/// A codec for translating between Unicode scalar values and UTF-16 code
/// units.
extension _Unicode.UTF16 : UnicodeCodec {
extension Unicode.UTF16 : UnicodeCodec {
/// Creates an instance of the UTF-16 codec.
public init() { self = ._swift3Buffer(ForwardParser()) }
@@ -418,11 +418,11 @@ extension _Unicode.UTF16 : UnicodeCodec {
processCodeUnit(UInt16(extendingOrTruncating: s))
}
}
public typealias UTF16 = _Unicode.UTF16
public typealias UTF16 = Unicode.UTF16
/// A codec for translating between Unicode scalar values and UTF-32 code
/// units.
extension _Unicode.UTF32 : UnicodeCodec {
extension Unicode.UTF32 : UnicodeCodec {
/// Creates an instance of the UTF-32 codec.
public init() { self = ._swift3Codec }
@@ -508,7 +508,7 @@ extension _Unicode.UTF32 : UnicodeCodec {
processCodeUnit(UInt32(input))
}
}
public typealias UTF32 = _Unicode.UTF32
public typealias UTF32 = Unicode.UTF32
/// Translates the given input from one Unicode encoding to another by calling
/// the given closure.
@@ -918,7 +918,7 @@ extension UTF16 {
&i, repairingIllFormedSequences: repairingIllFormedSequences
) {
if isASCII {
isASCII = _Unicode.ASCII.transcode($0, from: Encoding.self) != nil
isASCII = Unicode.ASCII.transcode($0, from: Encoding.self) != nil
}
count += numericCast(self._transcode($0, from: Encoding.self).count)
}
@@ -996,5 +996,5 @@ extension UTF16 {
}
/// A namespace for Unicode utilities.
public enum _Unicode {}
public enum Unicode {}

8
stdlib/public/core/UnicodeParser.swift
View File

@@ -9,7 +9,7 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
/// The result of attempting to parse a `T` from some input.
public enum ParseResult<T> {
/// A `T` was parsed successfully
@@ -40,7 +40,7 @@ public protocol UnicodeParser {
/// Parses a single Unicode scalar value from `input`.
mutating func parseScalar<I : IteratorProtocol>(
from input: inout I
) -> _Unicode.ParseResult<Encoding.EncodedScalar>
) -> Unicode.ParseResult<Encoding.EncodedScalar>
where I.Element == Encoding.CodeUnit
}
@@ -86,7 +86,7 @@ extension UnicodeParser {
}
}
extension _Unicode {
extension Unicode {
@_fixed_layout
public // @testable
struct _ParsingIterator<
@@ -104,7 +104,7 @@ extension _Unicode {
}
}
extension _Unicode._ParsingIterator : IteratorProtocol, Sequence {
extension Unicode._ParsingIterator : IteratorProtocol, Sequence {
@inline(__always)
@_inlineable
public mutating func next() -> Parser.Encoding.EncodedScalar? {

34
test/Prototypes/UnicodeDecoders.swift
View File

@@ -35,7 +35,7 @@ extension UnicodeScalar {
}
//===----------------------------------------------------------------------===//
extension _Unicode {
extension Unicode {
struct DefaultScalarView<
CodeUnits: BidirectionalCollection,
Encoding: UnicodeEncoding
@@ -49,28 +49,28 @@ extension _Unicode {
}
}
extension _Unicode.DefaultScalarView : Sequence {
extension Unicode.DefaultScalarView : Sequence {
struct Iterator {
var parsing: _Unicode._ParsingIterator<
var parsing: Unicode._ParsingIterator<
CodeUnits.Iterator, Encoding.ForwardParser>
}
func makeIterator() -> Iterator {
return Iterator(
parsing: _Unicode._ParsingIterator(
parsing: Unicode._ParsingIterator(
codeUnits: codeUnits.makeIterator(),
parser: Encoding.ForwardParser()
))
}
}
extension _Unicode.DefaultScalarView.Iterator : IteratorProtocol, Sequence {
extension Unicode.DefaultScalarView.Iterator : IteratorProtocol, Sequence {
mutating func next() -> UnicodeScalar? {
return parsing.next().map { Encoding.decode($0) }
}
}
extension _Unicode.DefaultScalarView {
extension Unicode.DefaultScalarView {
struct Index {
var codeUnitIndex: CodeUnits.Index
var scalar: UnicodeScalar
@@ -78,25 +78,25 @@ extension _Unicode.DefaultScalarView {
}
}
extension _Unicode.DefaultScalarView.Index : Comparable {
extension Unicode.DefaultScalarView.Index : Comparable {
@inline(__always)
public static func < (
lhs: _Unicode.DefaultScalarView<CodeUnits,Encoding>.Index,
rhs: _Unicode.DefaultScalarView<CodeUnits,Encoding>.Index
lhs: Unicode.DefaultScalarView<CodeUnits,Encoding>.Index,
rhs: Unicode.DefaultScalarView<CodeUnits,Encoding>.Index
) -> Bool {
return lhs.codeUnitIndex < rhs.codeUnitIndex
}
@inline(__always)
public static func == (
lhs: _Unicode.DefaultScalarView<CodeUnits,Encoding>.Index,
rhs: _Unicode.DefaultScalarView<CodeUnits,Encoding>.Index
lhs: Unicode.DefaultScalarView<CodeUnits,Encoding>.Index,
rhs: Unicode.DefaultScalarView<CodeUnits,Encoding>.Index
) -> Bool {
return lhs.codeUnitIndex == rhs.codeUnitIndex
}
}
extension _Unicode.DefaultScalarView : Collection {
extension Unicode.DefaultScalarView : Collection {
public var startIndex: Index {
@inline(__always)
get {
@@ -148,7 +148,7 @@ extension _Unicode.DefaultScalarView : Collection {
}
}
extension _Unicode.DefaultScalarView : BidirectionalCollection {
extension Unicode.DefaultScalarView : BidirectionalCollection {
@inline(__always)
public func index(before i: Index) -> Index {
var parser = Encoding.ReverseParser()
@@ -348,7 +348,7 @@ func checkDecodeUTF<Codec : UnicodeCodec & UnicodeEncoding>(
}
//===--- Scalar View ----------------------------------------------------===//
let scalars = _Unicode.DefaultScalarView(utfStr, fromEncoding: Codec.self)
let scalars = Unicode.DefaultScalarView(utfStr, fromEncoding: Codec.self)
expectEqualSequence(expected, scalars.map { $0.value })
expectEqualSequence(
expected.reversed(),
@@ -2442,18 +2442,18 @@ public func run_UTF8Decode(_ N: Int) {
typealias D = UTF8.ReverseParser
D.decode(&it, repairingIllFormedSequences: true) { total = total &+ $0.value }
#elseif SEQUENCE
for s in _Unicode.DefaultScalarView(string, fromEncoding: UTF8.self) {
for s in Unicode.DefaultScalarView(string, fromEncoding: UTF8.self) {
total = total &+ s.value
}
#elseif COLLECTION
let scalars = _Unicode.DefaultScalarView(string, fromEncoding: UTF8.self)
let scalars = Unicode.DefaultScalarView(string, fromEncoding: UTF8.self)
var i = scalars.startIndex
while i != scalars.endIndex {
total = total &+ scalars[i].value
i = scalars.index(after: i)
}
#elseif REVERSE_COLLECTION
let scalars = _Unicode.DefaultScalarView(string, fromEncoding: UTF8.self)
let scalars = Unicode.DefaultScalarView(string, fromEncoding: UTF8.self)
var i = scalars.endIndex
while i != scalars.startIndex {
i = scalars.index(before: i)