HttpServiceBase

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val DoubleNumber: PathMatcher1[Double]

A PathMatcher that matches and extracts a Double value.

object HexIntNumber extends NumberMatcher[Int]

A PathMatcher that efficiently matches a number of hex-digits and extracts their (non-negative) Int value.

object HexLongNumber extends NumberMatcher[Long]

A PathMatcher that efficiently matches a number of hex-digits and extracts their (non-negative) Long value.

object IntNumber extends NumberMatcher[Int]

A PathMatcher that efficiently matches a number of digits and extracts their (non-negative) Int value.

val JavaUUID: PathMatcher1[UUID]

A PathMatcher that matches and extracts a java.

object LongNumber extends NumberMatcher[Long]

A PathMatcher that efficiently matches a number of digits and extracts their (non-negative) Long value.

val Neutral: PathMatcher0

A PathMatcher that always matches, doesn't consume anything and extracts nothing.

object PathEnd extends PathMatcher0

A PathMatcher that matches the very end of the requests URI path.

object Rest extends PathMatcher1[String]

A PathMatcher that matches and extracts the complete remaining, unmatched part of the request's URI path as an (encoded!) String.

object RestPath extends PathMatcher1[Path]

A PathMatcher that matches and extracts the complete remaining, unmatched part of the request's URI path.

object Segment extends PathMatcher1[String]

A PathMatcher that matches if the unmatched path starts with a path segment.

val Segments: PathMatcher1[List[String]]

A PathMatcher that matches all remaining segments as a List[String].

object Slash extends PathMatcher0

A PathMatcher that matches a single slash character ('/').

def anyParam(apdm: AnyParamDefMagnet): Out

def anyParams(apdm: AnyParamDefMagnet): Out

def as[T](implicit um: FromRequestUnmarshaller[T]): FromRequestUnmarshaller[T]

Returns the in-scope FromRequestUnmarshaller for the given type.

final def asInstanceOf[T0]: T0

def authenticate[T](magnet: AuthMagnet[T]): Directive1[T]

Wraps its inner Route with authentication support.

def authorize(check: (RequestContext) ⇒ Boolean): Directive0

Applies the given authorization check to the request.

def authorize(check: ⇒ Boolean): Directive0

Applies the given authorization check to the request.

def autoChunk(csm: ChunkSizeMagnet): Directive0

Converts unchunked HttpResponses coming back from its inner route into chunked responses of which each chunk is smaller or equal to the given size, if the response entity is at least as large as the given threshold.

def autoChunkFileBytes(csm: ChunkSizeMagnet): Directive0

Converts unchunked HttpResponses coming back from its inner route into chunked responses of which each chunk is smaller or equal to the given size, if the response entity contains HttpData.

def cancelAllRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

Adds a TransformationRejection cancelling all rejections for which the given filter function returns true to the list of rejections potentially coming back from the inner route.

def cancelRejection(rejection: Rejection): Directive0

Adds a TransformationRejection cancelling all rejections equal to the given one to the list of rejections potentially coming back from the inner route.

def clientIP: Directive1[RemoteAddress]

Directive extracting the IP of the client from either the X-Forwarded-For, Remote-Address or X-Real-IP header (in that order of priority).

def clone(): AnyRef

def complete: (⇒ ToResponseMarshallable) ⇒ StandardRoute

Completes the request using the given arguments.

def compressResponse(magnet: CompressResponseMagnet): Directive0

Wraps its inner Route with response compression, using the specified encoders in the given order of preference.

def compressResponseIfRequested(magnet: RefFactoryMagnet): Directive0

Wraps its inner Route with response compression if and only if the client specifically requests compression with an Accept-Encoding header.

def conditional(eTag: EntityTag, lastModified: DateTime): Directive0

Wraps its inner route with support for Conditional Requests as defined by tools.

def cookie(name: String): Directive1[HttpCookie]

Extracts an HttpCookie with the given name.

def decodeRequest(decoder: Decoder): Directive0

Wraps its inner Route with decoding support using the given Decoder.

def decompressRequest(first: Decoder, more: Decoder*): Directive0

Decompresses the incoming request if it is encoded with one of the given encoders.

def decompressRequest(): Directive0

Decompresses the incoming request if it is GZip or Deflate encoded.

def delete: Directive0

A route filter that rejects all non-DELETE requests.

def deleteCookie(name: String, domain: String = "", path: String = ""): Directive0

Adds a Set-Cookie header expiring the given cookie to all responses of its inner route.

def deleteCookie(first: HttpCookie, more: HttpCookie*): Directive0

Adds a Set-Cookie header expiring the given cookies to all responses of its inner route.

def detach(dm: DetachMagnet): Directive0

Executes its inner Route in a Future.

def dynamic: ByNameDirective0

def dynamicIf(enabled: Boolean): ByNameDirective0

def encodeResponse(magnet: EncodeResponseMagnet): Directive0

Wraps its inner Route with encoding support using the given Encoder.

def entity[T](um: FromRequestUnmarshaller[T]): Directive1[T]

Unmarshalls the requests entity to the given type passes it to its inner Route.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extract[T](f: (RequestContext) ⇒ T): Directive1[T]

Extracts a single value using the given function.

def failWith(error: Throwable): StandardRoute

Bubbles the given error up the response chain, where it is dealt with by the closest handleExceptions directive and its ExceptionHandler.

def finalize(): Unit

def formField(fdm: FieldDefMagnet): Out

def formFields(fdm: FieldDefMagnet): Out

def get: Directive0

A route filter that rejects all non-GET requests.

final def getClass(): Class[_]

def getFromBrowseableDirectories(directories: String*)(implicit renderer: Marshaller[DirectoryListing], settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): (RequestContext) ⇒ Unit

Serves the content of the given directories as a file system browser, i.

def getFromBrowseableDirectory(directory: String)(implicit renderer: Marshaller[DirectoryListing], settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): (RequestContext) ⇒ Unit

Same as getFromBrowseableDirectories with only one directory.

def getFromDirectory(directoryName: String)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): (RequestContext) ⇒ Unit

Completes GET requests with the content of a file underneath the given directory.

def getFromFile(file: File, contentType: ContentType)(implicit settings: RoutingSettings, refFactory: ActorRefFactory): (RequestContext) ⇒ Unit

Completes GET requests with the content of the given file.

def getFromFile(file: File)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): (RequestContext) ⇒ Unit

Completes GET requests with the content of the given file.

def getFromFile(fileName: String)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): (RequestContext) ⇒ Unit

Completes GET requests with the content of the given file.

def getFromResource(resourceName: String, contentType: ContentType)(implicit refFactory: ActorRefFactory): (RequestContext) ⇒ Unit

Completes GET requests with the content of the given resource.

def getFromResource(resourceName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory): (RequestContext) ⇒ Unit

Completes GET requests with the content of the given resource.

def getFromResourceDirectory(directoryName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): (RequestContext) ⇒ Unit

Same as "getFromDirectory" except that the file is not fetched from the file system but rather from a "resource directory".

def handleExceptions(handler: ExceptionHandler): Directive0

Transforms exceptions thrown during evaluation of its inner route using the given spray.routing.ExceptionHandler.

def handleRejections(handler: RejectionHandler): Directive0

Transforms rejections produced by its inner route using the given spray.routing.RejectionHandler.

def handleUnhandledRejections: PF

def handleWith[A, B](f: (A) ⇒ B)(implicit um: FromRequestUnmarshaller[A], m: ToResponseMarshaller[B]): (RequestContext) ⇒ Unit

Completes the request using the given function.

def hashCode(): Int

def head: Directive0

A route filter that rejects all non-HEAD requests.

def headerValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[T]

Extracts an HTTP header value using the given function.

def headerValueByName(headerName: String): Directive1[String]

Extracts the value of the HTTP request header with the given name.

def headerValueByName(headerName: Symbol): Directive1[String]

Extracts the value of the HTTP request header with the given name.

def headerValueByType[T <: HttpHeader](magnet: ClassMagnet[T]): Directive1[T]

Extracts the HTTP request header of the given type.

def headerValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[T]

Extracts an HTTP header value using the given partial function.

def hextract[L <: HList](f: (RequestContext) ⇒ L): Directive[L]

Extracts a number of values using the given function.

def host(regex: Regex): Directive1[String]

Rejects all requests with a host name that doesn't have a prefix matching the given regular expression.

def host(predicate: (String) ⇒ Boolean): Directive0

Rejects all requests for whose host name the given predicate function returns false.

def host(hostNames: String*): Directive0

Rejects all requests with a host name different from the given ones.

def hostName: Directive1[String]

Extracts the hostname part of the Host header value in the request.

def hprovide[L <: HList](values: L): Directive[L]

Injects the given values into a directive.

def instanceOf[T](implicit m: ToResponseMarshaller[T]): ToResponseMarshaller[T]

Returns the in-scope Marshaller for the given type.

final def isInstanceOf[T0]: Boolean

def jsonpWithParameter(parameterName: String): Directive0

Wraps the inner Route with JSONP support.

def listDirectoryContents(directories: String*)(implicit renderer: Marshaller[DirectoryListing], refFactory: ActorRefFactory, log: LoggingContext): (RequestContext) ⇒ Unit

Completes GET requests with a unified listing of the contents of all given directories.

def logRequest(magnet: LoggingMagnet[(HttpRequest) ⇒ Unit]): Directive0

def logRequestResponse(magnet: LoggingMagnet[(HttpRequest) ⇒ (Any) ⇒ Unit]): Directive0

def logResponse(magnet: LoggingMagnet[(Any) ⇒ Unit]): Directive0

def mapHttpResponse(f: (HttpResponse) ⇒ HttpResponse): Directive0

def mapHttpResponseEntity(f: (HttpEntity) ⇒ HttpEntity): Directive0

def mapHttpResponseHeaders(f: (List[HttpHeader]) ⇒ List[HttpHeader]): Directive0

def mapHttpResponsePart(f: (HttpResponsePart) ⇒ HttpResponsePart): Directive0

def mapInnerRoute(f: ((RequestContext) ⇒ Unit) ⇒ (RequestContext) ⇒ Unit): Directive0

def mapRejections(f: (List[Rejection]) ⇒ List[Rejection]): Directive0

def mapRequest(f: (HttpRequest) ⇒ HttpRequest): Directive0

def mapRequestContext(f: (RequestContext) ⇒ RequestContext): Directive0

def mapRouteResponse(f: (Any) ⇒ Any): Directive0

def mapRouteResponsePF(f: PartialFunction[Any, Any]): Directive0

def method(httpMethod: HttpMethod): Directive0

Rejects all requests whose HTTP method does not match the given one.

final def ne(arg0: AnyRef): Boolean

def noop: Directive0

A Directive0 that always passes the request on to its inner route (i.

def nothingMatcher[L <: HList]: PathMatcher[L]

A PathMatcher that never matches.

final def notify(): Unit

final def notifyAll(): Unit

def ofType[T <: Rejection](implicit arg0: ClassTag[T]): (Rejection) ⇒ Boolean

def ofTypes(classes: Class[_]*): (Rejection) ⇒ Boolean

def onComplete[T](magnet: OnCompleteFutureMagnet[T]): Directive1[Try[T]]

"Unwraps" a Future[T] and runs its inner route after future completion with the future's value as an extraction of type Try[T].

def onConnectionClosed(ev: ConnectionClosed): Unit

Called by the runRoute behavior when a ConnectionClosed event is received.

def onFailure(magnet: OnFailureFutureMagnet): Directive1[Throwable]

"Unwraps" a Future[T] and runs its inner route when the future has failed with the future's failure exception as an extraction of type Throwable.

def onSuccess(magnet: OnSuccessFutureMagnet): Directive[Out]

"Unwraps" a Future[T] and runs its inner route after future completion with the future's value as an extraction of type T.

def optionalAuthenticate[T](magnet: AuthMagnet[T]): Directive1[Option[T]]

Wraps its inner Route with optional authentication support.

def optionalCookie(name: String): Directive1[Option[HttpCookie]]

Extracts an HttpCookie with the given name.

def optionalHeaderValue[T](f: (HttpHeader) ⇒ Option[T]): Directive1[Option[T]]

Extracts an optional HTTP header value using the given function.

def optionalHeaderValueByName(headerName: String): Directive1[Option[String]]

Extracts the value of the optional HTTP request header with the given name.

def optionalHeaderValueByName(headerName: Symbol): Directive1[Option[String]]

Extracts the value of the optional HTTP request header with the given name.

def optionalHeaderValueByType[T <: HttpHeader](magnet: ClassMagnet[T]): Directive1[Option[T]]

Extract the header value of the optional HTTP request header with the given type.

def optionalHeaderValuePF[T](pf: PartialFunction[HttpHeader, T]): Directive1[Option[T]]

Extracts an optional HTTP header value using the given partial function.

def options: Directive0

A route filter that rejects all non-OPTIONS requests.

def overrideMethodWithParameter(paramName: String): Directive0

Changes the HTTP method of the request to the value of the specified query string parameter.

def parameter(pdm: ParamDefMagnet): Out

def parameterMap: Directive[::[Map[String, String], HNil]]

Extracts the requests query parameters as a Map[String, String].

def parameterMultiMap: Directive[::[Map[String, List[String]], HNil]]

Extracts the requests query parameters as a Map[String, List[String]].

def parameterSeq: Directive[::[Seq[(String, String)], HNil]]

Extracts the requests query parameters as a Seq[(String, String)].

def parameters(pdm: ParamDefMagnet): Out

def pass: Directive0

A simple alias for the noop directive.

def patch: Directive0

A route filter that rejects all non-PATCH requests.

def path[L <: HList](pm: PathMatcher[L]): Directive[L]

Tries to consume a leading slash from the unmatched path of the spray.routing.RequestContext before applying the given matcher.

def pathEnd: Directive0

Rejects the request if the unmatchedPath of the spray.RequestContext is non-empty, or said differently: only passes on the request to its inner route if the request path has been matched completely.

def pathEndOrSingleSlash: Directive0

Only passes on the request to its inner route if the request path has been matched completely or only consists of exactly one remaining slash.

def pathPrefix[L <: HList](pm: PathMatcher[L]): Directive[L]

Tries to consume a leading slash from the unmatched path of the spray.routing.RequestContext before applying the given matcher.

def pathPrefixTest[L <: HList](pm: PathMatcher[L]): Directive[L]

Checks whether the unmatchedPath of the spray.RequestContext has a prefix matched by the given PathMatcher.

def pathSingleSlash: Directive0

Only passes on the request to its inner route if the request path consists of exactly one remaining slash.

def pathSuffix[L <: HList](pm: PathMatcher[L]): Directive[L]

Rejects the request if the unmatchedPath of the spray.RequestContext does not have a suffix matched the given PathMatcher.

def pathSuffixTest[L <: HList](pm: PathMatcher[L]): Directive[L]

Checks whether the unmatchedPath of the spray.RequestContext has a suffix matched by the given PathMatcher.

implicit def pimpRouteWithConcatenation(route: (RequestContext) ⇒ Unit): RouteConcatenation

def post: Directive0

A route filter that rejects all non-POST requests.

def produce[T](marshaller: ToResponseMarshaller[T]): Directive[::[(T) ⇒ Unit, HNil]]

Uses the marshaller for the given type to produce a completion function that is passed to its inner route.

def provide[T](value: T): Directive1[T]

Injects the given value into a directive.

def put: Directive0

A route filter that rejects all non-PUT requests.

def rawPathPrefix[L <: HList](pm: PathMatcher[L]): Directive[L]

Applies the given matcher directly to the unmatched path of the spray.routing.RequestContext (i.

def rawPathPrefixTest[L <: HList](pm: PathMatcher[L]): Directive[L]

Checks whether the unmatchedPath of the spray.RequestContext has a prefix matched by the given PathMatcher.

def redirect(uri: Uri, redirectionType: Redirection): StandardRoute

Completes the request with redirection response of the given type to the given URI.

implicit def regex2PathMatcher(regex: Regex): PathMatcher1[String]

Creates a PathMatcher that consumes (a prefix of) the first path segment if the path begins with a segment (a prefix of) which matches the given regex.

def reject(rejections: Rejection*): StandardRoute

Rejects the request with the given rejections.

def reject: StandardRoute

Rejects the request with an empty set of rejections.

def rejectEmptyResponse: Directive0

Converts responses with an empty entity into (empty) rejections.

def requestEncodedWith(encoding: HttpEncoding): Directive0

Rejects the request with an UnsupportedRequestEncodingRejection if its encoding doesn't match the given one.

def requestEntityEmpty: Directive0

Rejects the request if its entity is not empty.

def requestEntityPresent: Directive0

Rejects empty requests with a RequestEntityExpectedRejection.

def requestInstance: Directive1[HttpRequest]

Extracts the complete request.

def requestUri: Directive1[Uri]

Extracts the complete request URI.

def respondWithHeader(responseHeader: HttpHeader): Directive0

Unconditionally adds the given response header to all HTTP responses of its inner Route.

def respondWithHeaders(responseHeaders: List[HttpHeader]): Directive0

Unconditionally adds the given response headers to all HTTP responses of its inner Route.

def respondWithHeaders(responseHeaders: HttpHeader*): Directive0

Unconditionally adds the given response headers to all HTTP responses of its inner Route.

def respondWithLastModifiedHeader(timestamp: Long): Directive0

Adds a Last-Modified header to all HttpResponses from its inner Route.

def respondWithMediaType(mediaType: MediaType): Directive0

Overrides the media-type of the response returned by its inner route with the given one.

def respondWithSingletonHeader(responseHeader: HttpHeader): Directive0

Adds the given response header to all HTTP responses of its inner Route, if the response from the inner Route doesn't already contain a header with the same name.

def respondWithSingletonHeaders(responseHeaders: List[HttpHeader]): Directive0

def respondWithSingletonHeaders(responseHeaders: HttpHeader*): Directive0

Adds the given response headers to all HTTP responses of its inner Route, if a header already exists it is not added again.

def respondWithStatus(responseStatus: StatusCode): Directive0

Overrides the given response status on all HTTP responses of its inner Route.

def responseEncodingAccepted(encoding: HttpEncoding): Directive0

Rejects the request with an UnacceptedResponseEncodingRejection if the given encoding is not accepted for the response.

def rewriteUnmatchedPath(f: (Path) ⇒ Path): Directive0

Transforms the unmatchedPath of the RequestContext using the given function.

def routeRouteResponse(f: PartialFunction[Any, (RequestContext) ⇒ Unit]): Directive0

def runRoute(route: (RequestContext) ⇒ Unit)(implicit eh: ExceptionHandler, rh: RejectionHandler, ac: ActorContext, rs: RoutingSettings, log: LoggingContext): Receive

Supplies the actor behavior for executing the given route.

def scheme(schm: String): Directive0

Rejects all requests whose Uri scheme does not match the given one.

def schemeName: Directive1[String]

Extracts the Uri scheme from the request.

def sealRejectionHandler(rh: RejectionHandler): RejectionHandler

def sealRoute(route: (RequestContext) ⇒ Unit)(implicit eh: ExceptionHandler, rh: RejectionHandler): (RequestContext) ⇒ Unit

"Seals" a route by wrapping it with exception handling and rejection conversion.

implicit def segmentStringToPathMatcher(segment: String): PathMatcher0

Creates a PathMatcher that consumes (a prefix of) the first path segment (if the path begins with a segment).

def separateOnSlashes(string: String): PathMatcher0

Converts a path string containing slashes into a PathMatcher that interprets slashes as path segment separators.

def setCookie(first: HttpCookie, more: HttpCookie*): Directive0

Adds a Set-Cookie header with the given cookies to all responses of its inner route.

implicit def string2NR(string: String): NameReceptacle[String]

implicit def stringExtractionPair2PathMatcher[T](tuple: (String, T)): PathMatcher1[T]

Creates a PathMatcher that consumes (a prefix of) the first path segment (if the path begins with a segment) and extracts a given value.

implicit def stringOptionNameReceptacle2PathMatcher(nr: NameReceptacle[Option[String]]): PathMatcher0

implicit def symbol2NR(symbol: Symbol): NameReceptacle[String]

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

def timeoutRoute: (RequestContext) ⇒ Unit

def toString(): String

def unmatchedPath: Directive1[Path]

Extracts the unmatched path from the RequestContext.

def validate(check: ⇒ Boolean, errorMsg: String): Directive0

Returns a Directive which checks the given condition before passing on the spray.routing.RequestContext to its inner Route.

implicit def valueMap2PathMatcher[T](valueMap: Map[String, T]): PathMatcher1[T]

Creates a PathMatcher from the given Map of path segments (prefixes) to extracted values.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRangeSupport(m: WithRangeSupportMagnet): Directive0

Answers GET requests with an Accept-Ranges: bytes header and converts HttpResponses coming back from its inner route into partial responses if the initial request contained a valid Range request header.

def PathElement: Segment.type