0001    import Foundation
0002    
0003    /// A `MatchResult` encapsulates the result of a single match in a string,
0004    /// providing access to the matched string, as well as any capture groups within
0005    /// that string.
0006    public struct MatchResult
Regex.swift:70
  public func match(string: String) -> MatchResult? {
Regex.swift:73
      .map { MatchResult(string, $0) }
Regex.swift:87
  public func allMatches(string: String) -> [MatchResult] {
Regex.swift:90
      .map { MatchResult(string, $0) }
Regex.swift:109
  public static var lastMatch: MatchResult? {
Regex.swift:115
  private static var _lastMatch: MatchResult? {
 {
0007    
0008      // MARK: Accessing match results
0009    
0010      /// The entire matched string.
0011      ///
0012      /// Example:
0013      ///
0014      ///     let pattern = Regex("a*")
0015      ///
0016      ///     if let match = pattern.match("aaa") {
0017      ///       match.matchedString // "aaa"
0018      ///     }
0019      ///
0020      ///     if let match = pattern.match("bbb") {
0021      ///       match.matchedString // ""
0022      ///     }
0023      public var matchedString: String {
0024        return _result.matchedString
0025      }
0026    
0027      /// The range of the matched string.
0028      ///
0029      /// - note: This property currently assumes that it is always possible to
0030      ///   create a valid character range based on the underlying UTF-16 range.
0031      ///   If for some reason this turns out not to be true, it will trap.
0032      ///
0033      /// - returns: The character range of the matched string.
0034      internal var range
String+ReplaceMatching.swift:27
      replaceRange(match.range, with: replacement)
String+ReplaceMatching.swift:127
      replaceRange(match.range, with: replacement)
: Range<String.Index> {
0035        let utf16range = _result.range
0036        let start = String.Index(utf16range.startIndex, within: _string)!
0037        let end = String.Index(utf16range.endIndex, within: _string)!
0038        return start..<end
0039      }
0040    
0041      /// The matching string for each capture group in the regular expression
0042      /// (if any).
0043      ///
0044      /// **Note:** Usually if the match was successful, the captures will by
0045      /// definition be non-nil. However if a given capture group is optional, the
0046      /// captured string may also be nil, depending on the particular string that
0047      /// is being matched against.
0048      ///
0049      /// Example:
0050      ///
0051      ///     let regex = Regex("(a)?(b)")
0052      ///
0053      ///     regex.match("ab")?.captures // [Optional("a"), Optional("b")]
0054      ///     regex.match("b")?.captures // [nil, Optional("b")]
0055      public var captures: [String?] {
0056        return _result.captures
0057      }
0058    
0059      // MARK: Internal initialisers
0060    
0061      internal var matchResult
String+ReplaceMatching.swift:22
        .replacementStringForResult(match.matchResult,
String+ReplaceMatching.swift:122
        .replacementStringForResult(match.matchResult,
: NSTextCheckingResult {
0062        return _result.result
0063      }
0064    
0065      private let _result
MatchResult.swift:24
    return _result.matchedString
MatchResult.swift:35
    let utf16range = _result.range
MatchResult.swift:56
    return _result.captures
MatchResult.swift:62
    return _result.result
MatchResult.swift:69
    self._result = _MatchResult(string.utf16, result)
: _MatchResult
0066      private let _string
MatchResult.swift:36
    let start = String.Index(utf16range.startIndex, within: _string)!
MatchResult.swift:37
    let end = String.Index(utf16range.endIndex, within: _string)!
MatchResult.swift:70
    self._string = string
: String
0067    
0068      internal init
Regex.swift:73
      .map { MatchResult(string, $0) }
Regex.swift:90
      .map { MatchResult(string, $0) }
(_ string: String, _ result: NSTextCheckingResult) {
0069        self._result = _MatchResult(string.utf16, result)
0070        self._string = string
0071      }
0072    
0073    }
0074    
0075    // Use of a private class allows for lazy vars without the need for `mutating`.
0076    private final class _MatchResult
MatchResult.swift:65
  private let _result: _MatchResult
MatchResult.swift:69
    self._result = _MatchResult(string.utf16, result)
 {
0077    
0078      private let string
MatchResult.swift:82
    self.string = string
MatchResult.swift:104
    let start = string.startIndex.advancedBy(range.location)
MatchResult.swift:110
    return String(string[range])
: String.UTF16View
0079      private let result
MatchResult.swift:62
    return _result.result
MatchResult.swift:83
    self.result = result
MatchResult.swift:87
    return self.rangeFromNSRange(self.result.range)!
MatchResult.swift:95
    return self.result.ranges.dropFirst().map(self.rangeFromNSRange)
MatchResult.swift:99
    return self.substringFromRange(self.rangeFromNSRange(self.result.range)!)
: NSTextCheckingResult
0080    
0081      private init
MatchResult.swift:69
    self._result = _MatchResult(string.utf16, result)
(_ string: String.UTF16View, _ result: NSTextCheckingResult) {
0082        self.string = string
0083        self.result = result
0084      }
0085    
0086      lazy var range
MatchResult.swift:35
    let utf16range = _result.range
: Range<String.UTF16Index> = {
0087        return self.rangeFromNSRange(self.result.range)!
0088      }()
0089    
0090      lazy var captures
MatchResult.swift:56
    return _result.captures
: [String?] = {
0091        return self.captureRanges.map { $0.map(self.substringFromRange) }
0092      }()
0093    
0094      lazy var captureRanges
MatchResult.swift:91
    return self.captureRanges.map { $0.map(self.substringFromRange) }
: [Range<String.UTF16Index>?] = {
0095        return self.result.ranges.dropFirst().map(self.rangeFromNSRange)
0096      }()
0097    
0098      lazy var matchedString
MatchResult.swift:24
    return _result.matchedString
: String = {
0099        return self.substringFromRange(self.rangeFromNSRange(self.result.range)!)
0100      }()
0101    
0102      private func rangeFromNSRange
MatchResult.swift:87
    return self.rangeFromNSRange(self.result.range)!
MatchResult.swift:95
    return self.result.ranges.dropFirst().map(self.rangeFromNSRange)
MatchResult.swift:99
    return self.substringFromRange(self.rangeFromNSRange(self.result.range)!)
(range: NSRange) -> Range<String.UTF16Index>? {
0103        guard range.location != NSNotFound else { return nil }
0104        let start = string.startIndex.advancedBy(range.location)
0105        let end = start.advancedBy(range.length)
0106        return start..<end
0107      }
0108    
0109      private func substringFromRange
MatchResult.swift:91
    return self.captureRanges.map { $0.map(self.substringFromRange) }
MatchResult.swift:99
    return self.substringFromRange(self.rangeFromNSRange(self.result.range)!)
(range: Range<String.UTF16Index>) -> String {
0110        return String(string[range])
0111      }
0112    
0113    }
0114