ServerActor

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]

val JavaUUID: PathMatcher1[UUID]

val Neutral: PathMatcher0

val Segments: PathMatcher1[List[String]]

def actorRefFactory: ActorContext

The following is required by HttpService

val algorithms: Seq[BaseAlgorithm[_, _, Q, P]]

val algorithmsParams: Seq[Params]

def anyParam(apdm: AnyParamDefMagnet): Out

def anyParams(apdm: AnyParamDefMagnet): Out

val args: ServerConfig

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

var avgServingSec: Double

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]

val dataSourceParams: Params

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

val engine: Engine[_, _, _, Q, P, _]

val engineInstance: EngineInstance

val engineLanguage: EngineLanguage.Value

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

val feedbackEnabled: Boolean

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): (RequestContext) ⇒ Unit

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

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

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

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

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

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

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

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

def getStackTraceString(e: Throwable): String

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]): (RequestContext) ⇒ Unit

def hashCode(): Int

def head: Directive0

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

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

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

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

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

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

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

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

def host(hostNames: String*): Directive0

def hostName: Directive1[String]

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

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

final def isInstanceOf[T0]: Boolean

def jsonpWithParameter(parameterName: String): Directive0

var lastServingSec: Double

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

val log: LoggingAdapter

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

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

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

val manifest: EngineManifest

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

val models: Seq[Any]

val myRoute: (RequestContext) ⇒ Unit

final def ne(arg0: AnyRef): Boolean

def noop: Directive0

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

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]]

def onConnectionClosed(ev: ConnectionClosed): Unit

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

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

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

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

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

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

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

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

def options: Directive0

def overrideMethodWithParameter(paramName: String): Directive0

def parameter(pdm: ParamDefMagnet): Out

def parameterMap: Directive1[Map[String, String]]

def parameterMultiMap: Directive1[Map[String, List[String]]]

def parameterSeq: Directive1[Seq[(String, String)]]

def parameters(pdm: ParamDefMagnet): Out

def pass: Directive0

def patch: Directive0

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

def pathEnd: Directive0

def pathEndOrSingleSlash: Directive0

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

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

def pathSingleSlash: Directive0

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

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

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

val pluginContext: EngineServerPluginContext

val pluginsActorRef: ActorRef

def post: Directive0

def postRestart(reason: Throwable): Unit

def postStop(): Unit

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

def preStart(): Unit

val preparatorParams: Params

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

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

def put: Directive0

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

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

def receive: akka.actor.Actor.Receive

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

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

def reject(rejections: Rejection*): StandardRoute

def reject: StandardRoute

def rejectEmptyResponse: Directive0

def remoteLog(logUrl: String, logPrefix: String, message: String): Unit

var requestCount: Int

def requestEncodedWith(encoding: HttpEncoding): Directive0

def requestEntityEmpty: Directive0

def requestEntityPresent: Directive0

def requestInstance: Directive1[HttpRequest]

def requestUri: Directive1[Uri]

def respondWithHeader(responseHeader: HttpHeader): Directive0

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

def respondWithHeaders(responseHeaders: HttpHeader*): Directive0

def respondWithLastModifiedHeader(timestamp: Long): Directive0

def respondWithMediaType(mediaType: MediaType): Directive0

def respondWithSingletonHeader(responseHeader: HttpHeader): Directive0

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

def respondWithSingletonHeaders(responseHeaders: HttpHeader*): Directive0

def respondWithStatus(responseStatus: StatusCode): Directive0

def responseEncodingAccepted(encoding: HttpEncoding): Directive0

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

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

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

def scheme(schm: String): Directive0

def schemeName: Directive1[String]

def sealRejectionHandler(rh: RejectionHandler): RejectionHandler

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

implicit def segmentStringToPathMatcher(segment: String): PathMatcher0

implicit final val self: ActorRef

final def sender(): ActorRef

def separateOnSlashes(string: String): PathMatcher0

val serverStartTime: DateTime

val serving: BaseServing[Q, P]

val servingParams: Params

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

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

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

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

def supervisorStrategy: SupervisorStrategy

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

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

implicit val timeout: Timeout

def timeoutRoute: (RequestContext) ⇒ Unit

def toString(): String

def unhandled(message: Any): Unit

def unmatchedPath: Directive1[Path]

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRangeSupport(m: WithRangeSupportMagnet): Directive0

def PathElement: Segment.type