DefaultProcessors

implicit abstract val executor: ExecutionContext

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def ToFutureOps[A](a: A): DefaultProcessors.FutureOps[A] { def self: A }

def accepted: HttpResponse

def addHeader(name: HeaderName, v: Any)(f: Processor): Processor

def addHeader(name: String, v: Any)(f: Processor): Processor

Adds a processor that adds a header with the given name and value to the response.

def ajax(f: Processor): Processor

Processor that requires the request to identify itself as an ajax request by incuding the X-Requested-With header set to value "XMLRequest"

final def asInstanceOf[T0]: T0

def badGateway: HttpResponse

def badRequest(reason: String): HttpResponse

def badRequest: HttpResponse

def clone(): AnyRef

def complete(f: Processor): Processor

This processor can be used when the last processor in an endpoint pipeline uses multiple parameters and you don't like the param => req => handler syntax.

get("myurl") {
cookie("session") { sessionId => req =>
s"My sessionId is $sessionId [$req]"
}
}

can be re-written as

get("myurl") {
cookie("session") { sessionId => {
complete { req =>
s"My sessionId is $sessionId [$req]"
}
}
}

def conflict: HttpResponse

def consumes(mediaTypes: MediaType*)(f: Processor): Processor

A Processor that will reject a request with 415 Unsupported Media Type if the content type of the request does not match one of the given content types.

def contentTypeOverride(mediaType: MediaType)(f: Processor): Processor

A processor that sets the content type of the request.

def cookie(name: String)(f: (Cookie) ⇒ Processor): Processor

Adds a processor to the pipeline that requires the request to have a cookie with the given name.

def cookieValue(name: String)(f: (String) ⇒ Processor): Processor

def created: HttpResponse

def deleteCookie(name: String)(f: ⇒ Processor): Processor

A Processor that requests the removal of a cookie on the client side, by setting a cookie with the given name to a nonsense value, and a max age of -1.

def entityAs[E](f: (E) ⇒ Processor)(implicit arg0: Manifest[E]): Processor

def entitySizeLimit(size: Int)(f: Processor): Processor

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectationFailed: HttpResponse

def finalize(): Unit

def forbidden(reason: String): HttpResponse

def forbidden: HttpResponse

def found: HttpResponse

implicit def futureTeeToFutureResponse[T](f: Future[T])(implicit fn: (T) ⇒ HttpResponse): Future[HttpResponse]

def gatewayTimeout: HttpResponse

final def getClass(): Class[_]

def gone: HttpResponse

def hashCode(): Int

def header(name: HeaderName, value: Any)(f: Processor): Processor

def header(name: String, value: Any)(f: Processor): Processor

Adds a processor to the pipeline that requires the request to have a header with the given name and value If the request does not contain the header then processing will skip to the next endpoint.

def header(name: HeaderName)(f: Processor): Processor

def header(name: String)(f: Processor): Processor

Adds a processor to the pipeline that requires the request to have a header with the given name.

def hostname(regex: String)(f: Processor): Processor

def http(f: Processor): Processor

A Processor that only handles the request if the request is HTTP / un-secured

def https(f: Processor): Processor

A Processor that only handles the request if the request is HTTPS / secure

def ifMatch(name: String)(f: ⇒ Processor): Processor

def internalServerError(reason: String): HttpResponse

def internalServerError: HttpResponse

def internalServerError(e: Throwable): HttpResponse

def ipAddress(f: (String) ⇒ Processor): Processor

final def isInstanceOf[T0]: Boolean

def json(f: Processor): Processor

Adjusts the response from the inner processor by setting its content type to json

def lengthRequired: HttpResponse

def matchesIpAddress(regex: String)(f: Processor): Processor

Processes request only if the ipaddress in the request matches the given regex.

def methodNotAllowed: HttpResponse

def movedPermanently: HttpResponse

final def ne(arg0: AnyRef): Boolean

def noEntity(f: Processor): Processor

def nocontent: HttpResponse

implicit def nodeToEndpointFn(node: Node): Processor

implicit def nodeToFuture(node: Node): Future[HttpResponse]

implicit def nodeToResponse(node: Node): HttpResponse

def nonAuthoritativeInformation: HttpResponse

def notAcceptable: HttpResponse

def notFound(body: String): HttpResponse

def notFound: HttpResponse

def notImplemented: HttpResponse

def notImplemented(reason: String): HttpResponse

def notModified: HttpResponse

final def notify(): Unit

final def notifyAll(): Unit

def ok(ent: Any, contentType: MediaType): HttpResponse

Creates a Response, which is a 200 OK, with the given entity set as the payload with the given content-type.

def ok(ent: Any, contentType: String): HttpResponse

Creates a Response, which is a 200 OK, with the given entity set as the payload with the given content-type.

def ok(e: Any): HttpResponse

Creaes a 200 ok response with the entity set to the given value, and the content type inferred.

def ok: HttpResponse

implicit def optionToEndpointFn(o: Option[_]): Processor

implicit def optionToEndpointFn(f: Future[Option[_]]): Processor

implicit def optionToFuture(o: Option[_]): Future[HttpResponse]

implicit def optionToFuture(f: Future[Option[_]]): Future[HttpResponse]

implicit def optionToResponse(option: Option[_]): HttpResponse

def param(name: String, value: String)(f: Processor): Processor

def param(name: String)(f: (String) ⇒ Processor): Processor

def partialContent: HttpResponse

def paymentRequired: HttpResponse

def permanentRedirect(location: String): HttpResponse

def preconditionFailed: HttpResponse

implicit def productToFuture(prod: Product): Future[Product]

def proxyAuthenticationRequired: HttpResponse

def rateLimit(requestsPerSecond: Double, warmupPeriod: FiniteDuration)(f: Processor): Processor

def rateLimit(limiter: RateLimiter)(f: Processor): Processor

def requestEntityTooLarge: HttpResponse

def requestHeaderFieldsTooLarge: HttpResponse

def requestTimeout: HttpResponse

def requestURITooLong: HttpResponse

def requestedRangeNotSatisfiable: HttpResponse

def requiresEntity(f: Processor): Processor

def resetContent: HttpResponse

implicit def responseFutureToProcessor(resp: Future[HttpResponse]): Processor

implicit def responseToFuture(resp: HttpResponse): Future[HttpResponse]

implicit def responseToProcessorFn(resp: HttpResponse): Processor

implicit def scalazValToEndpointFn(v: ValidationNel[_, _]): Processor

implicit def scalazValToEndpointFn(f: Future[ValidationNel[_, _]]): Processor

implicit def scalazValToFuture(f: Future[ValidationNel[_, _]]): Future[HttpResponse]

implicit def scalazValToFuture(v: ValidationNel[_, _]): Future[HttpResponse]

implicit def scalazValToResponse(v: ValidationNel[_, _]): HttpResponse

def schema(f: (String) ⇒ Processor): Processor

A Processor that extracts the scheme from the request and makes it available in the inner processor.

def seeOther(location: String): HttpResponse

def serviceUnavailable: HttpResponse

def session(f: (Session) ⇒ Processor): Processor

Extracts the current session.

def sessionOption(f: (Option[Session]) ⇒ Processor): Processor

Extracts the current session as an Option.

def sessionProperty[T](key: SessionKey[T])(f: (T) ⇒ Processor): Processor

Extracts a property from the session.

def sessionPropertyOption[T](key: SessionKey[T])(f: (Option[T]) ⇒ Processor): Processor

Extracts an optional property from the session.

def status(s: Int, reason: String): HttpResponse

def status(s: Int): HttpResponse

Builds a Response with the status code set to a HttpStatus which has the value of the given int.

def status(s: HttpStatus): HttpResponse

Builds a Response with the status code set the given HttpStatus

implicit def statusToEndpointFn(s: HttpStatus): Processor

implicit def statusToFuture(s: HttpStatus): Future[HttpResponse]

implicit def statusToResponse(s: HttpStatus): HttpResponse

implicit def stringToFuture(str: String): Future[HttpResponse]

implicit def stringToFuture(f: Future[String]): Future[HttpResponse]

implicit def stringToProcessor(str: String): Processor

implicit def stringToProcessor(f: Future[String]): Processor

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

def temporaryRedirect(location: String): HttpResponse

def toString(): String

def tooManyRequests: HttpResponse

implicit def tryToEndpointFn(t: Try[_]): Processor

implicit def tryToEndpointFn(f: Future[Try[_]]): Processor

implicit def tryToFuture(t: Try[_]): Future[HttpResponse]

implicit def tryToFuture(f: Future[Try[_]]): Future[HttpResponse]

implicit def tryToResponse(t: Try[_]): HttpResponse

def unauthorized: HttpResponse

implicit def unitToEndpointFn(unit: Unit): Processor

implicit def unitToEndpointFn(f: Future[Unit]): Processor

implicit def unitToFuture(unit: Unit): Future[HttpResponse]

implicit def unitToFuture(f: Future[Unit]): Future[HttpResponse]

implicit def unitToResponse(unit: Unit): HttpResponse

def unprocessableEntity(reason: String): HttpResponse

def unprocessableEntity: HttpResponse

def unsupportedMediaType: HttpResponse

def useProxy: HttpResponse

def userAgent(regex: String)(f: Processor): Processor

def userAgent(regex: Regex)(f: Processor): Processor

The regex to match on the user agent

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xml(f: Processor): Processor

Creates a Response, which is a 200 OK, with the given entity set as an XML payload.