SimpleWebSocketComboWorker

abstract def route: Route

abstract def websockets: Receive

User-defined websocket handler.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val DoubleNumber: PathMatcher1[Double]

val JavaUUID: PathMatcher1[UUID]

val Neutral: PathMatcher0

val Segments: PathMatcher1[List[String]]

implicit def actorRefFactory: ActorRefFactory

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 cancelAllRejections(cancelFilter: (Rejection) ⇒ Boolean): Directive0

def cancelRejection(rejection: Rejection): Directive0

def clientIP: Directive1[RemoteAddress]

def clone(): AnyRef

def closeLogic: Receive

def complete: (⇒ ToResponseMarshallable) ⇒ StandardRoute

def compressResponse(magnet: CompressResponseMagnet): Directive0

def compressResponseIfRequested(magnet: RefFactoryMagnet): Directive0

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

val connection: ActorRef

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

implicit def handler: ExceptionHandler

def handshaking: Receive

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]

var headers: List[HttpHeader]

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

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

def log: LoggingAdapter

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

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 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 def rejecter: RejectionHandler

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

final def rest: Receive

User-defined REST handler.

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

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

def sendWithAck(frame: TextFrame, downstream: ActorRef): Unit

Wandoulabs' WebSocket implementation doesn't support ack/nack-ing on the CommandFrame level.

final def sender(): ActorRef

def separateOnSlashes(string: String): PathMatcher0

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

implicit def settings: RoutingSettings

def stash(): Unit

def stashing: Receive

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

def timeoutRoute: Route

def toString(): String

def unhandled(message: Any): Unit

def unmatchedPath: Directive1[Path]

def unstashAll(): Unit

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 waitingForAck(downstream: ActorRef, sending: Frame): Receive

def waitingForRecovery(frame: Frame): Receive

def withRangeSupport(m: WithRangeSupportMagnet): Directive0

def PathElement: Segment.type