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:230
public func ==(lhs:URITemplate, rhs:URITemplate) -> Bool {
URITemplate.swift:230
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:231
  return lhs.template == rhs.template
URITemplate.swift:231
  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:215
        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:208
    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    #if os(Linux)
0192            return expression
0193    #else
0194            return NSRegularExpression.escapedPatternForString(expression)
0195    #endif
0196          }
0197        }
0198    
0199        do {
0200          return try NSRegularExpression(pattern: "^\(pattern)$", options: NSRegularExpressionOptions(rawValue: 0))
0201        } catch _ {
0202          return nil
0203        }
0204      }
0205    
0206      /// Extract the variables used in a given URL
0207      public func extract(url:String) -> [String:String]? {
0208        if let expression = extractionRegex {
0209          let range = NSRange(location: 0, length: url.characters.count)
0210          let results = expression.matchesInString(url, options: NSMatchingOptions(rawValue: 0), range: range)
0211    
0212          if let result = results.first {
0213            var extractedVariables = Dictionary<String, String>()
0214    
0215            for (index, variable) in variables.enumerate() {
0216              let range = result.rangeAtIndex(index + 1)
0217              let value = NSString(string: url).substringWithRange(range).stringByRemovingPercentEncoding
0218              extractedVariables[variable] = value
0219            }
0220    
0221            return extractedVariables
0222          }
0223        }
0224    
0225        return nil
0226      }
0227    }
0228    
0229    /// Determine if two URITemplate's are equivalent
0230    public func ==(lhs:URITemplate, rhs:URITemplate) -> Bool {
0231      return lhs.template == rhs.template
0232    }
0233    
0234    // MARK: Extensions
0235    
0236    extension NSRegularExpression {
0237      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 {
0238        let range = NSRange(location: 0, length: string.characters.count)
0239        var newString = string
0240    
0241        let matches = matchesInString(string, options: NSMatchingOptions(rawValue: 0), range: range)
0242        for match in Array(matches.reverse()) {
0243          let expression = NSString(string: string).substringWithRange(match.range)
0244          let replacement = block(expression)
0245          newString = NSString(string: newString).stringByReplacingCharactersInRange(match.range, withString: replacement)
0246        }
0247    
0248        return newString as String
0249      }
0250    
0251      func matches
URITemplate.swift:71
    let expressions = regex.matches(template).map { expression in
(string:String) -> [String] {
0252        let range = NSRange(location: 0, length: string.characters.count)
0253        let results = matchesInString(string, options: NSMatchingOptions(rawValue: 0), range: range)
0254    
0255        return results.map { result -> String in
0256          return NSString(string: string).substringWithRange(result.range)
0257        }
0258      }
0259    }
0260    
0261    extension String {
0262      func percentEncoded
URITemplate.swift:351
    return value.percentEncoded()
URITemplate.swift:384
    return value.percentEncoded()
URITemplate.swift:422
    return value.percentEncoded()
URITemplate.swift:473
    return value.percentEncoded()
URITemplate.swift:529
    return value.percentEncoded()
() -> String {
0263        let allowedCharacters = NSCharacterSet(charactersInString: ":/?&=;+!@#$()',*").invertedSet
0264        return stringByAddingPercentEncodingWithAllowedCharacters(allowedCharacters)!
0265      }
0266    }
0267    
0268    // MARK: Operators
0269    
0270    protocol Operator
URITemplate.swift:28
  var operators:[Operator] {
URITemplate.swift:156
  func regexForVariable(variable:String, op:Operator?) -> String {
URITemplate.swift:345
class StringExpansion : BaseOperator, Operator {
URITemplate.swift:356
class ReservedExpansion : BaseOperator, Operator {
URITemplate.swift:367
class FragmentExpansion : BaseOperator, Operator {
URITemplate.swift:378
class LabelExpansion : BaseOperator, Operator {
URITemplate.swift:397
class PathSegmentExpansion : BaseOperator, Operator {
URITemplate.swift:416
class PathStyleParameterExpansion : BaseOperator, Operator {
URITemplate.swift:467
class FormStyleQueryExpansion : BaseOperator, Operator {
URITemplate.swift:523
class FormStyleQueryContinuation : BaseOperator, Operator {
 {
0271      /// Operator
0272      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 }
0273    
0274      /// Prefix for the expanded string
0275      var prefix
URITemplate.swift:149
        return op!.prefix + expansions.joinWithSeparator(op!.joiner)
:String { get }
0276    
0277      /// Character to use to join expanded components
0278      var joiner
URITemplate.swift:149
        return op!.prefix + expansions.joinWithSeparator(op!.joiner)
URITemplate.swift:179
    return regexes.joinWithSeparator((op ?? StringExpansion()).joiner)
:String { get }
0279    
0280      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?
0281    }
0282    
0283    class BaseOperator
URITemplate.swift:345
class StringExpansion : BaseOperator, Operator {
URITemplate.swift:356
class ReservedExpansion : BaseOperator, Operator {
URITemplate.swift:367
class FragmentExpansion : BaseOperator, Operator {
URITemplate.swift:378
class LabelExpansion : BaseOperator, Operator {
URITemplate.swift:397
class PathSegmentExpansion : BaseOperator, Operator {
URITemplate.swift:416
class PathStyleParameterExpansion : BaseOperator, Operator {
URITemplate.swift:467
class FormStyleQueryExpansion : BaseOperator, Operator {
URITemplate.swift:523
class FormStyleQueryContinuation : BaseOperator, Operator {
 {
0284      var joiner
URITemplate.swift:321
    let joiner = explode ? self.joiner : ","
URITemplate.swift:327
    let joiner = explode ? self.joiner : ","
:String { return "," }
0285    
0286      func expand(variable:String, value:AnyObject?, explode:Bool, prefix:Int?) -> String? {
0287        if let value:AnyObject = value {
0288          if let values = value as? [String:AnyObject] {
0289            return expand(variable:variable, value: values, explode: explode)
0290          } else if let values = value as? [AnyObject] {
0291            return expand(variable:variable, value: values, explode: explode)
0292          } else if let _ = value as? NSNull {
0293            return expand(variable:variable)
0294          } else {
0295            return expand(variable:variable, value:"\(value)", prefix:prefix)
0296          }
0297        }
0298    
0299        return expand(variable:variable)
0300      }
0301    
0302      // Point to overide to expand a value (i.e, perform encoding)
0303      func expand
URITemplate.swift:312
        return expand(value: value.substringToIndex(index))
URITemplate.swift:316
    return expand(value: value)
URITemplate.swift:322
    return value.map { self.expand(value: "\($0)") }.joinWithSeparator(joiner)
URITemplate.swift:330
      let expandedKey = self.expand(value: key)
URITemplate.swift:331
      let expandedValue = self.expand(value: "\(value)")
(value  value:String) -> String {
0304        return value
0305      }
0306    
0307      // Point to overide to expanding a string
0308      func expand
URITemplate.swift:295
        return expand(variable:variable, value:"\(value)", prefix:prefix)
URITemplate.swift:427
      let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
URITemplate.swift:477
    let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
URITemplate.swift:533
    let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
(variable  variable:String, value:String, prefix:Int?) -> String {
0309        if let prefix = prefix {
0310          if value.characters.count > prefix {
0311            let index = value.startIndex.advancedBy(prefix, limit: value.endIndex)
0312            return expand(value: value.substringToIndex(index))
0313          }
0314        }
0315    
0316        return expand(value: value)
0317      }
0318    
0319      // Point to overide to expanding an array
0320      func expand
URITemplate.swift:291
        return expand(variable:variable, value: values, explode: explode)
URITemplate.swift:389
      return super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:408
      return super.expand(variable: variable, value: value, explode: explode)
(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0321        let joiner = explode ? self.joiner : ","
0322        return value.map { self.expand(value: "\($0)") }.joinWithSeparator(joiner)
0323      }
0324    
0325      // Point to overide to expanding a dictionary
0326      func expand
URITemplate.swift:289
        return expand(variable:variable, value: values, explode: explode)
URITemplate.swift:454
    let expandedValue = super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:507
      let expandedValue = super.expand(variable: variable, value: value, explode: explode)
URITemplate.swift:557
    let expandedValue = super.expand(variable: variable, value: value, explode: explode)
(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0327        let joiner = explode ? self.joiner : ","
0328        let keyValueJoiner = explode ? "=" : ","
0329        let elements = value.map({ (key, value) -> String in
0330          let expandedKey = self.expand(value: key)
0331          let expandedValue = self.expand(value: "\(value)")
0332          return "\(expandedKey)\(keyValueJoiner)\(expandedValue)"
0333        })
0334    
0335        return elements.joinWithSeparator(joiner)
0336      }
0337    
0338      // Point to overide when value not found
0339      func expand
URITemplate.swift:293
        return expand(variable:variable)
URITemplate.swift:299
    return expand(variable:variable)
(variable  variable:String) -> String? {
0340        return nil
0341      }
0342    }
0343    
0344    /// RFC6570 (3.2.2) Simple String Expansion: {var}
0345    class StringExpansion
URITemplate.swift:30
      StringExpansion(),
URITemplate.swift:179
    return regexes.joinWithSeparator((op ?? StringExpansion()).joiner)
 : BaseOperator, Operator {
0346      var op:String? { return nil }
0347      var prefix:String { return "" }
0348      override var joiner:String { return "," }
0349    
0350      override func expand(value  value:String) -> String {
0351        return value.percentEncoded()
0352      }
0353    }
0354    
0355    /// RFC6570 (3.2.3) Reserved Expansion: {+var}
0356    class ReservedExpansion
URITemplate.swift:31
      ReservedExpansion(),
 : BaseOperator, Operator {
0357      var op:String? { return "+" }
0358      var prefix:String { return "" }
0359      override var joiner:String { return "," }
0360    
0361      override func expand(value  value:String) -> String {
0362        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLQueryAllowedCharacterSet())!
0363      }
0364    }
0365    
0366    /// RFC6570 (3.2.4) Fragment Expansion {#var}
0367    class FragmentExpansion
URITemplate.swift:32
      FragmentExpansion(),
 : BaseOperator, Operator {
0368      var op:String? { return "#" }
0369      var prefix:String { return "#" }
0370      override var joiner:String { return "," }
0371    
0372      override func expand(value  value:String) -> String {
0373        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLFragmentAllowedCharacterSet())!
0374      }
0375    }
0376    
0377    /// RFC6570 (3.2.5) Label Expansion with Dot-Prefix: {.var}
0378    class LabelExpansion
URITemplate.swift:33
      LabelExpansion(),
 : BaseOperator, Operator {
0379      var op:String? { return "." }
0380      var prefix:String { return "." }
0381      override var joiner:String { return "." }
0382    
0383      override func expand(value  value:String) -> String {
0384        return value.percentEncoded()
0385      }
0386    
0387      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0388        if value.count > 0 {
0389          return super.expand(variable: variable, value: value, explode: explode)
0390        }
0391    
0392        return nil
0393      }
0394    }
0395    
0396    /// RFC6570 (3.2.6) Path Segment Expansion: {/var}
0397    class PathSegmentExpansion
URITemplate.swift:34
      PathSegmentExpansion(),
 : BaseOperator, Operator {
0398      var op:String? { return "/" }
0399      var prefix:String { return "/" }
0400      override var joiner:String { return "/" }
0401    
0402      override func expand(value  value:String) -> String {
0403        return value.stringByAddingPercentEncodingWithAllowedCharacters(NSCharacterSet.URLPathAllowedCharacterSet())!
0404      }
0405    
0406      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0407        if value.count > 0 {
0408          return super.expand(variable: variable, value: value, explode: explode)
0409        }
0410    
0411        return nil
0412      }
0413    }
0414    
0415    /// RFC6570 (3.2.7) Path-Style Parameter Expansion: {;var}
0416    class PathStyleParameterExpansion
URITemplate.swift:35
      PathStyleParameterExpansion(),
 : BaseOperator, Operator {
0417      var op:String? { return ";" }
0418      var prefix:String { return ";" }
0419      override var joiner
URITemplate.swift:435
    let joiner = explode ? self.joiner : ","
:String { return ";" }
0420    
0421      override func expand
URITemplate.swift:437
      let expandedValue = self.expand(value: "\($0)")
(value  value:String) -> String {
0422        return value.percentEncoded()
0423      }
0424    
0425      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0426        if value.characters.count > 0 {
0427          let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0428          return "\(variable)=\(expandedValue)"
0429        }
0430    
0431        return variable
0432      }
0433    
0434      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0435        let joiner = explode ? self.joiner : ","
0436        let expandedValue = value.map {
0437          let expandedValue = self.expand(value: "\($0)")
0438    
0439          if explode {
0440            return "\(variable)=\(expandedValue)"
0441          }
0442    
0443          return expandedValue
0444        }.joinWithSeparator(joiner)
0445    
0446        if !explode {
0447          return "\(variable)=\(expandedValue)"
0448        }
0449    
0450        return expandedValue
0451      }
0452    
0453      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0454        let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0455    
0456        if let expandedValue = expandedValue {
0457          if (!explode) {
0458            return "\(variable)=\(expandedValue)"
0459          }
0460        }
0461    
0462        return expandedValue
0463      }
0464    }
0465    
0466    /// RFC6570 (3.2.8) Form-Style Query Expansion: {?var}
0467    class FormStyleQueryExpansion
URITemplate.swift:36
      FormStyleQueryExpansion(),
 : BaseOperator, Operator {
0468      var op:String? { return "?" }
0469      var prefix:String { return "?" }
0470      override var joiner
URITemplate.swift:483
      let joiner = explode ? self.joiner : ","
:String { return "&" }
0471    
0472      override func expand
URITemplate.swift:485
        let expandedValue = self.expand(value: "\($0)")
URITemplate.swift:506
      let expandedVariable = self.expand(value: variable)
(value  value:String) -> String {
0473        return value.percentEncoded()
0474      }
0475    
0476      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0477        let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0478        return "\(variable)=\(expandedValue)"
0479      }
0480    
0481      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0482        if value.count > 0 {
0483          let joiner = explode ? self.joiner : ","
0484          let expandedValue = value.map {
0485            let expandedValue = self.expand(value: "\($0)")
0486    
0487            if explode {
0488              return "\(variable)=\(expandedValue)"
0489            }
0490    
0491            return expandedValue
0492          }.joinWithSeparator(joiner)
0493    
0494          if !explode {
0495            return "\(variable)=\(expandedValue)"
0496          }
0497    
0498          return expandedValue
0499        }
0500    
0501        return nil
0502      }
0503    
0504      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0505        if value.count > 0 {
0506          let expandedVariable = self.expand(value: variable)
0507          let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0508    
0509          if let expandedValue = expandedValue {
0510            if (!explode) {
0511              return "\(expandedVariable)=\(expandedValue)"
0512            }
0513          }
0514    
0515          return expandedValue
0516        }
0517    
0518        return nil
0519      }
0520    }
0521    
0522    /// RFC6570 (3.2.9) Form-Style Query Continuation: {&var}
0523    class FormStyleQueryContinuation
URITemplate.swift:37
      FormStyleQueryContinuation(),
 : BaseOperator, Operator {
0524      var op:String? { return "&" }
0525      var prefix:String { return "&" }
0526      override var joiner
URITemplate.swift:538
    let joiner = explode ? self.joiner : ","
:String { return "&" }
0527    
0528      override func expand
URITemplate.swift:540
      let expandedValue = self.expand(value: "\($0)")
(value  value:String) -> String {
0529        return value.percentEncoded()
0530      }
0531    
0532      override func expand(variable  variable:String, value:String, prefix:Int?) -> String {
0533        let expandedValue = super.expand(variable: variable, value: value, prefix: prefix)
0534        return "\(variable)=\(expandedValue)"
0535      }
0536    
0537      override func expand(variable  variable:String, value:[AnyObject], explode:Bool) -> String? {
0538        let joiner = explode ? self.joiner : ","
0539        let expandedValue = value.map {
0540          let expandedValue = self.expand(value: "\($0)")
0541    
0542          if explode {
0543            return "\(variable)=\(expandedValue)"
0544          }
0545    
0546          return expandedValue
0547        }.joinWithSeparator(joiner)
0548    
0549        if !explode {
0550          return "\(variable)=\(expandedValue)"
0551        }
0552    
0553        return expandedValue
0554      }
0555    
0556      override func expand(variable  variable:String, value:[String:AnyObject], explode:Bool) -> String? {
0557        let expandedValue = super.expand(variable: variable, value: value, explode: explode)
0558    
0559        if let expandedValue = expandedValue {
0560          if (!explode) {
0561            return "\(variable)=\(expandedValue)"
0562          }
0563        }
0564    
0565        return expandedValue
0566      }
0567    }
0568