0001    //
0002    //  URITemplate.swift
0003    //  URITemplate
0004    //
0005    //  Created by Kyle Fuller on 25/11/2014.
0006    //  Copyright (c) 2014 Kyle Fuller. All rights reserved.
0007    //
0008    
0009    import Foundation
0010    
0011    // MARK: URITemplate
0012    
0013    /// A data structure to represent an RFC6570 URI template.
0014    public struct URITemplate
URITemplate.swift:227
public func ==(lhs:URITemplate, rhs:URITemplate) -> Bool {
URITemplate.swift:227
public func ==(lhs:URITemplate, rhs:URITemplate) -> Bool {
 : CustomStringConvertible, Equatable, Hashable, StringLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, UnicodeScalarLiteralConvertible {
0015      /// The underlying URI template
0016      public let template
URITemplate.swift:43
    self.template = template
URITemplate.swift:48
    template = value
URITemplate.swift:53
    template = value
URITemplate.swift:57
    template = value
URITemplate.swift:62
    return template
URITemplate.swift:66
    return template.hashValue
URITemplate.swift:71
    let expressions = regex.matches(template).map { expression in
URITemplate.swift:100
    return regex.substitute(template) { string in
URITemplate.swift:185
    let pattern = regex.substitute(self.template) { expression in
URITemplate.swift:228
  return lhs.template == rhs.template
URITemplate.swift:228
  return lhs.template == rhs.template
:String
0017    
0018      var regex
URITemplate.swift:71
    let expressions = regex.matches(template).map { expression in
URITemplate.swift:100
    return regex.substitute(template) { string in
:NSRegularExpression {
0019        let expression: NSRegularExpression?
0020        do {
0021          expression = try NSRegularExpression(pattern: "\\{([^\\}]+)\\}", options: NSRegularExpressionOptions(rawValue: 0))
0022        } catch let error as NSError {
0023          fatalError("Invalid Regex \(error)")
0024        }
0025        return expression!
0026      }
0027    
0028      var operators
URITemplate.swift:79
      for op in self.operators {
URITemplate.swift:104
      var op = self.operators.filter {
URITemplate.swift:115
        op = self.operators.first
URITemplate.swift:167
    let op = operators.filter {
:[Operator] {
0029        return [
0030          StringExpansion(),
0031          ReservedExpansion(),
0032          FragmentExpansion(),
0033          LabelExpansion(),
0034          PathSegmentExpansion(),
0035          PathStyleParameterExpansion(),
0036          FormStyleQueryExpansion(),
0037          FormStyleQueryContinuation(),
0038        ]
0039      }
0040    
0041      /// Initialize a URITemplate with the given template
0042      public init(template:String) {
0043        self.template = template
0044      }
0045    
0046      public typealias ExtendedGraphemeClusterLiteralType
URITemplate.swift:47
  public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) {
 = StringLiteralType
0047      public init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType) {
0048        template = value
0049      }
0050    
0051      public typealias UnicodeScalarLiteralType
URITemplate.swift:52
  public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) {
 = StringLiteralType
0052      public init(unicodeScalarLiteral value: UnicodeScalarLiteralType) {
0053        template = value
0054      }
0055    
0056      public init(stringLiteral value: StringLiteralType) {
0057        template = value
0058      }
0059    
0060      /// Returns a description of the URITemplate
0061      public var description:String {
0062        return template
0063      }
0064    
0065      public var hashValue:Int {
0066        return template.hashValue
0067      }
0068    
0069      /// Returns the set of keywords in the URI Template
0070      public var variables
URITemplate.swift:212
        for (index, variable) in variables.enumerate() {
:[String] {
0071        let expressions = regex.matches(template).map { expression in
0072          // Removes the { and } from the expression
0073          expression.substringWithRange(expression.startIndex.successor()..<expression.endIndex.predecessor())
0074        }
0075    
0076        return expressions.map { expression -> [String] in
0077          var expression = expression
0078    
0079          for op in self.operators {
0080            if let op = op.op {
0081              if expression.hasPrefix(op) {
0082                expression = expression.substringFromIndex(expression.startIndex.successor())
0083                break
0084              }
0085            }
0086          }
0087    
0088          return expression.componentsSeparatedByString(",").map { component in
0089            if component.hasSuffix("*") {
0090              return component.substringToIndex(component.endIndex.predecessor())
0091            } else {
0092              return component
0093            }
0094          }
0095        }.reduce([], combine: +)
0096      }
0097    
0098      /// Expand template as a URI Template using the given variables
0099      public func expand(variables:[String:AnyObject]) -> String {
0100        return regex.substitute(template) { string in
0101          var expression = string.substringWithRange(string.startIndex.successor()..<string.endIndex.predecessor())
0102          let firstCharacter = expression.substringToIndex(expression.startIndex.successor())
0103    
0104          var op = self.operators.filter {
0105            if let op = $0.op {
0106              return op == firstCharacter
0107            }
0108    
0109            return false
0110          }.first
0111    
0112          if (op != nil) {
0113            expression = expression.substringFromIndex(expression.startIndex.successor())
0114          } else {
0115            op = self.operators.first
0116          }
0117    
0118          let rawExpansions = expression.componentsSeparatedByString(",").map { vari -> String? in
0119            var variable = vari
0120            var prefix:Int?
0121    
0122            if let range = variable.rangeOfString(":") {
0123              prefix = Int(variable.substringFromIndex(range.endIndex))
0124              variable = variable.substringToIndex(range.startIndex)
0125            }
0126    
0127            let explode = variable.hasSuffix("*")
0128    
0129            if explode {
0130              variable = variable.substringToIndex(variable.endIndex.predecessor())
0131            }
0132    
0133            if let value:AnyObject = variables[variable] {
0134              return op!.expand(variable, value: value, explode: explode, prefix:prefix)
0135            }
0136    
0137            return op!.expand(variable, value:nil, explode:false, prefix:prefix)
0138          }
0139    
0140          let expansions = rawExpansions.reduce([], combine: { (accumulator, expansion) -> [String] in
0141            if let expansion = expansion {
0142              return accumulator + [expansion]
0143            }
0144    
0145            return accumulator
0146          })
0147    
0148          if expansions.count > 0 {
0149            return op!.prefix + expansions.joinWithSeparator(op!.joiner)
0150          }
0151    
0152          return ""
0153        }
0154      }
0155    
0156      func regexForVariable
URITemplate.swift:176
      return self.regexForVariable(variable, op: op)
(variable:String, op:Operator?) -> String {
0157        if op != nil {
0158          return "(.*)"
0159        } else {
0160          return "([A-z0-9%_\\-]+)"
0161        }
0162      }
0163    
0164      func regexForExpression
URITemplate.swift:189
        return self.regexForExpression(expression.substringWithRange(startIndex..<endIndex))
(expression:String) -> String {
0165        var expression = expression
0166    
0167        let op = operators.filter {
0168          $0.op != nil && expression.hasPrefix($0.op!)
0169        }.first
0170    
0171        if op != nil {
0172          expression = expression.substringWithRange(expression.startIndex.successor()..<expression.endIndex)
0173        }
0174    
0175        let regexes = expression.componentsSeparatedByString(",").map { variable -> String in
0176          return self.regexForVariable(variable, op: op)
0177        }
0178    
0179        return regexes.joinWithSeparator((op ?? StringExpansion()).joiner)
0180      }
0181    
0182      var extractionRegex
URITemplate.swift:204
    if let expression = extractionRegex {
:NSRegularExpression? {
0183        let regex = try! NSRegularExpression(pattern: "(\\{([^\\}]+)\\})|[^(.*)]", options: NSRegularExpressionOptions(rawValue: 0))
0184    
0185        let pattern = regex.substitute(self.template) { expression in
0186          if expression.hasPrefix("{") && expression.hasSuffix("}") {
0187            let startIndex = expression.startIndex.successor()
0188            let endIndex = expression.endIndex.predecessor()
0189            return self.regexForExpression(expression.substringWithRange(startIndex..<endIndex))
0190          } else {
0191            return NSRegularExpression.escapedPatternForString(expression)
0192          }
0193        }
0194    
0195        do {
0196          return try NSRegularExpression(pattern: "^\(pattern)$", options: NSRegularExpressionOptions(rawValue: 0))
0197        } catch _ {
0198          return nil
0199        }
0200      }
0201    
0202      /// Extract the variables used in a given URL
0203      public func extract(url:String) -> [String:String]? {
0204        if let expression = extractionRegex {
0205          let input = url as NSString
0206          let range = NSRange(location: 0, length: input.length)
0207          let results = expression.matchesInString(url, options: NSMatchingOptions(rawValue: 0), range: range)
0208    
0209          if let result = results.first {
0210            var extractedVariables = Dictionary<String, String>()
0211    
0212            for (index, variable) in variables.enumerate() {
0213              let range = result.rangeAtIndex(index + 1)
0214              let value = input.substringWithRange(range).stringByRemovingPercentEncoding
0215              extractedVariables[variable] = value
0216            }
0217    
0218            return extractedVariables
0219          }
0220        }
0221    
0222        return nil
0223      }
0224    }
0225    
0226    /// Determine if two URITemplate's are equivalent
0227    public func ==(lhs:URITemplate, rhs:URITemplate) -> Bool {
0228      return lhs.template == rhs.template
0229    }
0230    
0231    // MARK: Extensions
0232    
0233    extension NSRegularExpression {
0234      func substitute
URITemplate.swift:100
    return regex.substitute(template) { string in
URITemplate.swift:185
    let pattern = regex.substitute(self.template) { expression in
(string:String, block:((String) -> (String))) -> String {
0235        let oldString = string as NSString
0236        let range = NSRange(location: 0, length: oldString.length)
0237        var newString = string as NSString
0238    
0239        let matches = matchesInString(string, options: NSMatchingOptions(rawValue: 0), range: range)
0240        for match in Array(matches.reverse()) {
0241          let expression = oldString.substringWithRange(match.range)
0242          let replacement = block(expression)
0243          newString = newString.stringByReplacingCharactersInRange(match.range, withString: replacement)
0244        }
0245    
0246        return newString as String
0247      }
0248    
0249      func matches
URITemplate.swift:71
    let expressions = regex.matches(template).map { expression in
(string:String) -> [String] {
0250        let input = string as NSString
0251        let range = NSRange(location: 0, length: input.length)
0252        let results = matchesInString(string, options: NSMatchingOptions(rawValue: 0), range: range)
0253    
0254        return results.map { result -> String in
0255          return input.substringWithRange(result.range)
0256        }
0257      }
0258    }
0259    
0260    extension String {
0261      func percentEncoded
URITemplate.swift:350
    return value.percentEncoded()
URITemplate.swift:383
    return value.percentEncoded()
URITemplate.swift:421
    return value.percentEncoded()
URITemplate.swift:472
    return value.percentEncoded()
URITemplate.swift:528
    return value.percentEncoded()
() -> String {
0262        let allowedCharacters = NSCharacterSet(charactersInString: ":/?&=;+!@#$()',*").invertedSet
0263        return stringByAddingPercentEncodingWithAllowedCharacters(allowedCharacters)!
0264      }
0265    }
0266    
0267    // MARK: Operators
0268    
0269    protocol Operator
URITemplate.swift:28
  var operators:[Operator] {
URITemplate.swift:156
  func regexForVariable(variable:String, op:Operator?) -> String {
URITemplate.swift:344
class StringExpansion : BaseOperator, Operator {
URITemplate.swift:355
class ReservedExpansion : BaseOperator, Operator {
URITemplate.swift:366
class FragmentExpansion : BaseOperator, Operator {
URITemplate.swift:377
class LabelExpansion : BaseOperator, Operator {
URITemplate.swift:396
class PathSegmentExpansion : BaseOperator, Operator {
URITemplate.swift:415
class PathStyleParameterExpansion : BaseOperator, Operator {
URITemplate.swift:466
class FormStyleQueryExpansion : BaseOperator, Operator {
URITemplate.swift:522
class FormStyleQueryContinuation : BaseOperator, Operator {
 {
0270      /// Operator
0271      var op
URITemplate.swift:80
        if let op = op.op {
URITemplate.swift:105
        if let op = $0.op {
URITemplate.swift:168
      $0.op != nil && expression.hasPrefix($0.op!)
URITemplate.swift:168
      $0.op != nil && expression.hasPrefix($0.op!)
:String? { get }
0272    
0273      /// Prefix for the expanded string
0274      var prefix
URITemplate.swift:149
        return op!.prefix + expansions.joinWithSeparator(op!.joiner)
:String { get }
0275    
0276      /// Character to use to join expanded components
0277      var joiner
URITemplate.swift:149
        return op!.prefix + expansions.joinWithSeparator(op!.joiner)
URITemplate.swift:179
    return regexes.joinWithSeparator((op ?? StringExpansion()).joiner)
:String { get }
0278    
0279      func expand
URITemplate.swift:134
          return op!.expand(variable, value: value, explode: explode, prefix:prefix)
URITemplate.swift:137
        return op!.expand(variable, value:nil, explode:false, prefix:prefix)
(variable:String, value:AnyObject?, explode:Bool, prefix:Int?) -> String?
0280    }
0281    
0282    class BaseOperator
URITemplate.swift:344
class StringExpansion : BaseOperator, Operator {
URITemplate.swift:355
class ReservedExpansion : BaseOperator, Operator {
URITemplate.swift:366
class FragmentExpansion : BaseOperator, Operator {
URITemplate.swift:377
class LabelExpansion : BaseOperator, Operator {
URITemplate.swift:396
class PathSegmentExpansion : BaseOperator, Operator {
URITemplate.swift:415
class PathStyleParameterExpansion : BaseOperator, Operator {
URITemplate.swift:466
class FormStyleQueryExpansion : BaseOperator, Operator {
URITemplate.swift:522
class FormStyleQueryContinuation : BaseOperator, Operator {
 {
0283      var joiner
URITemplate.swift:320
    let joiner = explode ? self.joiner : ","
URITemplate.swift:326
    let joiner = explode ? self.joiner : ","
:String { return "," }
0284    
0285      func expand(variable:String, value:AnyObject?, explode:Bool, prefix:Int?) -> String? {
0286        if let value:AnyObject = value {
0287          if let values = value as? [String:AnyObject] {
0288            return expand(variable:variable, value: values, explode: explode)
0289          } else if let values = value as? [AnyObject] {
0290            return expand(variable:variable, value: values, explode: explode)
0291          } else if let _ = value as? NSNull {
0292            return expand(variable:variable)
0293          } else {
0294            return expand(variable:variable, value:"\(value)", prefix:prefix)
0295          }
0296        }
0297    
0298        return expand(variable:variable)
0299      }
0300    
0301      // Point to overide to expand a value (i.e, perform encoding)
0302      func expand
URITemplate.swift:311
        return expand(value: value.substringToIndex(index))
URITemplate.swift:315
    return expand(value: value)
URITemplate.swift:321
    return value.map { self.expand(value: "\($0)") }.joinWithSeparator(joiner)
URITemplate.swift:329
      let expandedKey = self.expand(value: key)
URITemplate.swift:330
      let expandedValue = self.expand(value: "\(value)")
(value  value:String) -> String {
0303        return value
0304      }
0305    
0306      // Point to overide to expanding a string
0307      func expand
URITemplate.swift:294
        return expand(variable:variable, value:"\(value)", prefix:prefix)
URITemplate.swift:426
      let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
URITemplate.swift:476
    let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
URITemplate.swift:532
    let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
(variable  variable:String, value:String, prefix:Int?) -> String {
0308        if let prefix = prefix {
0309          if value.characters.count > prefix {
0310            let index = value.startIndex.advancedBy(prefix, limit: value.endIndex)
0311            return expand(value: value.substringToIndex(index))
0312          }
0313        }
0314    
0315        return expand(value: value)
0316      }
0317    
0318      // Point to overide to expanding an array
0319      func expand
URITemplate.swift:290
        return expand(variable:variable, value: values, explode: explode)
URITemplate.swift:388
      return super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:407
      return super.expand(variable: variable, value: value, explode: explode)
(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0320        let joiner = explode ? self.joiner : ","
0321        return value.map { self.expand(value: "\($0)") }.joinWithSeparator(joiner)
0322      }
0323    
0324      // Point to overide to expanding a dictionary
0325      func expand
URITemplate.swift:288
        return expand(variable:variable, value: values, explode: explode)
URITemplate.swift:453
    let expandedValue = super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:506
      let expandedValue = super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:556
    let expandedValue = super.expand(variable: variable, value: value, explode: explode)
(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0326        let joiner = explode ? self.joiner : ","
0327        let keyValueJoiner = explode ? "=" : ","
0328        let elements = value.map({ (key, value) -> String in
0329          let expandedKey = self.expand(value: key)
0330          let expandedValue = self.expand(value: "\(value)")
0331          return "\(expandedKey)\(keyValueJoiner)\(expandedValue)"
0332        })
0333    
0334        return elements.joinWithSeparator(joiner)
0335      }
0336    
0337      // Point to overide when value not found
0338      func expand
URITemplate.swift:292
        return expand(variable:variable)
URITemplate.swift:298
    return expand(variable:variable)
(variable  variable:String) -> String? {
0339        return nil
0340      }
0341    }
0342    
0343    /// RFC6570 (3.2.2) Simple String Expansion: {var}
0344    class StringExpansion
URITemplate.swift:30
      StringExpansion(),
URITemplate.swift:179
    return regexes.joinWithSeparator((op ?? StringExpansion()).joiner)
 : BaseOperator, Operator {
0345      var op:String? { return nil }
0346      var prefix:String { return "" }
0347      override var joiner:String { return "," }
0348    
0349      override func expand(value  value:String) -> String {
0350        return value.percentEncoded()
0351      }
0352    }
0353    
0354    /// RFC6570 (3.2.3) Reserved Expansion: {+var}
0355    class ReservedExpansion
URITemplate.swift:31
      ReservedExpansion(),
 : BaseOperator, Operator {
0356      var op:String? { return "+" }
0357      var prefix:String { return "" }
0358      override var joiner:String { return "," }
0359    
0360      override func expand(value  value:String) -> String {
0361        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLQueryAllowedCharacterSet())!
0362      }
0363    }
0364    
0365    /// RFC6570 (3.2.4) Fragment Expansion {#var}
0366    class FragmentExpansion
URITemplate.swift:32
      FragmentExpansion(),
 : BaseOperator, Operator {
0367      var op:String? { return "#" }
0368      var prefix:String { return "#" }
0369      override var joiner:String { return "," }
0370    
0371      override func expand(value  value:String) -> String {
0372        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLFragmentAllowedCharacterSet())!
0373      }
0374    }
0375    
0376    /// RFC6570 (3.2.5) Label Expansion with Dot-Prefix: {.var}
0377    class LabelExpansion
URITemplate.swift:33
      LabelExpansion(),
 : BaseOperator, Operator {
0378      var op:String? { return "." }
0379      var prefix:String { return "." }
0380      override var joiner:String { return "." }
0381    
0382      override func expand(value  value:String) -> String {
0383        return value.percentEncoded()
0384      }
0385    
0386      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0387        if value.count > 0 {
0388          return super.expand(variable: variable, value: value, explode: explode)
0389        }
0390    
0391        return nil
0392      }
0393    }
0394    
0395    /// RFC6570 (3.2.6) Path Segment Expansion: {/var}
0396    class PathSegmentExpansion
URITemplate.swift:34
      PathSegmentExpansion(),
 : BaseOperator, Operator {
0397      var op:String? { return "/" }
0398      var prefix:String { return "/" }
0399      override var joiner:String { return "/" }
0400    
0401      override func expand(value  value:String) -> String {
0402        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLPathAllowedCharacterSet())!
0403      }
0404    
0405      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0406        if value.count > 0 {
0407          return super.expand(variable: variable, value: value, explode: explode)
0408        }
0409    
0410        return nil
0411      }
0412    }
0413    
0414    /// RFC6570 (3.2.7) Path-Style Parameter Expansion: {;var}
0415    class PathStyleParameterExpansion
URITemplate.swift:35
      PathStyleParameterExpansion(),
 : BaseOperator, Operator {
0416      var op:String? { return ";" }
0417      var prefix:String { return ";" }
0418      override var joiner
URITemplate.swift:434
    let joiner = explode ? self.joiner : ","
:String { return ";" }
0419    
0420      override func expand
URITemplate.swift:436
      let expandedValue = self.expand(value: "\($0)")
(value  value:String) -> String {
0421        return value.percentEncoded()
0422      }
0423    
0424      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0425        if value.characters.count > 0 {
0426          let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0427          return "\(variable)=\(expandedValue)"
0428        }
0429    
0430        return variable
0431      }
0432    
0433      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0434        let joiner = explode ? self.joiner : ","
0435        let expandedValue = value.map {
0436          let expandedValue = self.expand(value: "\($0)")
0437    
0438          if explode {
0439            return "\(variable)=\(expandedValue)"
0440          }
0441    
0442          return expandedValue
0443        }.joinWithSeparator(joiner)
0444    
0445        if !explode {
0446          return "\(variable)=\(expandedValue)"
0447        }
0448    
0449        return expandedValue
0450      }
0451    
0452      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0453        let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0454    
0455        if let expandedValue = expandedValue {
0456          if (!explode) {
0457            return "\(variable)=\(expandedValue)"
0458          }
0459        }
0460    
0461        return expandedValue
0462      }
0463    }
0464    
0465    /// RFC6570 (3.2.8) Form-Style Query Expansion: {?var}
0466    class FormStyleQueryExpansion
URITemplate.swift:36
      FormStyleQueryExpansion(),
 : BaseOperator, Operator {
0467      var op:String? { return "?" }
0468      var prefix:String { return "?" }
0469      override var joiner
URITemplate.swift:482
      let joiner = explode ? self.joiner : ","
:String { return "&" }
0470    
0471      override func expand
URITemplate.swift:484
        let expandedValue = self.expand(value: "\($0)")
URITemplate.swift:505
      let expandedVariable = self.expand(value: variable)
(value  value:String) -> String {
0472        return value.percentEncoded()
0473      }
0474    
0475      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0476        let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0477        return "\(variable)=\(expandedValue)"
0478      }
0479    
0480      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0481        if value.count > 0 {
0482          let joiner = explode ? self.joiner : ","
0483          let expandedValue = value.map {
0484            let expandedValue = self.expand(value: "\($0)")
0485    
0486            if explode {
0487              return "\(variable)=\(expandedValue)"
0488            }
0489    
0490            return expandedValue
0491          }.joinWithSeparator(joiner)
0492    
0493          if !explode {
0494            return "\(variable)=\(expandedValue)"
0495          }
0496    
0497          return expandedValue
0498        }
0499    
0500        return nil
0501      }
0502    
0503      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0504        if value.count > 0 {
0505          let expandedVariable = self.expand(value: variable)
0506          let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0507    
0508          if let expandedValue = expandedValue {
0509            if (!explode) {
0510              return "\(expandedVariable)=\(expandedValue)"
0511            }
0512          }
0513    
0514          return expandedValue
0515        }
0516    
0517        return nil
0518      }
0519    }
0520    
0521    /// RFC6570 (3.2.9) Form-Style Query Continuation: {&var}
0522    class FormStyleQueryContinuation
URITemplate.swift:37
      FormStyleQueryContinuation(),
 : BaseOperator, Operator {
0523      var op:String? { return "&" }
0524      var prefix:String { return "&" }
0525      override var joiner
URITemplate.swift:537
    let joiner = explode ? self.joiner : ","
:String { return "&" }
0526    
0527      override func expand
URITemplate.swift:539
      let expandedValue = self.expand(value: "\($0)")
(value  value:String) -> String {
0528        return value.percentEncoded()
0529      }
0530    
0531      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0532        let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0533        return "\(variable)=\(expandedValue)"
0534      }
0535    
0536      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0537        let joiner = explode ? self.joiner : ","
0538        let expandedValue = value.map {
0539          let expandedValue = self.expand(value: "\($0)")
0540    
0541          if explode {
0542            return "\(variable)=\(expandedValue)"
0543          }
0544    
0545          return expandedValue
0546        }.joinWithSeparator(joiner)
0547    
0548        if !explode {
0549          return "\(variable)=\(expandedValue)"
0550        }
0551    
0552        return expandedValue
0553      }
0554    
0555      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0556        let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0557    
0558        if let expandedValue = expandedValue {
0559          if (!explode) {
0560            return "\(variable)=\(expandedValue)"
0561          }
0562        }
0563    
0564        return expandedValue
0565      }
0566    }
0567