RoutedService

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit val ByteArrayMarshaller: Marshaller[Array[Byte]]

implicit val ByteStringMarshaller: Marshaller[ByteString]

implicit val CharArrayMarshaller: Marshaller[Array[Char]]

val DoubleNumber: PathMatcher1[Double]

implicit val FormDataMarshaller: Marshaller[FormData]

implicit val HttpDataMarshaller: Marshaller[HttpData]

implicit val HttpEntityMarshaller: Marshaller[HttpEntity]

val JavaUUID: PathMatcher1[UUID]

val Neutral: PathMatcher0

implicit val NodeSeqMarshaller: Marshaller[NodeSeq]

val Segments: PathMatcher1[List[String]]

implicit val StringMarshaller: Marshaller[String]

implicit val ThrowableMarshaller: Marshaller[Throwable]

object UUIDSerializer extends CustomSerializer[UUID] with Product with Serializable

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

val base: Receive

def byteArrayMarshaller(contentType: ContentType): Marshaller[Array[Byte]]

def byteStringMarshaller(contentType: ContentType): Marshaller[ByteString]

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

implicit def eitherMarshaller[A, B](implicit ma: Marshaller[A], mb: Marshaller[B]): Marshaller[Either[A, B]]

def encodeResponse(magnet: EncodeResponseMagnet): Directive0

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val exceptionHandler: ExceptionHandler

Wrap all Exceptions in the com.github.vonnagy.service.container.http.RejectionResponse class then marshall as json.

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

implicit val fact: ActorContext

def failWith(error: Throwable): StandardRoute

def finalize(): Unit

def formField(fdm: FieldDefMagnet): Out

def formFields(fdm: FieldDefMagnet): Out

implicit def futureMarshaller[T](implicit m: Marshaller[T], ec: ExecutionContext): Marshaller[Future[T]]

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

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 httpDataMarshaller(contentType: ContentType): Marshaller[HttpData]

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

final def isInstanceOf[T0]: Boolean

implicit def jsonFormats: Formats

def jsonMarshaller[T <: AnyRef]: Marshaller[AnyRef]

def jsonUnmarshaller[T](implicit arg0: Manifest[T]): Unmarshaller[T]

def jsonpWithParameter(parameterName: String): Directive0

def liftJson(implicit fmt: Formats): LiftJsonSupport

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

lazy val log: Logger

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

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

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

implicit def mMarshaller[M[_], T](implicit mm: MarshallerM[M], mt: Marshaller[T]): Marshaller[M[T]]

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

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]

implicit def optionMarshaller[T](implicit m: Marshaller[T]): Marshaller[Option[T]]

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

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: Route): RouteConcatenation

def plainMarshaller[T]: Marshaller[T]

def post: Directive0

def postRestart(reason: Throwable): Unit

def postStop(): Unit

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

def preStart(): Unit

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: PartialFunction[Any, Unit]

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

implicit val rejectionHandler: RejectionHandler

Wrap all Rejections in the com.github.vonnagy.service.container.http.RejectionResponse class then marshall as json.

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

val routeEndpoints: Seq[Class[_ <: RoutedEndpoints]]

the routes to manage

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

def runRoute(route: Route)(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: Route)(implicit eh: ExceptionHandler, rh: RejectionHandler): Route

implicit def segmentStringToPathMatcher(segment: String): PathMatcher0

implicit final val self: ActorRef

final def sender(): ActorRef

def separateOnSlashes(string: String): PathMatcher0

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

implicit def streamMarshaller[T](implicit marshaller: Marshaller[T], refFactory: ActorRefFactory): Marshaller[Stream[T]]

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

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

def stringMarshaller(contentType: ContentType, more: ContentType*): Marshaller[String]

def stringMarshaller(charset: HttpCharset, more: HttpCharset*): Marshaller[String]

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

def timeoutRoute: Route

def toString(): String

implicit def tryMarshaller[T](implicit m: Marshaller[T]): Marshaller[Try[T]]

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