docs/Classes/Router.html
public class Router
extension Router : RouterMiddleware
extension Router : ServerDelegate
Router provides the external interface for routing requests to the appropriate code to handle them. This includes:
RouterHandlerRouterMiddleware protocol.TemplateEngine to generate the appropriate output.Initializer
`
init(mergeParameters:enableWelcomePage:apiDocument:)
`
Initialize a Router instance.
let router = Router()
mergeParameters:When initialising a Router, mergeParameters allows you to control whether the router will be able to access parameters matched in its parent router. For instance, in the example below if mergeParameters is set to true, GET /Hello/Alex will return “Hello Alex”, but if set to false the greeting parameter will not be accessible and it will return just “ Alex”.
let router = Router()
let userRouter = Router(mergeParameters: true)
router.get("/:greeting") { request, response, _ in
let greeting = request.parameters["greeting"] ?? ""
try response.send("\(greeting)").end()
}
userRouter.get("/:user") { request, response, _ in
let user = request.parameters["user"] ?? ""
let greeting = request.parameters["greeting"] ?? ""
try response.send("\(greeting) \(user)").end()
}
router.all("/:greeting", middleware: userRouter)
Swift
public init(mergeParameters: Bool = false, enableWelcomePage: Bool = true, apiDocument: SwaggerDocument = SwaggerDocument())
| mergeParameters |
Optional parameter to specify if the router should be able to access parameters from its parent router. Defaults to false if not specified.
|
| enableWelcomePage |
Optional parameter to start and use the FileResourceServer to serve the default “Welcome to Kitura” page and related assets.
|
| apiDocument |
Optional parameter that allows customization of the OpenAPI document describing this Router.
|
Swagger
`
swaggerJSON
`
Returns the current in-memory representation of Codable routes as a Swagger document in JSON format, or nil if the document cannot be generated.
Swift
public var swaggerJSON: String? { get }
Custom encoder/decoder
`
encoders
`
A dictionary of MediaType to BodyEncoder generators. By default this includes an entry mapping the “application/json” media type to a JSONEncoder generator. When a Codable object is sent as a response, an encoder will be generated based on the “Accepts” header or using the defaultResponseMediaType if no matching encoder is found.
The example below replaces the default JSON encoder with a new encoder that has a different date encoding strategy.
let router = Router()
let newJSONEncoder: () -> BodyEncoder = {
let encoder = JSONEncoder()
encoder.dateEncodingStrategy = .secondsSince1970
return encoder
}
router.encoders[.json] = newJSONEncoder
In order for your OpenAPI (swagger) document to correctly represent an alternate Date encoding that you have chosen, you must configure your encoders before registering routes.
Swift
public var encoders: [MediaType : () -> BodyEncoder] { get set }
`
defaultResponseMediaType
`
if the request’s Accept header does not match an encoder, this media type will be used by the RouterResponse to select a BodyEncoder. By default, this is set to “application/json”.
The example below sets the defaultResponseMediaType as “application/x-yaml”.
let router = Router()
router.defaultResponseMediaType = MediaType(type: .application, subtype: "x-yaml")
Swift
public var defaultResponseMediaType: MediaType
`
decoders
`
A dictionary of MediaType to BodyDecoder generators. By default this includes an entry mapping the “application/json” media type to a JSONDecoder generator and an entry mapping “application/x-www-form-urlencoded” media type to QueryDecoder When a Codable object is read from the body of a request, a decoder will be generated based on the “Content-Type” header.
The example below replaces the default JSON decoder with a new decoder that has a different date encoding strategy.
let router = Router()
let newJSONDecoder: () -> BodyDecoder = {
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .secondsSince1970
return decoder
}
router.decoders[.json] = newJSONDecoder
Swift
public var decoders: [MediaType : () -> BodyDecoder] { get set }
Template Engine
`
viewsPath
`
The root directory where template files should be placed in order to be automatically handed over to an appropriate templating engine for content generation. The directory should sit at the same level as the project’s “Sources” directory. Defaults to “./Views/”.
The example below changes the directory where template files should be placed to be “./myViews/”
let router = Router()
router.viewsPath = "./myViews/"
Swift
public var viewsPath: String { get set }
`
add(templateEngine:forFileExtensions:useDefaultFileExtension:)
`
Register a template engine to a given router instance. A template engine allows rendering of documents using static templates.
By default the templating engine will handle files in the ./Views directory that match the file extension it supports. You can change this default location using the viewsPath property.
let router = Router()
router.add(templateEngine: MyTemplateEngine())
router.add(templateEngine: MyOtherTemplateEngine(), forFileExtensions: ["html"], useDefaultFileExtension: false)
If multiple different template engines are registered for the same extension, the template engine that is registered last will be the one that attempts to render all template files with the chosen extension.
Swift
public func add(templateEngine: TemplateEngine, forFileExtensions fileExtensions: [String] = [],
useDefaultFileExtension: Bool = true)
| templateEngine |
The templating engine to register.
|
| forFileExtensions |
The extensions of the files to apply the template engine on.
|
| useDefaultFileExtension |
The flag to specify if the default file extension of the template engine should be used. Defaults to true if not specified.
|
`
setDefault(templateEngine:)
`
Sets the default templating engine to be used when the extension of a file in the viewsPath doesn’t match the extension of one of the registered templating engines.
let router = Router()
router.setDefault(templateEngine: MyTemplateEngine())
If the template engine doesn’t provide a default extension you can provide one using add(templateEngine:forFileExtensions:useDefaultFileExtension:). If a router instance doesn’t have a template engine registered that can render the given template file a “No template engine defined for extension” TemplatingError is thrown.
Swift
public func setDefault(templateEngine: TemplateEngine?)
| templateEngine |
The templating engine to set as default.
|
Sub router
`
route(_:mergeParameters:allowPartialMatch:)
`
Set up a “sub router” to handle requests. Chaining a route handler onto another router can make it easier to build a server that serves a large set of paths. Each sub router handles all of the path mappings below its parent’s route path.
The example below shows how the route `/parent/child’ can be defined using a sub router.
let router = Router()
let parent = router.route("/parent")
parent.get("/child") { request, response, next in
// If allowPartialMatch was set to false, this would not be called.
}
Swift
public func route(_ route: String, mergeParameters: Bool = false, allowPartialMatch: Bool = true) -> Router
| route |
The path to bind the sub router to.
|
| mergeParameters |
Specify if this router should have access to path parameters matched in its parent router. Defaults to false if not specified.
|
| allowPartialMatch |
Specify if the sub router allows a match when additional paths are added. In the example above, the GET request to /parent/child would only succeed if allowPartialMatch is set to true. Defaults to true if not specified.
|
The sub router which has been created.
Parameter handling
`
parameter(_:handler:)
`
Set up handlers for a named request parameter. This can make it easier to handle multiple routes requiring the same parameter which needs to be handled in a certain way.
let router = Router()
router.parameter("id") { request, response, param, next in
if let _ = Int(param) {
// Id is an integer, continue
next()
}
else {
// Id is not an integer, error
try response.status(.badRequest).send("ID is not an integer").end()
}
}
router.get("/item/:id") { request, response, _ in
// This will only be reached if the id parameter is an integer
}
router.get("/user/:id") { request, response, _ in
// This will only be reached if the id parameter is an integer
}
Swift
@discardableResult
public func parameter(_ name: String, handler: RouterParameterHandler...) -> Router
| name |
The single parameter name to be handled.
|
| handler |
The comma delimited set of RouterParameterHandler instances that will be invoked when request parses a parameter with the specified name.
|
The current router instance.
`
parameter(_:handler:)
`
Set up handlers for a number of named request parameters. This can make it easier to handle multiple routes requiring similar parameters which need to be handled in a certain way.
let router = Router()
router.parameter(["id", "num"]) { request, response, param, next in
if let _ = Int(param) {
// Parameter is an integer, continue
next()
}
else {
// Parameter is not an integer, error
try response.status(.badRequest).send("\(param) is not an integer").end()
}
}
router.get("/item/:id/:num") { request, response, _ in
// This will only be reached if the id and num parameters are integers.
}
Swift
@discardableResult
public func parameter(_ names: [String], handler: RouterParameterHandler...) -> Router
| names |
The array of parameter names to be handled.
|
| handler |
The comma delimited set of RouterParameterHandler instances that will be invoked when request parses a parameter with the specified name.
|
The current router instance.
`
parameter(_:handlers:)
`
Set up handlers for a number of named request parameters. This can make it easier to handle multiple routes requiring similar parameters which need to be handled in a certain way.
let router = Router()
func handleInt(request: RouterRequest, response: RouterResponse, param: String, next: @escaping () -> Void) throws -> Void {
if let _ = Int(param) {
// Parameter is an integer, continue
}
else {
// Parameter is not an integer, error
try response.status(.badRequest).send("\(param) is not an integer").end()
}
next()
}
func handleItem(request: RouterRequest, response: RouterResponse, param: String, next: @escaping () -> Void) throws -> Void {
let itemId = Int(param) //This will only be reached if id is an integer
...
}
router.parameter(["id"], handlers: [handleInt, handleItem])
router.get("/item/:id/") { request, response, _ in
...
}
Swift
@discardableResult
public func parameter(_ names: [String], handlers: [RouterParameterHandler]) -> Router
| names |
The array of parameter names to be handled.
|
| handlers |
The array of RouterParameterHandler instances that will be invoked when request parses a parameter with the specified name. The handlers are executed in the order they are supplied.
|
The current router instance.
Codable Routing with TypeSafeMiddleware
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.
router.get("/user") { (session: MySession, respondWith: (User?, RequestError?) -> Void) in
guard let user: User = session.user else {
return respondWith(nil, .notFound)
}
respondWith(user, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
respondWith: (User?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, O: Codable>(
_ route: String,
handler: @escaping (T, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and returns a single Codable object or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User array, where User conforms to Codable.
router.get("/user") { (session: MySession, respondWith: ([User]?, RequestError?) -> Void) in
guard let user: [User] = session.user else {
return respondWith(nil, .notFound)
}
respondWith([user], nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
respondWith: ([User]?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, O: Codable>(
_ route: String,
handler: @escaping (T, @escaping CodableArrayResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and returns an array of Codable objects or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
router.get("/user") { (session: MySession, id: Int, respondWith: (User?, RequestError?) -> Void) in
guard let user: User = session.user[id] else {
return respondWith(nil, .notFound)
}
respondWith(user, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
respondWith: (User?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, Id: Identifier, O: Codable>(
_ route: String,
handler: @escaping (T, Id, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and an Identifier, and returns a single of Codable object or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with an array of (Identifier, Codable) tuples or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [(Int, User)] dictionary, where User conforms to Codable.
router.get("/user") { (session: MySession, respondWith: ([(Int, User)]?, RequestError?) -> Void) in
guard let users: [(Int, User)] = session.users else {
return respondWith(nil, .notFound)
}
respondWith(users, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
respondWith: ([(Int, User)]?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, Id: Identifier, O: Codable>(
_ route: String,
handler: @escaping (T, @escaping IdentifierCodableArrayResultClosure<Id, O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance, and returns an array of (Identifier, Codable) tuples or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
struct Query: QueryParams {
let id: Int
}
router.get("/user") { (session: MySession, query: Query, respondWith: (User?, RequestError?) -> Void) in
guard let user: User = session.user[query.id] else {
return respondWith(nil, .notFound)
}
respondWith(user, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: (User?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, Q: QueryParams, O: Codable>(
_ route: String,
handler: @escaping (T, Q, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and a QueryParams instance, and returns a single of Codable object or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: [User]] dictionary, where User conforms to Codable.
struct Query: QueryParams {
let id: Int
}
router.get("/user") { (session: MySession, query: Query, respondWith: ([User]?, RequestError?) -> Void) in
guard let user: [User] = session.user[query.id] else {
return respondWith(nil, .notFound)
}
respondWith(user, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: ([User]?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, Q: QueryParams, O: Codable>(
_ route: String,
handler: @escaping (T, Q, @escaping CodableArrayResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and a QueryParams instance, and returns an array of Codable objects or a RequestError.
|
`
get(_:handler:)
`
Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MyHTTPAuth is a struct that conforms to the TypeSafeHTTPBasic protocol from Kitura-CredentialsHTTP to provide basic HTTP authentication.
struct Query: QueryParams {
let id: Int
}
router.get("/user") { (auth: MyHTTPAuth, query: Query?, respondWith: ([User]?, RequestError?) -> Void) in
if let query = query {
let matchedUsers = userArray.filter { $0.id <= query.id }
return respondWith(matchedUsers, nil)
} else {
respondWith(userArray, nil)
}
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: ([User]?, RequestError?) -> Void) in
Swift
public func get<T: TypeSafeMiddleware, Q: QueryParams, O: Codable>(
_ route: String,
handler: @escaping (T, Q?, @escaping CodableArrayResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and a QueryParams instance, and returns an array of Codable objects or a RequestError.
|
`
delete(_:handler:)
`
Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.
router.delete("/user") { (session: MySession, respondWith: (RequestError?) -> Void) in
session.user: User? = nil
respondWith(nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
respondWith: (RequestError?) -> Void) in
Swift
public func delete<T: TypeSafeMiddleware>(
_ route: String,
handler: @escaping (T, @escaping ResultClosure) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware and returns a RequestError or nil on success.
|
`
delete(_:handler:)
`
Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
router.delete("/user") { (session: MySession, id: Int, respondWith: (RequestError?) -> Void) in
session.user[id] = nil
respondWith(nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
respondWith: (RequestError?) -> Void) in
Swift
public func delete<T: TypeSafeMiddleware, Id: Identifier>(
_ route: String,
handler: @escaping (T, Id, @escaping ResultClosure) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware and Identifier, and returns nil on success, or a RequestError.
|
`
delete(_:handler:)
`
Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
struct Query: QueryParams {
let id: Int
}
router.delete("/user") { (session: MySession, query: Query, respondWith: (RequestError?) -> Void) in
session.user[query.id] = nil
respondWith(nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: (RequestError?) -> Void) in
Swift
public func delete<T: TypeSafeMiddleware, Q: QueryParams>(
_ route: String,
handler: @escaping (T, Q, @escaping ResultClosure) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware and Identifier, and returns nil on success, or a RequestError.
|
`
delete(_:handler:)
`
Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MyHTTPAuth is a struct that conforms to the TypeSafeHTTPBasic protocol from Kitura-CredentialsHTTP to provide basic HTTP authentication.
struct Query: QueryParams {
let id: Int
}
router.delete("/user") { (auth: MyHTTPAuth, query: Query?, respondWith: (RequestError?) -> Void) in
if let query = query {
userArray = userArray.filter { $0.id != query.id }
return respondWith(nil)
} else {
userArray = []
return respondWith(nil)
}
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query?,
respondWith: (RequestError?) -> Void) in
Swift
public func delete<T: TypeSafeMiddleware, Q: QueryParams>(
_ route: String,
handler: @escaping (T, Q?, @escaping ResultClosure) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware and Identifier, and returns nil on success, or a RequestError.
|
`
post(_:handler:)
`
Sets up a closure that will be invoked when a POST request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.
router.post("/user") { (session: MySession, user: User, respondWith: (User?, RequestError?) -> Void) in
if session.user == nil {
return respondWith(nil, .badRequest)
} else {
session.user = user
respondWith(user, nil)
}
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.post("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, user: User,
respondWith: (User?, RequestError?) -> Void) in
Swift
public func post<T: TypeSafeMiddleware, I: Codable, O: Codable>(
_ route: String,
handler: @escaping (T, I, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and a Codable object, and returns a Codable object or a RequestError.
|
`
post(_:handler:)
`
Sets up a closure that will be invoked when a POST request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, a Codable object and a handler which responds with an Identifier and a Codable object, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
router.post("/user") { (session: MySession, user: User, respondWith: (Int?, User?, RequestError?) -> Void) in
let newId = session.users.count + 1
session.user[newId] = user
respondWith(newId, user, nil)
}
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.post("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, user: User, respondWith: (Int?, User?, RequestError?) -> Void) in
Swift
public func post<T: TypeSafeMiddleware, I: Codable, Id: Identifier, O: Codable>(
_ route: String,
handler: @escaping (T, I, @escaping IdentifierCodableResultClosure<Id, O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance and a Codable object, and returns an Identifier and a Codable object or a RequestError.
|
`
put(_:handler:)
`
Sets up a closure that will be invoked when a PUT request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
router.post("/user") { (session: MySession, id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in
session.user[id] = user
respondWith(user, nil)
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.put("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in
Swift
public func put<T: TypeSafeMiddleware, Id: Identifier, I: Codable, O: Codable>(
_ route: String,
handler: @escaping (T, Id, I, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance, an Identifier and a Codable object, and returns a Codable object or a RequestError.
|
`
patch(_:handler:)
`
Sets up a closure that will be invoked when a PATCH request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.
In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.
router.patch("/user") { (session: MySession, id: Int, inputUser: User, respondWith: (User?, RequestError?) -> Void) in
guard let user: User = session.user[id] else {
return respondWith(nil, .notFound)
}
user.id = inputUser.id ?? user.id
user.name = inputUser.name ?? user.name
respondWith(user, nil)
}
}
The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:
router.patch("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in
Swift
public func patch<T: TypeSafeMiddleware, Id: Identifier, I: Codable, O: Codable>(
_ route: String,
handler: @escaping (T, Id, I, @escaping CodableResultClosure<O>) -> Void
)
| route |
A String specifying the URL path that will invoke the handler.
|
| handler |
A closure that receives a TypeSafeMiddleware instance, an Identifier and a Codable object, and returns a Codable object or a RequestError.
|
Codable Routing
`
get(_:handler:)
`
Setup a CodableArrayClosure on the provided route which will be invoked when a request comes to the server.
//User is a struct object that conforms to Codable
router.get("/users") { (respondWith: ([User]?, RequestError?) -> Void) in
...
respondWith(users, nil)
}
Swift
public func get<O>(_ route: String, handler: @escaping CodableArrayClosure<O>) where O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A CodableArrayClosure that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a SimpleCodableClosure on the provided route which will be invoked when a request comes to the server.
//Status is a struct object that conforms to Codable
router.get("/status") { (respondWith: (Status?, RequestError?) -> Void) in
...
respondWith(status, nil)
}
Swift
public func get<O>(_ route: String, handler: @escaping SimpleCodableClosure<O>) where O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A SimpleCodableClosure that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a IdentifierSimpleCodableClosure on the provided route which will be invoked when a request comes to the server.
//User is a struct object that conforms to Codable
router.get("/users") { (id: Int, respondWith: (User?, RequestError?) -> Void) in
...
respondWith(user, nil)
}
Swift
public func get<Id, O>(_ route: String, handler: @escaping IdentifierSimpleCodableClosure<Id, O>) where Id : Identifier, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
An IdentifierSimpleCodableClosure that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a IdentifierCodableArrayClosure on the provided route which will be invoked when a request comes to the server.
//User is a struct object that conforms to Codable
router.get("/users") { (respondWith: ([(Int, User)]?, RequestError?) -> Void) in
...
respondWith([(Int, User)], nil)
}
Swift
public func get<Id, O>(_ route: String, handler: @escaping IdentifierCodableArrayClosure<Id, O>) where Id : Identifier, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A IdentifierCodableArrayClosure that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a (QueryParams, CodableArrayResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery, respondWith: ([User]?, RequestError?) -> Void) in
...
respondWith(users, nil)
}
Swift
public func get<Q, O>(_ route: String, handler: @escaping (Q, @escaping CodableArrayResultClosure<O>) -> Void) where Q : QueryParams, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams, CodableArrayResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a (QueryParams, CodableResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery, respondWith: (User?, RequestError?) -> Void) in
...
respondWith(user, nil)
}
Swift
public func get<Q, O>(_ route: String, handler: @escaping (Q, @escaping CodableResultClosure<O>) -> Void) where Q : QueryParams, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams, CodableResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a (QueryParams?, CodableArrayResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery?, respondWith: ([User]?, RequestError?) -> Void) in
...
respondWith(users, nil)
}
Swift
public func get<Q, O>(_ route: String, handler: @escaping (Q?, @escaping CodableArrayResultClosure<O>) -> Void) where Q : QueryParams, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams?, CodableArrayResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
get(_:handler:)
`
Setup a (QueryParams?, CodableResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery?, respondWith: (User?, RequestError?) -> Void) in
...
respondWith(user, nil)
}
Swift
public func get<Q, O>(_ route: String, handler: @escaping (Q?, @escaping CodableResultClosure<O>) -> Void) where Q : QueryParams, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams?, CodableResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
delete(_:handler:)
`
Setup a NonCodableClosure on the provided route which will be invoked when a request comes to the server.
router.delete("/users") { (respondWith: (RequestError?) -> Void) in
...
respondWith(nil)
}
Swift
public func delete(_ route: String, handler: @escaping NonCodableClosure)
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
An NonCodableClosure that gets invoked when a request comes to the server.
|
`
delete(_:handler:)
`
Setup a IdentifierNonCodableClosure on the provided route which will be invoked when a request comes to the server.
router.delete("/users") { (id: Int, respondWith: (RequestError?) -> Void) in
...
respondWith(nil)
}
Swift
public func delete<Id>(_ route: String, handler: @escaping IdentifierNonCodableClosure<Id>) where Id : Identifier
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
An IdentifierNonCodableClosure that gets invoked when a request comes to the server.
|
`
delete(_:handler:)
`
Setup a (QueryParams, ResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
router.delete("/query") { (query: MyQuery, respondWith: (RequestError?) -> Void) in
...
respondWith(nil)
}
Swift
public func delete<Q>(_ route: String, handler: @escaping (Q, @escaping ResultClosure) -> Void) where Q : QueryParams
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams, ResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
delete(_:handler:)
`
Setup a (QueryParams?, ResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.
// MyQuery is a codable struct defining the supported query parameters
router.delete("/query") { (query: MyQuery?, respondWith: (RequestError?) -> Void) in
...
respondWith(nil)
}
Swift
public func delete<Q>(_ route: String, handler: @escaping (Q?, @escaping ResultClosure) -> Void) where Q : QueryParams
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A (QueryParams?, ResultClosure) -> Void that gets invoked when a request comes to the server.
|
`
post(_:handler:)
`
Setup a CodableClosure on the provided route which will be invoked when a POST request comes to the server. In this scenario, the ID (i.e. unique identifier) is a field in the Codable instance.
//User is a struct object that conforms to Codable
router.post("/users") { (user: User, respondWith: (User?, RequestError?) -> Void) in
...
respondWith(user, nil)
}
Swift
public func post<I, O>(_ route: String, handler: @escaping CodableClosure<I, O>) where I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A Codable closure that gets invoked when a request comes to the server.
|
`
post(_:handler:)
`
Setup a CodableIdentifierClosure on the provided route which will be invoked when a POST request comes to the server. In this scenario, the ID (i.e. unique identifier) for the Codable instance is a separate field (which is sent back to the client in the location HTTP header).
//User is a struct object that conforms to Codable
router.post("/users") { (user: User, respondWith: (Int?, User?, RequestError?) -> Void) in
...
respondWith(id, user, nil)
}
Swift
public func post<I, Id, O>(_ route: String, handler: @escaping CodableIdentifierClosure<I, Id, O>) where I : Decodable, I : Encodable, Id : Identifier, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
A Codable closure that gets invoked when a request comes to the server.
|
`
put(_:handler:)
`
Setup a IdentifierCodableClosure on the provided route which will be invoked when a request comes to the server.
//User is a struct object that conforms to Codable
router.put("/users") { (id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in
...
respondWith(user, nil)
}
Swift
public func put<Id, I, O>(_ route: String, handler: @escaping IdentifierCodableClosure<Id, I, O>) where Id : Identifier, I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
An Identifier Codable closure that gets invoked when a request comes to the server.
|
`
patch(_:handler:)
`
Setup a IdentifierCodableClosure on the provided route which will be invoked when a request comes to the server.
//User is a struct object that conforms to Codable
//OptionalUser is a struct object that conforms to Codable where all properties are optional
router.patch("/users") { (id: Int, patchUser: OptionalUser, respondWith: (User?, RequestError?) -> Void) -> Void in
...
respondWith(user, nil)
}
Swift
public func patch<Id, I, O>(_ route: String, handler: @escaping IdentifierCodableClosure<Id, I, O>) where Id : Identifier, I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
A String specifying the pattern that needs to be matched, in order for the handler to be invoked.
|
| handler |
An Identifier Codable closure that gets invoked when a request comes to the server.
|
RouterMiddleware extensions
`
handle(request:response:next:)
`
Handle an HTTP request as a middleware. Used internally in Router to allow for sub routing.
Throws
Any ErrorType. If an error is thrown, processing of the request is stopped, the error handlers, if any are defined, will be invoked, and the user will get a response with a status code of 500.
Swift
public func handle(request: RouterRequest, response: RouterResponse, next: @escaping () -> Void) throws
| request |
The RouterRequest object used to work with the incoming HTTP request.
|
| response |
The RouterResponse object used to respond to the HTTP request.
|
| next |
The closure called to invoke the next handler or middleware associated with the request.
|
HTTPServerDelegate extensions
`
handle(request:response:)
`
Handle new incoming requests to the server.
Swift
public func handle(request: ServerRequest, response: ServerResponse)
| request |
The ServerRequest object used to work with the incoming HTTP request at the Kitura-net API level.
|
| response |
The ServerResponse object used to send responses to the HTTP request at the Kitura-net API level.
|
Error
`
error(_:)
`
Setup error handling that will cause a set of one or more closures of the type RouterHandler to be invoked when an error occurs.
Swift
@discardableResult
public func error(_ handler: RouterHandler...) -> Router
| handler |
A comma delimited set of RouterHandler that will be invoked if an error ocurrs.
|
`
error(_:)
`
Setup error handling that will cause an array of one or more closures of the type RouterHandler to be invoked when an error occurs.
Swift
@discardableResult
public func error(_ handler: [RouterHandler]) -> Router
| handler |
An array of RouterHandler that will be invoked if an error ocurrs.
|
`
error(_:)
`
Setup error handling that will cause a set of one or more RouterMiddleware to be invoked when an error occurs.
Swift
@discardableResult
public func error(_ middleware: RouterMiddleware...) -> Router
| middleware |
A comma delimited set of RouterMiddleware that will be invoked if an error ocurrs.
|
`
error(_:)
`
Setup error handling that will cause an array of one or more RouterMiddleware to be invoked when an error occurs.
Swift
@discardableResult
public func error(_ middleware: [RouterMiddleware]) -> Router
| middleware |
An array of RouterMiddleware that will be invoked if an error ocurrs.
|
All
`
all(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when any request comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func all(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when any request comes to the server.
|
`
all(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when any request comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func all(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when any request comes to the server.
|
`
all(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when any request comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func all(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when any request comes to the server.
|
`
all(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when any request comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func all(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when any request comes to the server.
|
Get
`
get(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func get(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP GET requests comes to the server.
|
`
get(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func get(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP GET requests comes to the server.
|
`
get(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func get(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP GET requests comes to the server.
|
`
get(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func get(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP GET requests comes to the server.
|
Head
`
head(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func head(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP HEAD requests comes to the server.
|
`
head(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func head(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP HEAD requests comes to the server.
|
`
head(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func head(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server.
|
`
head(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func head(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server.
|
Post
`
post(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func post(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP POST requests comes to the server.
|
`
post(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func post(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP POST requests comes to the server.
|
`
post(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func post(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP POST requests comes to the server.
|
`
post(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func post(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP POST requests comes to the server.
|
Put
`
put(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func put(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP PUT requests comes to the server.
|
`
put(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func put(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP PUT requests comes to the server.
|
`
put(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func put(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP PUT requests comes to the server.
|
`
put(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func put(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP PUT requests comes to the server.
|
Delete
`
delete(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func delete(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP DELETE requests comes to the server.
|
`
delete(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func delete(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP DELETE requests comes to the server.
|
`
delete(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func delete(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server.
|
`
delete(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func delete(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server.
|
Options
`
options(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP OPTIONS requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func options(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP OPTIONS requests comes to the server.
|
`
options(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP OPTIONS requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func options(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP OPTIONS requests comes to the server.
|
`
options(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP OPTIONS requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func options(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP OPTIONS requests comes to the server.
|
`
options(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP OPTIONS requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func options(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP OPTIONS requests comes to the server.
|
Trace
`
trace(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP TRACE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func trace(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP TRACE requests comes to the server.
|
`
trace(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP TRACE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func trace(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP TRACE requests comes to the server.
|
`
trace(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP TRACE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func trace(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP TRACE requests comes to the server.
|
`
trace(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP TRACE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func trace(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP TRACE requests comes to the server.
|
Copy
`
copy(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP COPY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func copy(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP COPY requests comes to the server.
|
`
copy(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP COPY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func copy(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP COPY requests comes to the server.
|
`
copy(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP COPY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func copy(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP COPY requests comes to the server.
|
`
copy(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP COPY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func copy(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP COPY requests comes to the server.
|
Lock
`
lock(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP LOCK requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func lock(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP LOCK requests comes to the server.
|
`
lock(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP LOCK requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func lock(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP LOCK requests comes to the server.
|
`
lock(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP LOCK requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func lock(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP LOCK requests comes to the server.
|
`
lock(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP LOCK requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func lock(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP LOCK requests comes to the server.
|
MkCol
`
mkCol(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP MKCOL requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkCol(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP MKCOL requests comes to the server.
|
`
mkCol(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP MKCOL requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkCol(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP MKCOL requests comes to the server.
|
`
mkCol(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP MKCOL requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkCol(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP MKCOL requests comes to the server.
|
`
mkCol(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP MKCOL requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkCol(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP MKCOL requests comes to the server.
|
Move
`
move(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP MOVE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func move(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP MOVE requests comes to the server.
|
`
move(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP MOVE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func move(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP MOVE requests comes to the server.
|
`
move(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP MOVE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func move(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP MOVE requests comes to the server.
|
`
move(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP MOVE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func move(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP MOVE requests comes to the server.
|
Purge
`
purge(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PURGE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func purge(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP PURGE requests comes to the server.
|
`
purge(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PURGE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func purge(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP PURGE requests comes to the server.
|
`
purge(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP PURGE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func purge(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP PURGE requests comes to the server.
|
`
purge(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP PURGE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func purge(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP PURGE requests comes to the server.
|
PropFind
`
propFind(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PROPFIND requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propFind(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP PROPFIND requests comes to the server.
|
`
propFind(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PROPFIND requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propFind(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP PROPFIND requests comes to the server.
|
`
propFind(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP PROPFIND requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propFind(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP PROPFIND requests comes to the server.
|
`
propFind(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP PROPFIND requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propFind(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP PROPFIND requests comes to the server.
|
PropPatch
`
propPatch(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PROPPATCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propPatch(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP PROPPATCH requests comes to the server.
|
`
propPatch(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PROPPATCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propPatch(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP PROPPATCH requests comes to the server.
|
`
propPatch(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP PROPPATCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propPatch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP PROPPATCH requests comes to the server.
|
`
propPatch(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP PROPPATCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func propPatch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP PROPPATCH requests comes to the server.
|
Unlock
`
unlock(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP UNLOCK requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unlock(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP UNLOCK requests comes to the server.
|
`
unlock(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP UNLOCK requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unlock(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP UNLOCK requests comes to the server.
|
`
unlock(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP UNLOCK requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unlock(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP UNLOCK requests comes to the server.
|
`
unlock(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP UNLOCK requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unlock(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP UNLOCK requests comes to the server.
|
Report
`
report(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP REPORT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func report(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP REPORT requests comes to the server.
|
`
report(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP REPORT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func report(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP REPORT requests comes to the server.
|
`
report(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP REPORT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func report(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP REPORT requests comes to the server.
|
`
report(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP REPORT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func report(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP REPORT requests comes to the server.
|
MkActivity
`
mkActivity(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP MKACTIVITY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkActivity(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP MKACTIVITY requests comes to the server.
|
`
mkActivity(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP MKACTIVITY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkActivity(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP MKACTIVITY requests comes to the server.
|
`
mkActivity(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP MKACTIVITY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkActivity(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP MKACTIVITY requests comes to the server.
|
`
mkActivity(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP MKACTIVITY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mkActivity(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP MKACTIVITY requests comes to the server.
|
Checkout
`
checkout(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP CHECKOUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func checkout(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP CHECKOUT requests comes to the server.
|
`
checkout(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP CHECKOUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func checkout(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP CHECKOUT requests comes to the server.
|
`
checkout(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP CHECKOUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func checkout(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP CHECKOUT requests comes to the server.
|
`
checkout(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP CHECKOUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func checkout(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP CHECKOUT requests comes to the server.
|
Merge
`
merge(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP MERGE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func merge(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP MERGE requests comes to the server.
|
`
merge(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP MERGE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func merge(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP MERGE requests comes to the server.
|
`
merge(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP MERGE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func merge(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP MERGE requests comes to the server.
|
`
merge(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP MERGE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func merge(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP MERGE requests comes to the server.
|
MSearch
`
mSearch(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP MSEARCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mSearch(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP MSEARCH requests comes to the server.
|
`
mSearch(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP MSEARCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mSearch(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP MSEARCH requests comes to the server.
|
`
mSearch(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP MSEARCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mSearch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP MSEARCH requests comes to the server.
|
`
mSearch(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP MSEARCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func mSearch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP MSEARCH requests comes to the server.
|
Notify
`
notify(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP NOTIFY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func notify(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP NOTIFY requests comes to the server.
|
`
notify(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP NOTIFY requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func notify(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP NOTIFY requests comes to the server.
|
`
notify(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP NOTIFY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func notify(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP NOTIFY requests comes to the server.
|
`
notify(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP NOTIFY requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func notify(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP NOTIFY requests comes to the server.
|
Subscribe
`
subscribe(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP SUBSCRIBE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func subscribe(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP SUBSCRIBE requests comes to the server.
|
`
subscribe(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP SUBSCRIBE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func subscribe(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP SUBSCRIBE requests comes to the server.
|
`
subscribe(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP SUBSCRIBE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func subscribe(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP SUBSCRIBE requests comes to the server.
|
`
subscribe(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP SUBSCRIBE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func subscribe(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP SUBSCRIBE requests comes to the server.
|
Unsubscribe
`
unsubscribe(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP UNSUBSCRIBE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unsubscribe(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP UNSUBSCRIBE requests comes to the server.
|
`
unsubscribe(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP UNSUBSCRIBE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unsubscribe(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP UNSUBSCRIBE requests comes to the server.
|
`
unsubscribe(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP UNSUBSCRIBE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unsubscribe(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP UNSUBSCRIBE requests comes to the server.
|
`
unsubscribe(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP UNSUBSCRIBE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func unsubscribe(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP UNSUBSCRIBE requests comes to the server.
|
Patch
`
patch(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PATCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func patch(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP PATCH requests comes to the server.
|
`
patch(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PATCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func patch(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP PATCH requests comes to the server.
|
`
patch(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP PATCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func patch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP PATCH requests comes to the server.
|
`
patch(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP PATCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func patch(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP PATCH requests comes to the server.
|
Search
`
search(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP SEARCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func search(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP SEARCH requests comes to the server.
|
`
search(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP SEARCH requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func search(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP SEARCH requests comes to the server.
|
`
search(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP SEARCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func search(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP SEARCH requests comes to the server.
|
`
search(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP SEARCH requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func search(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP SEARCH requests comes to the server.
|
Connect
`
connect(_:handler:)
`
Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP CONNECT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func connect(_ path: String? = nil, handler: RouterHandler...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
A comma delimited set of RouterHandlers that will be invoked when HTTP CONNECT requests comes to the server.
|
`
connect(_:handler:)
`
Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP CONNECT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.
Swift
@discardableResult
public func connect(_ path: String? = nil, handler: [RouterHandler]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the handlers to be invoked.
|
| handler |
The array of RouterHandlers that will be invoked when HTTP CONNECT requests comes to the server.
|
`
connect(_:allowPartialMatch:middleware:)
`
Setup a set of one or more RouterMiddleware that will be invoked when HTTP CONNECT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func connect(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: RouterMiddleware...) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
A comma delimited set of RouterMiddleware that will be invoked when HTTP CONNECT requests comes to the server.
|
`
connect(_:allowPartialMatch:middleware:)
`
Setup an array of one or more RouterMiddleware that will be invoked when HTTP CONNECT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.
Swift
@discardableResult
public func connect(_ path: String? = nil, allowPartialMatch: Bool = true, middleware: [RouterMiddleware]) -> Router
| path |
An optional String specifying the pattern that needs to be matched, in order for the RouterMiddleware to be invoked.
|
| allowPartialMatch |
A Bool that indicates whether or not a partial match of the path by the pattern is sufficient.
|
| handler |
The array of RouterMiddleware that will be invoked when HTTP CONNECT requests comes to the server.
|
`
registerGetRoute(route:outputType:outputIsArray:)
`
Register GET route
Swift
public func registerGetRoute<O>(route: String, outputType: O.Type, outputIsArray: Bool = false) where O : Decodable, O : Encodable
| route |
The route to register.
|
| outputtype |
The output object type.
|
`
registerGetRoute(route:id:outputType:outputIsArray:)
`
Register GET route
Swift
public func registerGetRoute<Id, O>(route: String, id: Id.Type, outputType: O.Type, outputIsArray: Bool = false) where Id : Identifier, O : Decodable, O : Encodable
| route |
The route to register.
|
| id |
The id type.
|
| outputtype |
The output object type.
|
`
registerGetRoute(route:queryParams:optionalQParam:outputType:outputIsArray:)
`
Register GET route
Swift
public func registerGetRoute<Q, O>(route: String, queryParams: Q.Type, optionalQParam: Bool, outputType: O.Type, outputIsArray: Bool = false) where Q : QueryParams, O : Decodable, O : Encodable
| route |
The route to register.
|
| queryParams |
The query parameters.
|
| optionalQParam |
Flag to indicate that the query params are all optional.
|
| outputType |
The output object type.
|
`
registerDeleteRoute(route:)
`
Register DELETE route
Swift
public func registerDeleteRoute(route: String)
| route |
The route to register.
|
`
registerDeleteRoute(route:queryParams:optionalQParam:)
`
Register DELETE route
Swift
public func registerDeleteRoute<Q>(route: String, queryParams: Q.Type, optionalQParam: Bool) where Q : QueryParams
| route |
The route to register.
|
| queryParams |
The query parameters.
|
| optionalQParam |
Flag to indicate that the query params are all optional.
|
`
registerDeleteRoute(route:id:)
`
Register DELETE route
Swift
public func registerDeleteRoute<Id>(route: String, id: Id.Type) where Id : Identifier
| route |
The route to register.
|
| id |
The id type.
|
`
registerPostRoute(route:inputType:outputType:)
`
Register POST route that is handled by a CodableIdentifierClosure.
Swift
public func registerPostRoute<I, O>(route: String, inputType: I.Type, outputType: O.Type) where I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
The route to register.
|
| inputType |
The input object type.
|
| outputType |
The output object type.
|
`
registerPostRoute(route:id:inputType:outputType:)
`
Register POST route that is handled by a CodableIdentifierClosure.
Swift
public func registerPostRoute<I, Id, O>(route: String, id: Id.Type, inputType: I.Type, outputType: O.Type) where I : Decodable, I : Encodable, Id : Identifier, O : Decodable, O : Encodable
| route |
The route to register.
|
| id |
The id type.
|
| inputType |
The input object type.
|
| outputType |
The output object type.
|
`
registerPutRoute(route:id:inputType:outputType:)
`
Register PUT route that is handled by a IdentifierCodableClosure.
Swift
public func registerPutRoute<Id, I, O>(route: String, id: Id.Type, inputType: I.Type, outputType: O.Type) where Id : Identifier, I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
The route to register.
|
| id |
The id type.
|
| inputType |
The input object type.
|
| outputType |
The output object type.
|
`
registerPatchRoute(route:id:inputType:outputType:)
`
Register PATCH route that is handled by an IdentifierCodableClosure.
Swift
public func registerPatchRoute<Id, I, O>(route: String, id: Id.Type, inputType: I.Type, outputType: O.Type) where Id : Identifier, I : Decodable, I : Encodable, O : Decodable, O : Encodable
| route |
The route to register.
|
| id |
The id type.
|
| inputType |
The input object type.
|
| outputType |
The output object type.
|