object RawRest extends RawRpcCompanion[RawRest]

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RawRest
  2. RawRpcCompanion
  3. RpcImplicitsProvider
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type AsRawRealRpc[Real] = AsRawReal[RawRest, Real]
    Definition Classes
    RawRpcCompanion
  2. type AsRawRpc[Real] = AsRaw[RawRest, Real]
    Definition Classes
    RawRpcCompanion
  3. type AsRealRpc[Real] = AsReal[RawRest, Real]
    Definition Classes
    RawRpcCompanion
  4. type Async[T] = (Callback[T]) ⇒ Unit

    The most low-level, raw type representing an asynchronous, possibly side-effecting operation that yields a value of type T as a result.

    The most low-level, raw type representing an asynchronous, possibly side-effecting operation that yields a value of type T as a result. Async is a consumer of a callback. When a callback is passed to Async, it should start the operation and ultimately notify the callback about the result. Each time the callback is passed, the entire operation should be repeated, involving all possible side effects. Operation should never be started without the callback being passed (i.e. there should be no observable side effects before a callback is passed). Implementation of Async should also be prepared to accept a callback before the previous one was notified about the result (i.e. it should support concurrent execution).

  5. type Callback[T] = (commons.Try[T]) ⇒ Unit

    A callback that gets notified when value of type T gets computed or when computation of that value fails.

    A callback that gets notified when value of type T gets computed or when computation of that value fails. Callbacks should never throw exceptions. Preferably, they should be simple notifiers that delegate the real work somewhere else, e.g. schedule some handling code on a separate executor (e.g. ExecutionContext).

  6. type HandleRequest = (RestRequest) ⇒ Async[RestResponse]

    Raw type of an operation that executes a RestRequest.

    Raw type of an operation that executes a RestRequest. The operation should be run every time the resulting Async value is passed a callback. It should not be run before that. Each run may involve side effects, network communication, etc. Runs may be concurrent. Request handlers should never throw exceptions but rather convert them into failing implementation of Async. One way to do this is by wrapping the handler with safeHandle.

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def asHandleRequest[Real](real: Real)(implicit arg0: AsRawRpc[Real], arg1: RestMetadata[Real]): HandleRequest
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def asRaw[Real](real: Real)(implicit asRawRpc: AsRawRpc[Real]): RawRest
    Definition Classes
    RawRpcCompanion
  7. def asReal[Real](raw: RawRest)(implicit asRealRpc: AsRealRpc[Real]): Real
    Definition Classes
    RawRpcCompanion
  8. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  9. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  10. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  11. def failingAsync[T](cause: Throwable): Async[T]
  12. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  13. def fromHandleRequest[Real](handleRequest: HandleRequest)(implicit arg0: AsRealRpc[Real], arg1: RestMetadata[Real]): Real
  14. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  15. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. val implicits: Any

    If you want some more implicits to be visible by RPC macros, make the companion of your raw RPC trait extend RpcImplicitsProvider (e.g.

    If you want some more implicits to be visible by RPC macros, make the companion of your raw RPC trait extend RpcImplicitsProvider (e.g. through RpcMetadataCompanion), override this val with an object and put your additional implicits into it.

    Definition Classes
    RpcImplicitsProvider
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. macro def materializeAsRaw[Real]: AsRawRpc[Real]
    Definition Classes
    RawRpcCompanion
  19. macro def materializeAsRawReal[Real]: AsRawRealRpc[Real]
    Definition Classes
    RawRpcCompanion
  20. macro def materializeAsReal[Real]: AsRealRpc[Real]
    Definition Classes
    RawRpcCompanion
  21. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  22. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  23. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  24. def readyAsync[T](result: commons.Try[T]): Async[T]
  25. def safeAsync[T](async: ⇒ Async[T]): Async[T]
  26. def safeHandle(handleRequest: HandleRequest): HandleRequest

    Ensures that all possible exceptions thrown by a request handler are not propagated but converted into an instance of Async that notifies its callbacks about the failure.

  27. def successfulAsync[T](value: T): Async[T]
  28. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  29. def toString(): String
    Definition Classes
    AnyRef → Any
  30. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  31. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  32. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from RawRpcCompanion[RawRest]

Inherited from RpcImplicitsProvider

Inherited from AnyRef

Inherited from Any

Ungrouped