TypedAsyncFeatures

abstract def error(handler: ErrorHandler): Unit

Defines an error handler for exceptions thrown in either the before block or a route action.

abstract def methodNotAllowed(block: (Set[HttpMethod]) ⇒ Any): Unit

Defines a block to run if matching routes are found only for other methods.

abstract def notFound(block: ⇒ Any): Unit

Defines a block to run if no matching routes are found, or if all matching routes pass.

abstract def routeBasePath(implicit ctx: SkinnyContext): String

The base path for URL generation

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def FutureWithContext[A](op: (SkinnyContext) ⇒ A)(implicit ec: ExecutionContext, context: SkinnyContext): Future[A]

Creates a future with implicit context.

def addRoute(method: HttpMethod, transformers: Seq[RouteTransformer], action: (Context) ⇒ AsyncResult): Route

Prepends a new route for the given HTTP method.

def after(transformers: RouteTransformer*)(fun: (Context) ⇒ Any): Unit

Adds a filter to run after the route.

final def asInstanceOf[T0]: T0

def awaitFutures[A](duration: Duration)(fs: Future[A]*)(implicit ec: ExecutionContext): Seq[A]

Awaits multiple Future's results.

def before(transformers: RouteTransformer*)(fun: (Context) ⇒ Any): Unit

Adds a filter to run before the route.

def clone(): AnyRef

var config: (TypedAsyncFeatures.this)#ConfigT

The configuration, typically a ServletConfig or FilterConfig.

implicit def configWrapper(config: (TypedAsyncFeatures.this)#ConfigT): (TypedAsyncFeatures.this)#Config { object initParameters }

def context: SkinnyContext

def contextPath: String

def delete(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichHttpServletSession

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def get(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

The SkinnyMicro DSL core methods take a list of skinny.micro.routing.RouteMatcher and a block as the action body.

get("/") {
  <form action="/echo">
    <label>Enter your name</label>
    <input type="text" name="name"/>
  </form>
}

post("/echo") {
  "hello {params('name)}!"
}

get("/", request.getRemoteHost == "127.0.0.1") { "Hello localhost!" }

final def getClass(): Class[_]

def halt(result: response.ActionResult): Nothing

def halt[T](status: Integer = null, body: T = (), headers: Map[String, String] = Map.empty, reason: String = null)(implicit arg0: Manifest[T]): Nothing

Immediately halts processing of a request.

def hashCode(): Int

def head(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

def initParameter(name: String): Option[String]

Gets an init parameter from the config.

def initialize(config: (TypedAsyncFeatures.this)#ConfigT): Unit

Initializes the kernel.

def isAsyncExecutable(result: Any): Boolean

true if async supported

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def options(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

def pass(): Nothing

Immediately exits from the current route.

def patch(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

def post(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

def put(transformers: RouteTransformer*)(action: (Context) ⇒ Future[ActionResult]): Route

def request(implicit ctx: SkinnyContext): HttpServletRequest

def response(implicit ctx: SkinnyContext): HttpServletResponse

val routes: RouteRegistry

The routes registered in this kernel.

def serverAuthority(implicit ctx: SkinnyContext): String

def serverHost(implicit ctx: SkinnyContext): String

def serverPort(implicit ctx: SkinnyContext): Int

implicit def servletContext: ServletContext

The servlet context in which this kernel runs.

def shutdown(): Unit

A hook to shutdown the class.

def skinnyContext(implicit ctx: ServletContext): SkinnyContext

Skinny Micro Context

implicit def stringToRicherString(s: String): RicherString

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

def toString(): String

def trap(code: Int)(block: (Context) ⇒ Future[ActionResult]): Unit

def trap(codes: Range)(block: (Context) ⇒ Future[ActionResult]): Unit

Error handler for HTTP response status code range.

trap(403) {
   "You are not authorized"
  }
}*

def unstableAccessValidationEnabled: Boolean

Enables unstable access validation.

def useMostlyStableHttpSession: Boolean

Enables mostly stable Servlet HttpSession implementation instead.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRequest[A](request: HttpServletRequest)(f: ⇒ A): A

Executes the block with the given request bound to the request method.

def withRequestResponse[A](request: HttpServletRequest, response: HttpServletResponse)(f: ⇒ A): A

def withResponse[A](response: HttpServletResponse)(f: ⇒ A): A

Executes the block with the given response bound to the response method.

def futureWithRequest[A](op: (HttpServletRequest) ⇒ A)(implicit ec: ExecutionContext, ctx: SkinnyContext): Future[A]

Creates a future with implicit request.