StaticFileHandlerBase

abstract def handleNormal(request: Request, f: File, expirationSeconds: Int): Option[(Request) ⇒ Future[Response]]

abstract def isValidDir(f: File): Boolean

Is this a valid directory that we should check for an index file?

abstract def isValidFile(f: File): Boolean

Is this a valid file we can serve?

abstract def root: File

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def afterShutdown(): Unit

Called once web server shutdown is completed -- Should be idempotent

def afterStartup(): Unit

Called after the web server is running but before ping is enabled -- Should be idempotent

final def asInstanceOf[T0]: T0

def beforeShutdown(): Unit

Called when web server shutdown is requested but before actually shutting down -- Should be idempotent

def beforeStartup(): Unit

Called before the web server starts up -- Should be idempotent

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def handleFileSystemFile(request: Request, f: File, expirationSeconds: Int): Option[(Request) ⇒ Future[Response]]

This can be called by handleNormal for when the File refers to an actual file on the file system

def hashCode(): Int

final def isFileSystemDir(f: File): Boolean

final def isFileSystemFile(f: File): Boolean

final def isInstanceOf[T0]: Boolean

final def lookup(request: Request): Option[(Request) ⇒ Future[Response]]

Given a request lookup a RequestHandler that can satisfy it

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def orElse(that: RequestRouter): RequestRouter

If this router doesn't match the request then try that router

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def withDefaultHandler(handler: (Request) ⇒ Future[Response]): RequestRouter

If this request router does not match a request then send the request to the specified default handler

final def withErrorHandler(handler: (Request) ⇒ Future[Response])(implicit ec: ExecutionContext): RequestRouter

If a RequestHandler throws an Exception then run this handler.

final def withFilter(filter: Option[RequestFilter]): RequestRouter

Run any RequestHandlers returned by this RequestRouter through an optional RequestFilter

final def withFilter(filter: RequestFilter): RequestRouter

Run any RequestHandlers returned by this RequestRouter through a RequestFilter

final def withFilters(filters: TraversableOnce[RequestFilter]): RequestRouter

Run any RequestHandlers returned by this RequestRouter through a sequence of RequestFilter