| //===----------------------------------------------------------------------===// |
| // |
| // This source file is part of the Swift.org open source project |
| // |
| // Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors |
| // Licensed under Apache License v2.0 with Runtime Library Exception |
| // |
| // See https://swift.org/LICENSE.txt for license information |
| // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| // |
| //===----------------------------------------------------------------------===// |
| |
| extension String { |
| // FIXME(strings): at least temporarily remove it to see where it was applied |
| /// Creates a new string from the given substring. |
| /// |
| /// - Parameter substring: A substring to convert to a standalone `String` |
| /// instance. |
| /// |
| /// - Complexity: O(*n*), where *n* is the length of `substring`. |
| @inlinable // FIXME(sil-serialize-all) |
| public init(_ substring: Substring) { |
| let wholeGuts = substring._wholeString._guts |
| self.init(wholeGuts._extractSlice(substring._encodedOffsetRange)) |
| } |
| } |
| |
| /// A slice of a string. |
| /// |
| /// When you create a slice of a string, a `Substring` instance is the result. |
| /// Operating on substrings is fast and efficient because a substring shares |
| /// its storage with the original string. The `Substring` type presents the |
| /// same interface as `String`, so you can avoid or defer any copying of the |
| /// string's contents. |
| /// |
| /// The following example creates a `greeting` string, and then finds the |
| /// substring of the first sentence: |
| /// |
| /// let greeting = "Hi there! It's nice to meet you! 👋" |
| /// let endOfSentence = greeting.firstIndex(of: "!")! |
| /// let firstSentence = greeting[...endOfSentence] |
| /// // firstSentence == "Hi there!" |
| /// |
| /// You can perform many string operations on a substring. Here, we find the |
| /// length of the first sentence and create an uppercase version. |
| /// |
| /// print("'\(firstSentence)' is \(firstSentence.count) characters long.") |
| /// // Prints "'Hi there!' is 9 characters long." |
| /// |
| /// let shoutingSentence = firstSentence.uppercased() |
| /// // shoutingSentence == "HI THERE!" |
| /// |
| /// Converting a Substring to a String |
| /// ================================== |
| /// |
| /// This example defines a `rawData` string with some unstructured data, and |
| /// then uses the string's `prefix(while:)` method to create a substring of |
| /// the numeric prefix: |
| /// |
| /// let rawInput = "126 a.b 22219 zzzzzz" |
| /// let numericPrefix = rawInput.prefix(while: { "0"..."9" ~= $0 }) |
| /// // numericPrefix is the substring "126" |
| /// |
| /// When you need to store a substring or pass it to a function that requires a |
| /// `String` instance, you can convert it to a `String` by using the |
| /// `String(_:)` initializer. Calling this initializer copies the contents of |
| /// the substring to a new string. |
| /// |
| /// func parseAndAddOne(_ s: String) -> Int { |
| /// return Int(s, radix: 10)! + 1 |
| /// } |
| /// _ = parseAndAddOne(numericPrefix) |
| /// // error: cannot convert value... |
| /// let incrementedPrefix = parseAndAddOne(String(numericPrefix)) |
| /// // incrementedPrefix == 127 |
| /// |
| /// Alternatively, you can convert the function that takes a `String` to one |
| /// that is generic over the `StringProtocol` protocol. The following code |
| /// declares a generic version of the `parseAndAddOne(_:)` function: |
| /// |
| /// func genericParseAndAddOne<S: StringProtocol>(_ s: S) -> Int { |
| /// return Int(s, radix: 10)! + 1 |
| /// } |
| /// let genericallyIncremented = genericParseAndAddOne(numericPrefix) |
| /// // genericallyIncremented == 127 |
| /// |
| /// You can call this generic function with an instance of either `String` or |
| /// `Substring`. |
| /// |
| /// - Important: Don't store substrings longer than you need them to perform a |
| /// specific operation. A substring holds a reference to the entire storage |
| /// of the string it comes from, not just to the portion it presents, even |
| /// when there is no other reference to the original string. Storing |
| /// substrings may, therefore, prolong the lifetime of string data that is |
| /// no longer otherwise accessible, which can appear to be memory leakage. |
| @_fixed_layout // FIXME(sil-serialize-all) |
| public struct Substring : StringProtocol { |
| public typealias Index = String.Index |
| public typealias SubSequence = Substring |
| |
| @usableFromInline // FIXME(sil-serialize-all) |
| internal var _slice: Slice<String> |
| |
| /// Creates an empty substring. |
| @inlinable // FIXME(sil-serialize-all) |
| public init() { |
| _slice = Slice() |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| internal init(_slice: Slice<String>) { |
| self._slice = _slice |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| internal init(_ guts: _StringGuts, _ offsetRange: Range<Int>) { |
| self.init( |
| _base: String(guts), |
| Index(encodedOffset: offsetRange.lowerBound) ..< |
| Index(encodedOffset: offsetRange.upperBound)) |
| } |
| |
| /// Creates a substring with the specified bounds within the given string. |
| /// |
| /// - Parameters: |
| /// - base: The string to create a substring of. |
| /// - bounds: The range of `base` to use for the substring. The lower and |
| /// upper bounds of `bounds` must be valid indices of `base`. |
| @inlinable // FIXME(sil-serialize-all) |
| public init(_base base: String, _ bounds: Range<Index>) { |
| _slice = Slice(base: base, bounds: bounds) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| internal init<R: RangeExpression>( |
| _base base: String, _ bounds: R |
| ) where R.Bound == Index { |
| self.init(_base: base, bounds.relative(to: base)) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public var startIndex: Index { return _slice.startIndex } |
| @inlinable // FIXME(sil-serialize-all) |
| public var endIndex: Index { return _slice.endIndex } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func index(after i: Index) -> Index { |
| _precondition(i < endIndex, "Cannot increment beyond endIndex") |
| _precondition(i >= startIndex, "Cannot increment an invalid index") |
| // FIXME(strings): slice types currently lack necessary bound checks |
| return _slice.index(after: i) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func index(before i: Index) -> Index { |
| _precondition(i <= endIndex, "Cannot decrement an invalid index") |
| _precondition(i > startIndex, "Cannot decrement beyond startIndex") |
| // FIXME(strings): slice types currently lack necessary bound checks |
| return _slice.index(before: i) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func index(_ i: Index, offsetBy n: Int) -> Index { |
| let result = _slice.index(i, offsetBy: n) |
| // FIXME(strings): slice types currently lack necessary bound checks |
| _precondition( |
| (_slice._startIndex ... _slice.endIndex).contains(result), |
| "Operation results in an invalid index") |
| return result |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func index( |
| _ i: Index, offsetBy n: Int, limitedBy limit: Index |
| ) -> Index? { |
| let result = _slice.index(i, offsetBy: n, limitedBy: limit) |
| // FIXME(strings): slice types currently lack necessary bound checks |
| _precondition(result.map { |
| (_slice._startIndex ... _slice.endIndex).contains($0) |
| } ?? true, |
| "Operation results in an invalid index") |
| return result |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func distance(from start: Index, to end: Index) -> Int { |
| return _slice.distance(from: start, to: end) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public subscript(i: Index) -> Character { |
| return _slice[i] |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public mutating func replaceSubrange<C>( |
| _ bounds: Range<Index>, |
| with newElements: C |
| ) where C : Collection, C.Iterator.Element == Iterator.Element { |
| // FIXME(strings): slice types currently lack necessary bound checks |
| _slice.replaceSubrange(bounds, with: newElements) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public mutating func replaceSubrange( |
| _ bounds: Range<Index>, with newElements: Substring |
| ) { |
| replaceSubrange(bounds, with: newElements._slice) |
| } |
| |
| /// Creates a string from the given Unicode code units in the specified |
| /// encoding. |
| /// |
| /// - Parameters: |
| /// - codeUnits: A collection of code units encoded in the encoding |
| /// specified in `sourceEncoding`. |
| /// - sourceEncoding: The encoding in which `codeUnits` should be |
| /// interpreted. |
| @inlinable // FIXME(sil-serialize-all) |
| public init<C: Collection, Encoding: _UnicodeEncoding>( |
| decoding codeUnits: C, as sourceEncoding: Encoding.Type |
| ) where C.Iterator.Element == Encoding.CodeUnit { |
| self.init(String(decoding: codeUnits, as: sourceEncoding)) |
| } |
| |
| /// Creates a string from the null-terminated, UTF-8 encoded sequence of |
| /// bytes at the given pointer. |
| /// |
| /// - Parameter nullTerminatedUTF8: A pointer to a sequence of contiguous, |
| /// UTF-8 encoded bytes ending just before the first zero byte. |
| @inlinable // FIXME(sil-serialize-all) |
| public init(cString nullTerminatedUTF8: UnsafePointer<CChar>) { |
| self.init(String(cString: nullTerminatedUTF8)) |
| } |
| |
| /// Creates a string from the null-terminated sequence of bytes at the given |
| /// pointer. |
| /// |
| /// - Parameters: |
| /// - nullTerminatedCodeUnits: A pointer to a sequence of contiguous code |
| /// units in the encoding specified in `sourceEncoding`, ending just |
| /// before the first zero code unit. |
| /// - sourceEncoding: The encoding in which the code units should be |
| /// interpreted. |
| @inlinable // FIXME(sil-serialize-all) |
| public init<Encoding: _UnicodeEncoding>( |
| decodingCString nullTerminatedCodeUnits: UnsafePointer<Encoding.CodeUnit>, |
| as sourceEncoding: Encoding.Type |
| ) { |
| self.init( |
| String(decodingCString: nullTerminatedCodeUnits, as: sourceEncoding)) |
| } |
| |
| /// Calls the given closure with a pointer to the contents of the string, |
| /// represented as a null-terminated sequence of UTF-8 code units. |
| /// |
| /// The pointer passed as an argument to `body` is valid only during the |
| /// execution of `withCString(_:)`. Do not store or return the pointer for |
| /// later use. |
| /// |
| /// - Parameter body: A closure with a pointer parameter that points to a |
| /// null-terminated sequence of UTF-8 code units. If `body` has a return |
| /// value, that value is also used as the return value for the |
| /// `withCString(_:)` method. The pointer argument is valid only for the |
| /// duration of the method's execution. |
| /// - Returns: The return value, if any, of the `body` closure parameter. |
| @inlinable // FIXME(sil-serialize-all) |
| public func withCString<Result>( |
| _ body: (UnsafePointer<CChar>) throws -> Result) rethrows -> Result { |
| return try _wholeString._guts._withCSubstringAndLength( |
| in: _encodedOffsetRange, |
| encoding: UTF8.self) { p, length in |
| try p.withMemoryRebound(to: CChar.self, capacity: length, body) |
| } |
| } |
| |
| /// Calls the given closure with a pointer to the contents of the string, |
| /// represented as a null-terminated sequence of code units. |
| /// |
| /// The pointer passed as an argument to `body` is valid only during the |
| /// execution of `withCString(encodedAs:_:)`. Do not store or return the |
| /// pointer for later use. |
| /// |
| /// - Parameters: |
| /// - body: A closure with a pointer parameter that points to a |
| /// null-terminated sequence of code units. If `body` has a return |
| /// value, that value is also used as the return value for the |
| /// `withCString(encodedAs:_:)` method. The pointer argument is valid |
| /// only for the duration of the method's execution. |
| /// - targetEncoding: The encoding in which the code units should be |
| /// interpreted. |
| /// - Returns: The return value, if any, of the `body` closure parameter. |
| @inlinable // FIXME(sil-serialize-all) |
| public func withCString<Result, TargetEncoding: _UnicodeEncoding>( |
| encodedAs targetEncoding: TargetEncoding.Type, |
| _ body: (UnsafePointer<TargetEncoding.CodeUnit>) throws -> Result |
| ) rethrows -> Result { |
| return try _wholeString._guts._withCSubstring( |
| in: _encodedOffsetRange, |
| encoding: targetEncoding, |
| body) |
| } |
| } |
| |
| extension Substring : _SwiftStringView { |
| @inlinable // FIXME(sil-serialize-all) |
| internal var _persistentContent: String { |
| return String(self) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public // @testable |
| var _ephemeralContent: String { |
| return _persistentContent |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public var _wholeString: String { |
| return _slice._base |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public var _encodedOffsetRange: Range<Int> { |
| return startIndex.encodedOffset..<endIndex.encodedOffset |
| } |
| } |
| |
| extension Substring : CustomReflectable { |
| @inlinable // FIXME(sil-serialize-all) |
| public var customMirror: Mirror { |
| return String(self).customMirror |
| } |
| } |
| |
| extension Substring : CustomPlaygroundQuickLookable { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(*, deprecated, message: "Substring.customPlaygroundQuickLook will be removed in a future Swift version") |
| public var customPlaygroundQuickLook: PlaygroundQuickLook { |
| return String(self).customPlaygroundQuickLook |
| } |
| } |
| |
| extension Substring : CustomStringConvertible { |
| @inlinable // FIXME(sil-serialize-all) |
| public var description: String { |
| return String(self) |
| } |
| } |
| |
| extension Substring : CustomDebugStringConvertible { |
| @inlinable // FIXME(sil-serialize-all) |
| public var debugDescription: String { |
| return String(self).debugDescription |
| } |
| } |
| |
| extension Substring : LosslessStringConvertible { |
| @inlinable // FIXME(sil-serialize-all) |
| public init(_ content: String) { |
| self.init(_base: content, content.startIndex ..< content.endIndex) |
| } |
| } |
| |
| |
| % for (property, ViewPrefix) in [ |
| % ('utf8', 'UTF8'), |
| % ('utf16', 'UTF16'), |
| % ('unicodeScalars', 'UnicodeScalar'), |
| % ('characters', 'Character') |
| % ]: |
| % View = ViewPrefix + 'View' |
| % _View = '_CharacterView' if property == 'characters' else View |
| % _property = '_characters' if property == 'characters' else property |
| % |
| extension Substring { |
| % if View == 'CharacterView': |
| @available(swift, deprecated: 3.2, message: |
| "Please use String or Substring directly") |
| public typealias CharacterView = _CharacterView |
| % end |
| |
| @_fixed_layout // FIXME(sil-serialize-all) |
| public struct ${_View} { |
| @usableFromInline // FIXME(sil-serialize-all) |
| internal var _slice: Slice<String.${_View}> |
| } |
| } |
| |
| extension Substring.${_View} : BidirectionalCollection { |
| public typealias Index = String.Index |
| |
| /// Creates an instance that slices `base` at `_bounds`. |
| @inlinable // FIXME(sil-serialize-all) |
| internal init(_ base: String.${_View}, _bounds: Range<Index>) { |
| _slice = Slice( |
| base: String(base._guts).${_property}, |
| bounds: _bounds) |
| } |
| |
| /// The entire String onto whose slice this view is a projection. |
| @inlinable // FIXME(sil-serialize-all) |
| internal var _wholeString: String { |
| return String(_slice._base._guts) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| internal var _encodedOffsetRange: Range<Int> { |
| return startIndex.encodedOffset..<endIndex.encodedOffset |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public var startIndex: Index { return _slice.startIndex } |
| @inlinable // FIXME(sil-serialize-all) |
| public var endIndex: Index { return _slice.endIndex } |
| @inlinable // FIXME(sil-serialize-all) |
| public func index(after i: Index) -> Index { |
| return _slice.index(after: i) |
| } |
| @inlinable // FIXME(sil-serialize-all) |
| public func index(before i: Index) -> Index { |
| return _slice.index(before: i) |
| } |
| @inlinable // FIXME(sil-serialize-all) |
| public subscript(i: Index) -> String.${View}.Element { |
| return _slice[i] |
| } |
| @inlinable // FIXME(sil-serialize-all) |
| % if property == 'characters': |
| @available(swift, deprecated: 3.2, message: |
| "Please use String or Substring directly") |
| % end |
| public subscript(r: Range<Index>) -> Substring.${View} { |
| // FIXME(strings): tests. |
| _precondition(r.lowerBound >= startIndex && r.upperBound <= endIndex, |
| "${View} index range out of bounds") |
| return Substring.${_View}(_wholeString.${_property}, _bounds: r) |
| } |
| } |
| |
| extension Substring { |
| % if View == 'CharacterView': |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, deprecated: 3.2, message: |
| "Please use String or Substring directly") |
| public var characters: CharacterView { |
| get { |
| return _characters |
| } |
| set { |
| _characters = newValue |
| } |
| } |
| % end |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public var ${_property}: ${_View} { |
| get { |
| return ${_View}(_wholeString.${_property}, _bounds: startIndex..<endIndex) |
| } |
| set { |
| self = Substring(newValue) |
| } |
| } |
| |
| /// Creates a Substring having the given content. |
| /// |
| /// - Complexity: O(1) |
| @inlinable // FIXME(sil-serialize-all) |
| public init(_ content: ${View}) { |
| self = content._wholeString[content.startIndex..<content.endIndex] |
| } |
| } |
| |
| extension String { |
| % if property in ('utf8', 'utf16'): |
| /// Creates a String having the given content. |
| /// |
| /// If `codeUnits` is an ill-formed code unit sequence, the result is `nil`. |
| /// |
| /// - Complexity: O(N), where N is the length of the resulting `String`'s |
| /// UTF-16. |
| @inlinable // FIXME(sil-serialize-all) |
| public init?(_ codeUnits: Substring.${View}) { |
| let wholeString = codeUnits._wholeString |
| guard |
| codeUnits.startIndex.samePosition(in: wholeString.unicodeScalars) != nil |
| && codeUnits.endIndex.samePosition(in: wholeString.unicodeScalars) != nil |
| else { return nil } |
| self = String(Substring(codeUnits)) |
| } |
| % else: |
| /// Creates a String having the given content. |
| /// |
| /// - Complexity: O(N), where N is the length of the resulting `String`'s |
| /// UTF-16. |
| @inlinable // FIXME(sil-serialize-all) |
| % if property == 'characters': |
| @available(swift, deprecated: 3.2, message: |
| "Please use String or Substring directly") |
| % end |
| public init(_ content: Substring.${View}) { |
| self = String(Substring(content)) |
| } |
| % end |
| } |
| % end |
| |
| // FIXME: The other String views should be RangeReplaceable too. |
| extension Substring.UnicodeScalarView : RangeReplaceableCollection { |
| @inlinable // FIXME(sil-serialize-all) |
| public init() { _slice = Slice.init() } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public mutating func replaceSubrange<C : Collection>( |
| _ target: Range<Index>, with replacement: C |
| ) where C.Element == Element { |
| _slice.replaceSubrange(target, with: replacement) |
| } |
| } |
| |
| extension Substring : RangeReplaceableCollection { |
| @inlinable // FIXME(sil-serialize-all) |
| public init<S : Sequence>(_ elements: S) |
| where S.Element == Character { |
| let e0 = elements as? _SwiftStringView |
| if _fastPath(e0 != nil), let e = e0 { |
| self.init(e._wholeString._guts, e._encodedOffsetRange) |
| } else { |
| self.init(String(elements)) |
| } |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public mutating func append<S : Sequence>(contentsOf elements: S) |
| where S.Element == Character { |
| var string = String(self) |
| self = Substring() // Keep unique storage if possible |
| string.append(contentsOf: elements) |
| self = Substring(string) |
| } |
| } |
| |
| extension Substring { |
| @inlinable // FIXME(sil-serialize-all) |
| public func lowercased() -> String { |
| return String(self).lowercased() |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func uppercased() -> String { |
| return String(self).uppercased() |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| public func filter( |
| _ isIncluded: (Element) throws -> Bool |
| ) rethrows -> String { |
| return try String(self.lazy.filter(isIncluded)) |
| } |
| } |
| |
| extension Substring : TextOutputStream { |
| @inlinable // FIXME(sil-serialize-all) |
| public mutating func write(_ other: String) { |
| append(contentsOf: other) |
| } |
| } |
| |
| extension Substring : TextOutputStreamable { |
| @inlinable // FIXME(sil-serialize-all) |
| public func write<Target : TextOutputStream>(to target: inout Target) { |
| target.write(String(self)) |
| } |
| } |
| |
| extension Substring : ExpressibleByUnicodeScalarLiteral { |
| @inlinable // FIXME(sil-serialize-all) |
| public init(unicodeScalarLiteral value: String) { |
| self.init(_base: value, value.startIndex ..< value.endIndex) |
| } |
| } |
| extension Substring : ExpressibleByExtendedGraphemeClusterLiteral { |
| @inlinable // FIXME(sil-serialize-all) |
| public init(extendedGraphemeClusterLiteral value: String) { |
| self.init(_base: value, value.startIndex ..< value.endIndex) |
| } |
| } |
| |
| extension Substring : ExpressibleByStringLiteral { |
| @inlinable // FIXME(sil-serialize-all) |
| public init(stringLiteral value: String) { |
| self.init(_base: value, value.startIndex ..< value.endIndex) |
| } |
| } |
| |
| //===--- String/Substring Slicing Support ---------------------------------===// |
| /// In Swift 3.2, in the absence of type context, |
| /// |
| /// someString[someString.startIndex..<someString.endIndex] |
| /// |
| /// was deduced to be of type `String`. Therefore have a more-specific |
| /// Swift-3-only `subscript` overload on `String` (and `Substring`) that |
| /// continues to produce `String`. |
| extension String { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, introduced: 4) |
| public subscript(r: Range<Index>) -> Substring { |
| _boundsCheck(r) |
| return Substring( |
| _slice: Slice(base: self, bounds: r)) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, obsoleted: 4) |
| public subscript(bounds: Range<Index>) -> String { |
| _boundsCheck(bounds) |
| return String(Substring(_slice: Slice(base: self, bounds: bounds))) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, obsoleted: 4) |
| public subscript(bounds: ClosedRange<Index>) -> String { |
| _boundsCheck(bounds) |
| return String(Substring(_slice: Slice( |
| base: self, |
| bounds: bounds.relative(to: self)))) |
| } |
| } |
| |
| extension Substring { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, introduced: 4) |
| public subscript(r: Range<Index>) -> Substring { |
| return Substring(_slice: _slice[r]) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, obsoleted: 4) |
| public subscript(bounds: Range<Index>) -> String { |
| return String(Substring(_slice: _slice[bounds])) |
| } |
| |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, obsoleted: 4) |
| public subscript(bounds: ClosedRange<Index>) -> String { |
| return self[bounds.relative(to: self)] |
| } |
| } |
| //===----------------------------------------------------------------------===// |
| |
| // popFirst() is only present when a collection is its own subsequence. This was |
| // dropped in Swift 4. |
| extension String { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, deprecated: 3.2, obsoleted: 4, message: |
| "Please use 'first', 'dropFirst()', or 'Substring.popFirst()'.") |
| public mutating func popFirst() -> String.Element? { |
| guard !isEmpty else { return nil } |
| let element = first! |
| let nextIdx = self.index(after: self.startIndex) |
| self = String(self[nextIdx...]) |
| return element |
| } |
| } |
| extension String._CharacterView { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, deprecated: 3.2, obsoleted: 4, message: |
| "Please use 'first', 'dropFirst()', or 'Substring.CharacterView.popFirst()'.") |
| public mutating func popFirst() -> String._CharacterView.Element? { |
| guard !isEmpty else { return nil } |
| let element = first! |
| let nextIdx = self.index(after: self.startIndex) |
| self = String(self[nextIdx...])._characters |
| return element |
| } |
| } |
| extension String.UnicodeScalarView { |
| @inlinable // FIXME(sil-serialize-all) |
| @available(swift, deprecated: 3.2, obsoleted: 4, message: |
| "Please use 'first', 'dropFirst()', or 'Substring.UnicodeScalarView.popFirst()'.") |
| public mutating func popFirst() -> String.UnicodeScalarView.Element? { |
| guard !isEmpty else { return nil } |
| let element = first! |
| let nextIdx = self.index(after: self.startIndex) |
| self = String(self[nextIdx...]).unicodeScalars |
| return element |
| } |
| } |