Router

abstract def apply(input: Input): Option[(Input, () ⇒ Future[A])]

Extracts some value of type A from the given input.

final def !=(arg0: Any): Boolean

final def ##(): Int

def /[B](that: Router[B])(implicit adjoin: PairAdjoin[A, B]): Router[PairAdjoin.Out]

Composes this router with the given that router.

def :+:[B](that: Router[B])(implicit adjoin: Adjoin[:+:[B, :+:[A, CNil]]]): Router[shapeless.ops.adjoin.Adjoin.Out]

Compose this router with another in such a way that coproducts are flattened.

final def ==(arg0: Any): Boolean

def ?[B](that: RequestReader[B])(implicit adjoin: PairAdjoin[A, B]): Router[PairAdjoin.Out]

Composes this router with the given io.finch.request.RequestReader.

def ap[B](fn: Router[(A) ⇒ B]): Router[B]

Flat-maps this router to the given function A => Router[B].

def apply(mapper: Mapper[A]): Router[Out]

Maps this Router to either A => B or A => Future[B].

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def embedFlatMap[B](fn: (A) ⇒ Future[B]): Router[B]

Flat-maps the router to the given function A => Future[B].

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](fn: (A) ⇒ B): Router[B]

Maps this router to the given function A => B.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toService[R](implicit arg0: ToRequest[R], ts: ToService[R, A]): Service[R, Response]

Converts this router to a Finagle service from a request-like type R to a com.twitter.finagle.httpx.Response.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: (A) ⇒ Boolean): Router[A]

def |[B >: A](that: Router[B]): Router[B]

Sequentially composes this router with the given that router.