0001    
import Foundation
0002    
0003    protocol Handler
Application.swift:37
    func dispatch(request request: Request, response: Response, handlers: [Handler]?) {
Application.swift:44
    func handleMiddleware(handlers: [Handler], request: Request, response: Response) {
Application.swift:111
    func handleRoutes(routes: [Handler], request: Request, response: Response) {
HandlerManager.swift:16
    let pathTree: PathTree<Handler>
HandlerManager.swift:20
        pathTree = PathTree<Handler>()
HandlerManager.swift:37
    func register(handler: Handler) {
HandlerManager.swift:42
    func register(method: String?, handler: Handler) {
HandlerManager.swift:54
    func routeSingle(request: Request) -> Handler? {
HandlerManager.swift:73
    func route(request: Request) -> [Handler] {
Middleware.swift:19
extension MiddlewareHandler: Handler {
Middleware.swift:39
extension MiddlewareClosureHandler: Handler {
Route.swift:70
extension Route: Handler {
 {
0004        
0005        func handle
Application.swift:50
            handler.handle(request: request, response: response) {
Application.swift:114
            route.handle(request: request, response: response) {
(request request: Request, response: Response, next: (() -> ()))
0006        
0007        var path
HandlerManager.swift:38
        let path = "*/" + handler.path
HandlerManager.swift:46
            path = method + "/" + handler.path
HandlerManager.swift:48
            path = "*/" + handler.path
: String { get }
0008        
0009    }
0010    
0011    final class HandlerManager
Application.swift:8
    private let middlewareManager: HandlerManager<MiddlewareHandler>
Application.swift:10
    private let routeManager: HandlerManager<Route>
Application.swift:25
        middlewareManager = HandlerManager<MiddlewareHandler>(allowsMultiplesPerPath: true)
Application.swift:26
        routeManager = HandlerManager<Route>(allowsMultiplesPerPath: false)
HandlerManager.swift:25
extension HandlerManager {
<T: Handler> {
0012        
0013        let allowsMultiples
HandlerManager.swift:19
        allowsMultiples = allowsMultiplesPerPath
HandlerManager.swift:39
        pathTree.addHandler(handler, toPath: path, overwrite: !allowsMultiples)
HandlerManager.swift:51
        pathTree.addHandler(handler, toPath: path, overwrite: allowsMultiples)
: Bool
0014        
0015        let pathTree
HandlerManager.swift:20
        pathTree = PathTree<Handler>()
HandlerManager.swift:34
        return pathTree.paramsForPath(fullPath)
HandlerManager.swift:39
        pathTree.addHandler(handler, toPath: path, overwrite: !allowsMultiples)
HandlerManager.swift:51
        pathTree.addHandler(handler, toPath: path, overwrite: allowsMultiples)
HandlerManager.swift:64
        let result = pathTree.findValue(path)
HandlerManager.swift:83
        let result = pathTree.findValues(path)
: PathTree<Handler>
0016        
0017        init(allowsMultiplesPerPath: Bool) {
0018            allowsMultiples = allowsMultiplesPerPath
0019            pathTree = PathTree<Handler>()
0020        }
0021        
0022    }
0023    
0024    extension HandlerManager {
0025        
0026        func paramsForPath
Application.swift:56
            let params = routeManager.paramsForPath(request.method.rawValue, path: request.path)
(method: String?, path: String) -> [String: String] {
0027            let fullPath: String
0028            if let method = method {
0029                fullPath = method + "/" + path
0030            } else {
0031                fullPath = "*/" + path
0032            }
0033            return pathTree.paramsForPath(fullPath)
0034        }
0035        
0036        func register
Application.swift:206
        middlewareManager.register(handler)
Application.swift:217
        middlewareManager.register(middlewareHandler)
(handler: Handler) {
0037            let path = "*/" + handler.path
0038            pathTree.addHandler(handler, toPath: path, overwrite: !allowsMultiples)
0039        }
0040        
0041        func register
Application.swift:124
            self.routeManager.register(route.method.rawValue, handler: route)
(method: String?, handler: Handler) {
0042            let path: String
0043            
0044            if let method = method {
0045                path = method + "/" + handler.path
0046            } else {
0047                path = "*/" + handler.path
0048            }
0049            
0050            pathTree.addHandler(handler, toPath: path, overwrite: allowsMultiples)
0051        }
0052        
0053        func routeSingle
Application.swift:101
                if let result = routeManager.routeSingle(request) {
(request: Request) -> Handler? {
0054            
0055            let path: String
0056            
0057            if request.method != Request.Method.Unknown {
0058                path = request.method.rawValue + "/" + request.path
0059            } else {
0060                path = "*/" + request.path
0061            }
0062            
0063            let result = pathTree.findValue(path)
0064            
0065            for (key, value) in result.params {
0066                request.params[key] = value
0067            }
0068            
0069            return result.handler
0070        }
0071    
0072        func route
Application.swift:39
        let handlers = middlewareManager.route(request)
(request: Request) -> [Handler] {
0073            
0074            let path: String
0075    
0076            if request.method != Request.Method.Unknown {
0077                path = request.method.rawValue + "/" + request.path
0078            } else {
0079                path = "*/" + request.path
0080            }
0081            
0082            let result = pathTree.findValues(path)
0083            
0084            for (key, value) in result.params {
0085                request.params[key] = value
0086            }
0087            
0088            return result.handlers
0089        }
0090    }
0091    
0092