title: Singleton pattern and proper use of Alamofire's URLRequestConvertible
body: <p>This is a 2 part question the first is similar to this question here: <a href="https://stackoverflow.com/questions/28333241/proper-usage-of-the-alamofires-urlrequestconvertible">Proper usage of the Alamofire&#39;s URLRequestConvertible</a>. But I need a little more help!</p>
  
  <p>1) Do I create an enum router which implements URLRequestConvertible for each model in my model layer?</p>
  
  <p>The alamofire github page provides an example of a router which i've copied  here:</p>
  
  <pre><code>  enum Router: URLRequestConvertible {
      static let baseURLString = "http://example.com"
      static var OAuthToken: String?
  
      case CreateUser([String: AnyObject])
      case ReadUser(String)
      case UpdateUser(String, [String: AnyObject])
      case DestroyUser(String)
  
      var method: Alamofire.Method {
          switch self {
          case .CreateUser:
              return .POST
          case .ReadUser:
              return .GET
          case .UpdateUser:
              return .PUT
          case .DestroyUser:
              return .DELETE
          }
      }
  
      var path: String {
          switch self {
          case .CreateUser:
              return "/users"
          case .ReadUser(let username):
              return "/users/\(username)"
          case .UpdateUser(let username, _):
              return "/users/\(username)"
          case .DestroyUser(let username):
              return "/users/\(username)"
          }
      }
  
      // MARK: URLRequestConvertible
  
      var URLRequest: NSURLRequest {
          let URL = NSURL(string: Router.baseURLString)!
          let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
          mutableURLRequest.HTTPMethod = method.rawValue
  
          if let token = Router.OAuthToken {
              mutableURLRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
          }
  
          switch self {
          case .CreateUser(let parameters):
              return Alamofire.ParameterEncoding.JSON.encode(mutableURLRequest, parameters: parameters).0
          case .UpdateUser(_, let parameters):
              return Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: parameters).0
          default:
              return mutableURLRequest
          }
      }
  }
  </code></pre>
  
  <p>When I look at this (i'm new at swift so please bear with me >_&lt;) I see operations on a user object; they are creating a user, updating a user etc... So, if I had model objects person, company, location in my model layer, would I create a router for each model object? </p>
  
  <p>2) When interacting heavily with an API, I'm used to creating a "network manager" singleton to abstract away the network layer and to hold headers and the baseurl for that API. The alamofire has a "Manager" described here:</p>
  
  <blockquote>
    <p>Top-level convenience methods like Alamofire.request use a shared instance of Alamofire.Manager, which is configured with the default NSURLSessionConfiguration. As such, the following two statements are equivalent:</p>
  </blockquote>
  
  <pre><code>Alamofire.request(.GET, "http://httpbin.org/get")
  
  let manager = Alamofire.Manager.sharedInstance
  manager.request(NSURLRequest(URL: NSURL(string: "http://httpbin.org/get")))
  </code></pre>
  
  <p>is this manager what I should be using as my singleton? If so, how do I set the baseurl on the manager? Also, if I use this manager does / can this work together with the router construct shown above (with each model object setting it's baseurl and NSURLRquest)? If so can you provide a simple example?</p>
  
  <p>I'm new to the Alamofire library and swift. So, I know there are a lot of holes in my understanding but I'm just trying to understand the best that I can! Any info helps. Thanks.</p>