rpc

Type Members

1. trait AsRaw[Raw, Real] extends AnyRef

   

   Annotations

   @implicitNotFound( ... )

2. trait AsRawReal[Raw, Real] extends AsReal[Raw, Real] with AsRaw[Raw, Real]

   

   Annotations

   @implicitNotFound( ... )

3. trait AsReal[Raw, Real] extends AnyRef

   

   Annotations

   @implicitNotFound( ... )

4. final case class Fallback[+T](value: T) extends AnyVal with Product with Serializable

   

   Wrap your implicit instance of AsReal, AsRaw, AsRawReal or RPC metadata (with companion that extends RpcMetadataCompanion into Fallback in order to lower its implicit priority.

   Wrap your implicit instance of AsReal, AsRaw, AsRawReal or RPC metadata (with companion that extends RpcMetadataCompanion into Fallback in order to lower its implicit priority. Useful when some implicit must be imported but we don't want it to get higher priority that imports normally have over implicit scope (e.g. implicits from companion objects).

   NOTE: Fallback does not work for *all* typeclasses, only RPC-related ones (AsReal, AsRaw, etc). You can make it work with your own typeclass, but you must define appropriate forwarder in its companion, e.g.

   trait FallbackAwareTC[T] { ... }
   object FallbackAwareTC {
     implicit def fromFallback[T](implicit f: Fallback[FallbackAwareTC[T]]): FallbackAwareTC[T] = f.value
   }

5. trait FunctionRPCFramework extends RPCFramework

   

   Mix in this trait into your RPC framework to support remote functions, i.e.

   Mix in this trait into your RPC framework to support remote functions, i.e. methods which asynchronously return some result (Future[A] where A has a Reader and Writer).

6. trait GetterRPCFramework extends RPCFramework

   

   Mix in this trait into your RPC framework to support getters, i.e.

   Mix in this trait into your RPC framework to support getters, i.e. methods that return RPC subinterfaces

7. class InvalidRpcCall extends RuntimeException

   

8. class MissingOptionalRpc extends InvalidRpcCall

   

9. class MissingRpcArgument extends InvalidRpcCall

   

10. trait OneWayRPCFramework extends GetterRPCFramework with ProcedureRPCFramework

    

11. trait ProcedureRPCFramework extends RPCFramework

    

    Mix in this trait into your RPC framework to support remote procedures, i.e.

    Mix in this trait into your RPC framework to support remote procedures, i.e. fire-and-forget methods with Unit return type.

12. trait RPCFramework extends AnyRef

    

13. trait RawRpcCompanion[Raw] extends RpcImplicitsProvider

    

    Base trait for companion objects of raw RPC traits.

14. trait RpcImplicitsProvider extends AnyRef

    

15. trait RpcMacroInstances[Implicits, InstancesTrait[_], Real] extends AnyRef

    

    Intermediate factory that creates an InstancesTrait for given Real RPC trait, based on provided Implicits.

    Intermediate factory that creates an InstancesTrait for given Real RPC trait, based on provided Implicits. Normally, this factory is used as implicit constructor parameter of base classes for companion objects of RPC traits (e.g. DefaultRestApiCompanion). This all serves to reduce boilerplate associated with RPC trait companion declarations and makes RPC trait definitions as concise as possible. It also lets the programmer easily inject additional implicits into macro-materialization of RPC-related typeclasses (AsReal, AsRaw, metadata, etc.).

    An InstancesTrait is a trait that aggregates multiple RPC related typeclass instances for given Real RPC trait. There is no fixed interface for InstancesTrait, its members are inspected by materialize macro and implemented automatically. InstancesTrait must contain only parameterless abstract methods that return either AsRaw[Raw,Real], AsReal[Raw,Real], AsRawReal[Raw,Real] or some RPC metadata class for Real. The Raw type is arbitrary and may be different for every method. However, it must be a concrete raw RPC trait so that it's further understood by the macro engine. All methods of the InstancesTrait are macro-implemented using AsRaw/AsReal/AsRawReal/RpcMetadata.materializeForRpc macros.

    Example of InstancesTrait: ClientInstances

    The Implicits type is typically a trait with a collection of implicit definitions whose companion object implements that trait, e.g. DefaultRestImplicits. When the macro implements apply method of RpcMacroInstances contents of Implicits are imported into the body of apply and visible further by macros that materialize InstancesTrait.

    If RpcMacroInstances is accepted as implicit super constructor parameter of a companion object (which is the typical situation) then this reference should be passed as companion. This is in order to work around https://github.com/scala/bug/issues/7666

16. trait RpcMetadataCompanion[M[_]] extends MetadataCompanion[M] with RpcImplicitsProvider

    

17. trait StandardRPCFramework extends GetterRPCFramework with FunctionRPCFramework with ProcedureRPCFramework

    

18. class UnknownRpc extends InvalidRpcCall