AppHandler

Instance Constructors

new AppHandler(store: ActorRef)

Type Members

abstract class NumberMatcher[T] extends PathMatcher1[T]

Definition Classes
PathMatchers
type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor
class RouteConcatenation extends AnyRef

Definition Classes
RouteConcatenation
type RouteResponse = Either[Seq[Rejection], HttpResponse]

Definition Classes
CachingDirectives

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val DoubleNumber: PathMatcher1[Double]

Definition Classes
PathMatchers
val JavaUUID: PathMatcher1[UUID]

Definition Classes
PathMatchers
val Neutral: PathMatcher0

Definition Classes
PathMatchers
object Segment extends PathMatcher1[String]

Definition Classes
PathMatchers
val Segments: PathMatcher1[List[String]]

Definition Classes
PathMatchers
def actorRefFactory: ActorRefFactory

Definition Classes
AppHandler → HttpService
def alwaysCache(csm: CacheSpecMagnet): Directive0

Definition Classes
CachingDirectives
def anyParam(apdm: AnyParamDefMagnet): Out

Definition Classes
AnyParamDirectives
def anyParams(apdm: AnyParamDefMagnet): Out

Definition Classes
AnyParamDirectives
def aroundPostRestart(reason: Throwable): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPostStop(): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundPreStart(): Unit

Attributes
protected[akka]
Definition Classes
Actor
def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit

Attributes
protected[akka]
Definition Classes
Actor
def as[T](implicit um: FromRequestUnmarshaller[T]): FromRequestUnmarshaller[T]

Definition Classes
MarshallingDirectives
final def asInstanceOf[T0]: T0

Definition Classes
Any
def authenticate[T](magnet: AuthMagnet[T]): Directive1[T]

Definition Classes
SecurityDirectives
def authorize(check: (RequestContext) ⇒ Boolean): Directive0

Definition Classes
SecurityDirectives
def authorize(check: ⇒ Boolean): Directive0

Definition Classes
SecurityDirectives
def autoChunk(csm: ChunkSizeMagnet): Directive0

Definition Classes
ChunkingDirectives
def autoChunkFileBytes(csm: ChunkSizeMagnet): Directive0

Definition Classes
ChunkingDirectives
def cache(csm: CacheSpecMagnet): Directive0

Definition Classes
CachingDirectives
def cachingProhibited: Directive0

Definition Classes
CachingDirectives
def cancelAllRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

Definition Classes
MiscDirectives
def cancelRejection(rejection: Rejection): Directive0

Definition Classes
MiscDirectives
def clientIP: Directive1[RemoteAddress]

Definition Classes
MiscDirectives
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def complete: (⇒ ToResponseMarshallable) ⇒ StandardRoute

Definition Classes
RouteDirectives
def compressResponse(magnet: CompressResponseMagnet): Directive0

Definition Classes
EncodingDirectives
def compressResponseIfRequested(magnet: RefFactoryMagnet): Directive0

Definition Classes
EncodingDirectives
def conditional(eTag: EntityTag, lastModified: DateTime): Directive0

Definition Classes
CacheConditionDirectives
implicit val context: ActorContext

Definition Classes
Actor
def cookie(name: String): Directive1[HttpCookie]

Definition Classes
CookieDirectives
def decodeRequest(decoder: Decoder): Directive0

Definition Classes
EncodingDirectives
def decompressRequest(first: Decoder, more: Decoder*): Directive0

Definition Classes
EncodingDirectives
def decompressRequest(): Directive0

Definition Classes
EncodingDirectives
def delete: Directive0

Definition Classes
MethodDirectives
def deleteCookie(name: String, domain: String, path: String): Directive0

Definition Classes
CookieDirectives
def deleteCookie(first: HttpCookie, more: HttpCookie*): Directive0

Definition Classes
CookieDirectives
def detach(dm: DetachMagnet): Directive0

Definition Classes
ExecutionDirectives
def dynamic: ByNameDirective0

Definition Classes
ExecutionDirectives
def dynamicIf(enabled: Boolean): ByNameDirective0

Definition Classes
ExecutionDirectives
def encodeResponse(magnet: EncodeResponseMagnet): Directive0

Definition Classes
EncodingDirectives
def entity[T](um: FromRequestUnmarshaller[T]): Directive1[T]

Definition Classes
MarshallingDirectives
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def extract[T](f: (RequestContext) ⇒ T): Directive1[T]

Definition Classes
BasicDirectives
def failWith(error: Throwable): StandardRoute

Definition Classes
RouteDirectives
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def formField(fdm: FieldDefMagnet): Out

Definition Classes
FormFieldDirectives
def formFields(fdm: FieldDefMagnet): Out

Definition Classes
FormFieldDirectives
def get: Directive0

Definition Classes
MethodDirectives
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getFromBrowseableDirectories(directories: String*)(implicit renderer: Marshaller[DirectoryListing], settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): Route

Definition Classes
FileAndResourceDirectives
def getFromBrowseableDirectory(directory: String)(implicit renderer: Marshaller[DirectoryListing], settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): Route

Definition Classes
FileAndResourceDirectives
def getFromDirectory(directoryName: String)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(file: File, contentType: ContentType)(implicit settings: RoutingSettings, refFactory: ActorRefFactory): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(file: File)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

Definition Classes
FileAndResourceDirectives
def getFromFile(fileName: String)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

Definition Classes
FileAndResourceDirectives
def getFromResource(resourceName: String, contentType: ContentType)(implicit refFactory: ActorRefFactory): Route

Definition Classes
FileAndResourceDirectives
def getFromResource(resourceName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

Definition Classes
FileAndResourceDirectives
def getFromResourceDirectory(directoryName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): Route

Definition Classes
FileAndResourceDirectives
def handleExceptions(handler: ExceptionHandler): Directive0

Definition Classes
ExecutionDirectives
def handleRejections(handler: RejectionHandler): Directive0

Definition Classes
ExecutionDirectives
def handleUnhandledRejections: PF

Definition Classes
HttpServiceBase
def handleWith[A, B](f: (A) ⇒ B)(implicit um: FromRequestUnmarshaller[A], m: ToResponseMarshaller[B]): Route

Definition Classes
MarshallingDirectives
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: Directive0

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

Definition Classes
HeaderDirectives
def headerValueByName(headerName: String): Directive1[String]

Definition Classes
HeaderDirectives
def headerValueByName(headerName: Symbol): Directive1[String]

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

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

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

Definition Classes
BasicDirectives
def host(regex: Regex): Directive1[String]

Definition Classes
HostDirectives
def host(predicate: (String) ⇒ Boolean): Directive0

Definition Classes
HostDirectives
def host(hostNames: String*): Directive0

Definition Classes
HostDirectives
def hostName: Directive1[String]

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

Definition Classes
BasicDirectives
def instanceOf[T](implicit m: ToResponseMarshaller[T]): ToResponseMarshaller[T]

Definition Classes
MarshallingDirectives
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def jsonpWithParameter(parameterName: String): Directive0

Definition Classes
MiscDirectives
def listDirectoryContents(directories: String*)(implicit renderer: Marshaller[DirectoryListing], refFactory: ActorRefFactory, log: LoggingContext): Route

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

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

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

Definition Classes
DebuggingDirectives
def mapHttpResponse(f: (HttpResponse) ⇒ HttpResponse): Directive0

Definition Classes
BasicDirectives
def mapHttpResponseEntity(f: (HttpEntity) ⇒ HttpEntity): Directive0

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

Definition Classes
BasicDirectives
def mapHttpResponsePart(f: (HttpResponsePart) ⇒ HttpResponsePart): Directive0

Definition Classes
BasicDirectives
def mapInnerRoute(f: (Route) ⇒ Route): Directive0

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

Definition Classes
BasicDirectives
def mapRequest(f: (HttpRequest) ⇒ HttpRequest): Directive0

Definition Classes
BasicDirectives
def mapRequestContext(f: (RequestContext) ⇒ RequestContext): Directive0

Definition Classes
BasicDirectives
def mapRouteResponse(f: (Any) ⇒ Any): Directive0

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

Definition Classes
BasicDirectives
def method(httpMethod: HttpMethod): Directive0

Definition Classes
MethodDirectives
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def noop: Directive0

Definition Classes
BasicDirectives
def nothingMatcher[L <: HList]: PathMatcher[L]

Definition Classes
PathMatchers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

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

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

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

Definition Classes
FutureDirectives
def onConnectionClosed(ev: ConnectionClosed): Unit

Definition Classes
HttpServiceBase
def onFailure(magnet: OnFailureFutureMagnet): Directive1[Throwable]

Definition Classes
FutureDirectives
def onSuccess(magnet: OnSuccessFutureMagnet): Directive[Out]

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

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

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

Definition Classes
HeaderDirectives
def optionalHeaderValueByName(headerName: String): Directive1[Option[String]]

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

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

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

Definition Classes
HeaderDirectives
def options: Directive0

Definition Classes
MethodDirectives
def overrideMethodWithParameter(paramName: String): Directive0

Definition Classes
MethodDirectives
def parameter(pdm: ParamDefMagnet): Out

Definition Classes
ParameterDirectives
def parameterMap: Directive1[Map[String, String]]

Definition Classes
ParameterDirectives
def parameterMultiMap: Directive1[Map[String, List[String]]]

Definition Classes
ParameterDirectives
def parameterSeq: Directive1[Seq[(String, String)]]

Definition Classes
ParameterDirectives
def parameters(pdm: ParamDefMagnet): Out

Definition Classes
ParameterDirectives
def pass: Directive0

Definition Classes
BasicDirectives
def patch: Directive0

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

Definition Classes
PathDirectives
def pathEnd: Directive0

Definition Classes
PathDirectives
def pathEndOrSingleSlash: Directive0

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

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

Definition Classes
PathDirectives
def pathSingleSlash: Directive0

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

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

Definition Classes
PathDirectives
implicit def pimpRouteWithConcatenation(route: Route): RouteConcatenation

Definition Classes
RouteConcatenation
def post: Directive0

Definition Classes
MethodDirectives
def postRestart(reason: Throwable): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def postStop(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def preStart(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def produce[T](marshaller: ToResponseMarshaller[T]): Directive[::[(T) ⇒ Unit, HNil]]

Definition Classes
MarshallingDirectives
def provide[T](value: T): Directive1[T]

Definition Classes
BasicDirectives
def put: Directive0

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

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

Definition Classes
PathDirectives
def receive: akka.actor.Actor.Receive

Definition Classes
AppHandler → Actor
def redirect(uri: Uri, redirectionType: Redirection): StandardRoute

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

Definition Classes
ImplicitPathMatcherConstruction
def reject(rejections: Rejection*): StandardRoute

Definition Classes
RouteDirectives
def reject: StandardRoute

Definition Classes
RouteDirectives
def rejectEmptyResponse: Directive0

Definition Classes
MiscDirectives
def requestEncodedWith(encoding: HttpEncoding): Directive0

Definition Classes
EncodingDirectives
def requestEntityEmpty: Directive0

Definition Classes
MiscDirectives
def requestEntityPresent: Directive0

Definition Classes
MiscDirectives
def requestInstance: Directive1[HttpRequest]

Definition Classes
MiscDirectives
def requestUri: Directive1[Uri]

Definition Classes
MiscDirectives
def respondWithHeader(responseHeader: HttpHeader): Directive0

Definition Classes
RespondWithDirectives
def respondWithHeaders(responseHeaders: List[HttpHeader]): Directive0

Definition Classes
RespondWithDirectives
def respondWithHeaders(responseHeaders: HttpHeader*): Directive0

Definition Classes
RespondWithDirectives
def respondWithLastModifiedHeader(timestamp: Long): Directive0

Definition Classes
FileAndResourceDirectives
def respondWithMediaType(mediaType: MediaType): Directive0

Definition Classes
RespondWithDirectives
def respondWithSingletonHeader(responseHeader: HttpHeader): Directive0

Definition Classes
RespondWithDirectives
def respondWithSingletonHeaders(responseHeaders: List[HttpHeader]): Directive0

Definition Classes
RespondWithDirectives
def respondWithSingletonHeaders(responseHeaders: HttpHeader*): Directive0

Definition Classes
RespondWithDirectives
def respondWithStatus(responseStatus: StatusCode): Directive0

Definition Classes
RespondWithDirectives
def responseEncodingAccepted(encoding: HttpEncoding): Directive0

Definition Classes
EncodingDirectives
def rewriteUnmatchedPath(f: (Path) ⇒ Path): Directive0

Definition Classes
MiscDirectives
def routeCache(maxCapacity: Int, initialCapacity: Int, timeToLive: Duration, timeToIdle: Duration): Cache[RouteResponse]

Definition Classes
CachingDirectives
def routeRouteResponse(f: PartialFunction[Any, Route]): Directive0

Definition Classes
BasicDirectives
def runRoute(route: Route)(implicit eh: ExceptionHandler, rh: RejectionHandler, ac: ActorContext, rs: RoutingSettings, log: LoggingContext): akka.actor.Actor.Receive

Definition Classes
HttpServiceBase
def scheme(schm: String): Directive0

Definition Classes
SchemeDirectives
def schemeName: Directive1[String]

Definition Classes
SchemeDirectives
def sealRejectionHandler(rh: RejectionHandler): RejectionHandler

Definition Classes
HttpServiceBase
def sealRoute(route: Route)(implicit eh: ExceptionHandler, rh: RejectionHandler): Route

Definition Classes
HttpServiceBase
implicit def segmentStringToPathMatcher(segment: String): PathMatcher0

Definition Classes
ImplicitPathMatcherConstruction
implicit final val self: ActorRef

Definition Classes
Actor
final def sender(): ActorRef

Definition Classes
Actor
def separateOnSlashes(string: String): PathMatcher0

Definition Classes
PathMatchers
def setCookie(first: HttpCookie, more: HttpCookie*): Directive0

Definition Classes
CookieDirectives
implicit def string2NR(string: String): NameReceptacle[String]

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

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

Definition Classes
ImplicitPathMatcherConstruction
def supervisorStrategy: SupervisorStrategy

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

Definition Classes
ToNameReceptaclePimps
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def timeoutRoute: Route

Definition Classes
HttpServiceBase
def toString(): String

Definition Classes
AnyRef → Any
def unhandled(message: Any): Unit

Definition Classes
Actor
def unmatchedPath: Directive1[Path]

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

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

Definition Classes
ImplicitPathMatcherConstruction
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withRangeSupport(m: WithRangeSupportMagnet): Directive0

Definition Classes
RangeDirectives

Deprecated Value Members

def PathElement: Segment.type

Definition Classes
PathMatchers
Annotations
@deprecated
Deprecated
(Since version 1.0-M8/1.1-M8) Use Segment instead

Related Doc: package app

final class AppHandler extends Actor with HttpService with CachingDirectives

Instance Constructors

new AppHandler(store: ActorRef)

Type Members

abstract class NumberMatcher[T] extends PathMatcher1[T]

type Receive = PartialFunction[Any, Unit]

class RouteConcatenation extends AnyRef

type RouteResponse = Either[Seq[Rejection], HttpResponse]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DoubleNumber: PathMatcher1[Double]

val JavaUUID: PathMatcher1[UUID]

val Neutral: PathMatcher0

object Segment extends PathMatcher1[String]

val Segments: PathMatcher1[List[String]]

def actorRefFactory: ActorRefFactory

def alwaysCache(csm: CacheSpecMagnet): Directive0

def anyParam(apdm: AnyParamDefMagnet): Out

def anyParams(apdm: AnyParamDefMagnet): Out

def aroundPostRestart(reason: Throwable): Unit

def aroundPostStop(): Unit

def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

def aroundPreStart(): Unit

def aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit

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

final def asInstanceOf[T0]: T0

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

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

def authorize(check: ⇒ Boolean): Directive0

def autoChunk(csm: ChunkSizeMagnet): Directive0

def autoChunkFileBytes(csm: ChunkSizeMagnet): Directive0

def cache(csm: CacheSpecMagnet): Directive0

def cachingProhibited: Directive0

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

def cancelRejection(rejection: Rejection): Directive0

def clientIP: Directive1[RemoteAddress]

def clone(): AnyRef

def complete: (⇒ ToResponseMarshallable) ⇒ StandardRoute

def compressResponse(magnet: CompressResponseMagnet): Directive0

def compressResponseIfRequested(magnet: RefFactoryMagnet): Directive0

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

implicit val context: ActorContext

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

def decodeRequest(decoder: Decoder): Directive0

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

def decompressRequest(): Directive0

def delete: Directive0

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

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

def detach(dm: DetachMagnet): Directive0

def dynamic: ByNameDirective0

def dynamicIf(enabled: Boolean): ByNameDirective0

def encodeResponse(magnet: EncodeResponseMagnet): Directive0

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def failWith(error: Throwable): StandardRoute

def finalize(): Unit

def formField(fdm: FieldDefMagnet): Out

def formFields(fdm: FieldDefMagnet): Out

def get: Directive0

final def getClass(): Class[_]

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

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

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

def getFromFile(file: File, contentType: ContentType)(implicit settings: RoutingSettings, refFactory: ActorRefFactory): Route

def getFromFile(file: File)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

def getFromFile(fileName: String)(implicit settings: RoutingSettings, resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

def getFromResource(resourceName: String, contentType: ContentType)(implicit refFactory: ActorRefFactory): Route

def getFromResource(resourceName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory): Route

def getFromResourceDirectory(directoryName: String)(implicit resolver: ContentTypeResolver, refFactory: ActorRefFactory, log: LoggingContext): Route

def handleExceptions(handler: ExceptionHandler): Directive0

def handleRejections(handler: RejectionHandler): Directive0

def handleUnhandledRejections: PF

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