ApiFormats

abstract def addSessionId(uri: String): String

implicit abstract def configWrapper(config: ConfigT): Config

abstract val doNotFound: () ⇒ Any

Called if no route matches the current request for any method.

abstract def requestPath: String

The effective path against which routes are matched.

abstract def routeBasePath: 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

val _params: MultiMapHeadView[String, String] with MapWithIndifferentAccess[String]

def acceptHeader: List[String]

The list of media types accepted by the current request.

def acceptedFormats(accepted: Symbol*): Boolean

def addRoute(method: HttpMethod, transformers: Seq[(Route) ⇒ Route], action: ⇒ Any): Route

Prepends a new route for the given HTTP method.

def addStatusRoute(codes: Range, action: ⇒ Any): Unit

def after(transformers: (Route) ⇒ Route*)(fun: ⇒ Any): Unit

Adds a filter to run after the route.

final def asInstanceOf[T0]: T0

def before(transformers: (Route) ⇒ Route*)(fun: ⇒ Any): Unit

Adds a filter to run before the route.

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

Converts a boolean expression to a route matcher.

def clone(): AnyRef

def contentType: String

Gets the content type of the current response.

def contentTypeInferrer: ContentTypeInferrer

A partial function to infer the content type from the action result.

def contentType_=(contentType: String): Unit

Sets the content type of the current response.

def contextPath: String

def defaultAcceptedFormats: List[Symbol]

A list of formats accepted by default.

val defaultCharacterEncoding: String

The default character encoding for requests and responses.

def defaultFormat: Symbol

The default format.

def delete(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

var doMethodNotAllowed: (Set[HttpMethod]) ⇒ Any

Called if no route matches the current request method, but routes match for other methods.

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichSession

def environment: String

A free form string representing the environment.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(handler: ErrorHandler): Unit

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

var errorHandler: ErrorHandler

The error handler function, called if an exception is thrown during before filters or the routes.

def executeRoutes(): Unit

Executes routes in the context of the current request and response.

def finalize(): Unit

def format: String

Returns the request-scoped format.

def formatForMimeTypes(mimeTypes: String*): Option[String]

def format_=(formatValue: String): Unit

Explicitly sets the request-scoped format.

def format_=(formatValue: Symbol): Unit

Explicitly sets the request-scoped format.

val formats: ConcurrentMap[String, String]

A map of suffixes to content types.

def fullUrl(path: String, params: Iterable[(String, Any)] = Iterable.empty, includeContextPath: Boolean = true, includeServletPath: Boolean = true): String

Builds a full URL from the given relative path.

def get(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

The Scalatra DSL core methods take a list of 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(): java.lang.Class[_]

def halt(result: ActionResult): Nothing

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

Immediately halts processing of a request.

def handle(request: HttpServletRequest, response: HttpServletResponse): Unit

Handles a request and renders a response.

def hashCode(): Int

def inferFromFormats: ContentTypeInferrer

A content type inferrer based on the format variable.

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

Gets an init paramter from the config.

def initialize(config: ConfigT): Unit

Initializes the kernel.

def invoke(matchedRoute: MatchedRoute): Option[Any]

Invokes a route or filter.

def isAsyncExecutable(result: Any): Boolean

def isDevelopmentMode: Boolean

A boolean flag representing whether the kernel is in development mode.

def isHttps: Boolean

final def isInstanceOf[T0]: Boolean

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

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

val mimeTypes: ConcurrentMap[String, String]

A map of content types to suffixes.

def multiParams: MultiParams

The current multiparams.

final def ne(arg0: AnyRef): Boolean

def needsHttps: Boolean

def notFound(fun: ⇒ Any): Unit

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

final def notify(): Unit

final def notifyAll(): Unit

def options(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

def params: MultiMapHeadView[String, String] with MapWithIndifferentAccess[String]

A view of multiParams.

def pass(): Nothing

Immediately exits from the current route.

def patch(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

Path pattern is decoupled from requests.

def post(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

def put(transformers: (Route) ⇒ Route*)(action: ⇒ Any): Route

def redirect(uri: String): Unit

Sends a redirect response and immediately halts the current action.

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

Converts a regular expression to a route matcher.

def relativeUrl(path: String, params: Iterable[(String, Any)] = Iterable.empty, includeContextPath: Boolean = true, includeServletPath: Boolean = true): String

def removeRoute(method: String, route: Route): Unit

def removeRoute(method: HttpMethod, route: Route): Unit

Removes _all_ the actions of a given route for a given HTTP method.

def renderHaltException(e: HaltException): Unit

def renderPipeline: RenderPipeline

The render pipeline is a partial function of Any => Any.

def renderResponse(actionResult: Any): Unit

Renders the action result to the response.

def renderResponseBody(actionResult: Any): Unit

Renders the action result to the response body via the render pipeline.

implicit def request: HttpServletRequest

The currently scoped request.

implicit def response: HttpServletResponse

The currently scoped response.

def responseFormat: String

lazy val routes: RouteRegistry

The routes registered in this kernel.

def runFilters(filters: Traversable[Route]): Unit

Invokes each filters with invoke.

def runRoutes(routes: Traversable[Route]): Stream[Any]

Lazily invokes routes with invoke.

implicit def safe[S, T](f: (S) ⇒ T): (S) ⇒ Option[T]

implicit def safeOption[S, T](f: (S) ⇒ Option[T]): (S) ⇒ Option[T]

Implicit convert a (String) => Option[T] function into a TypeConverter[T]

def seqHead[T](elementConverter: (String) ⇒ Option[T])(implicit arg0: Manifest[T]): (Seq[String]) ⇒ Option[T]

def seqToSeq[T](elementConverter: (String) ⇒ Option[T])(implicit arg0: Manifest[T]): (Seq[String]) ⇒ Option[Seq[T]]

def serverHost: String

def serverPort: Int

def servletContext: ServletContext

The servlet context in which this kernel runs.

def status: Int

Gets the status code of the current response.

def status_=(code: Int): Unit

Sets the status code of the current response.

implicit def string2RouteMatcher(path: String): RouteMatcher

Pluggable way to convert a path expression to a route matcher.

implicit val stringSeqToBoolean: (Seq[String]) ⇒ Option[Boolean]

implicit val stringSeqToByte: (Seq[String]) ⇒ Option[Byte]

implicit val stringSeqToDouble: (Seq[String]) ⇒ Option[Double]

implicit val stringSeqToFloat: (Seq[String]) ⇒ Option[Float]

implicit val stringSeqToInt: (Seq[String]) ⇒ Option[Int]

implicit val stringSeqToLong: (Seq[String]) ⇒ Option[Long]

implicit val stringSeqToSeqBoolean: (Seq[String]) ⇒ Option[Seq[Boolean]]

implicit val stringSeqToSeqByte: (Seq[String]) ⇒ Option[Seq[Byte]]

implicit val stringSeqToSeqDouble: (Seq[String]) ⇒ Option[Seq[Double]]

implicit val stringSeqToSeqFloat: (Seq[String]) ⇒ Option[Seq[Float]]

implicit val stringSeqToSeqInt: (Seq[String]) ⇒ Option[Seq[Int]]

implicit val stringSeqToSeqLong: (Seq[String]) ⇒ Option[Seq[Long]]

implicit val stringSeqToSeqShort: (Seq[String]) ⇒ Option[Seq[Short]]

implicit val stringSeqToSeqString: (Seq[String]) ⇒ Option[Seq[String]]

implicit val stringSeqToShort: (Seq[String]) ⇒ Option[Short]

implicit val stringSeqToString: (Seq[String]) ⇒ Option[String]

implicit val stringToBoolean: (String) ⇒ Option[Boolean]

implicit val stringToByte: (String) ⇒ Option[Byte]

def stringToDate(format: ⇒ String): (String) ⇒ Option[Date]

def stringToDateFormat(format: ⇒ DateFormat): (String) ⇒ Option[Date]

implicit val stringToDouble: (String) ⇒ Option[Double]

implicit val stringToFloat: (String) ⇒ Option[Float]

implicit val stringToInt: (String) ⇒ Option[Int]

implicit val stringToLong: (String) ⇒ Option[Long]

implicit val stringToSelf: (String) ⇒ Option[String]

def stringToSeq[T](elementConverter: (String) ⇒ Option[T], separator: String)(implicit arg0: Manifest[T]): (String) ⇒ Option[Seq[T]]

implicit val stringToSeqBoolean: (String) ⇒ Option[Seq[Boolean]]

implicit val stringToSeqByte: (String) ⇒ Option[Seq[Byte]]

implicit val stringToSeqDouble: (String) ⇒ Option[Seq[Double]]

implicit val stringToSeqFloat: (String) ⇒ Option[Seq[Float]]

implicit val stringToSeqInt: (String) ⇒ Option[Seq[Int]]

implicit val stringToSeqLong: (String) ⇒ Option[Seq[Long]]

implicit val stringToSeqShort: (String) ⇒ Option[Seq[Short]]

implicit val stringToSeqString: (String) ⇒ Option[Seq[String]]

implicit val stringToShort: (String) ⇒ Option[Short]

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

def toString(): String

implicit def toTypedMultiParams(params: MultiParamsType): TypedMultiParams

implicit def toTypedParams(params: ParamsType): TypedParams

def trap(codes: Range)(block: ⇒ Any): Unit

Error handler for HTTP response status code range.

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

def trap(code: Int)(block: ⇒ Any): Unit

def url(path: String, params: Iterable[(String, Any)] = Iterable.empty, includeContextPath: Boolean = true, includeServletPath: Boolean = true, absolutize: Boolean = true): String

Returns a context-relative, session-aware URL for a path and specified parameters.

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 withRouteMultiParams[S](matchedRoute: Option[MatchedRoute])(thunk: ⇒ S): S

def _request: DynamicVariable[HttpServletRequest]

def _response: DynamicVariable[HttpServletResponse]

def applicationContext: ServletContext

def status(code: Int): Unit