Struct vessels::replicate::Shared

pub struct Shared<T: Trait<T> + Reflected + ?Sized>(_);

Methods

impl<T: Trait<T> + Reflected + ?Sized> Shared<T>

pub fn new(item: Box<T>) -> Self

Trait Implementations

impl<T: Trait<T> + Reflected + ?Sized> Trait<T> for Shared<T>

fn call(
    &self,
    index: MethodIndex,
    args: Vec<Box<dyn Any + Send + Sync>>
) -> Result<Box<dyn Any + Send + Sync>, CallError>

fn call_mut(
    &mut self,
    index: MethodIndex,
    args: Vec<Box<dyn Any + Send + Sync>>
) -> Result<Box<dyn Any + Send + Sync>, CallError>

fn call_move(
    self: Box<Self>,
    index: MethodIndex,
    args: Vec<Box<dyn Any + Send + Sync>>
) -> Result<Box<dyn Any + Send + Sync>, CallError>

fn by_name(&self, name: &str) -> Result<MethodIndex, NameError>

fn count(&self) -> MethodIndex

fn name_of(&self, index: MethodIndex) -> Result<String, OutOfRangeError>

fn this(&self) -> TypeId

fn name(&self) -> String

fn types(&self, index: MethodIndex) -> Result<MethodTypes, OutOfRangeError>

fn supertraits(&self) -> Vec<TypeId>

Returns all supertraits in the form TypeId::of<dyn SomeTrait> for each supertrait SomeTrait.

fn upcast_erased(
    self: Box<Self>,
    ty: TypeId
) -> Result<Box<dyn Erased>, CastError>

For a TypeId that is TypeId::of<dyn SomeTrait> returns the erasure of a concrete type Box<dyn SomeTrait> which can then be downcasted into.

fn erase(self: Box<Self>) -> Box<dyn Erased>

impl<T: Trait<T> + Reflected + ?Sized> Share for Shared<T>

fn share(&self) -> Self

impl<T: Reflected + Trait<T> + ?Sized> Kind for Shared<T> where
    Box<T>: Kind, 

type ConstructItem = ForkHandle

The item transmitted over the network to the construction task from deconstruction.

type ConstructError = WrappedError<<Box<T> as Kind>::ConstructError>

The failure condition of constructing a concrete type from communicated data.

type ConstructFuture = Future<ConstructResult<Self>>

The concrete future type returned by the construction process.

type DeconstructItem = ()

The item transmitted over the network from the construction task to deconstruction.

type DeconstructError = WrappedError<<Box<T> as Kind>::DeconstructError>

The failure condition of constructing a concrete type from communicated data.

type DeconstructFuture = Future<DeconstructResult<Self>>

The concrete future type returned by the deconstruction process. This is used to only to communicate failure of deconstruction and does not return a value.

fn deconstruct<C: Channel<Self::DeconstructItem, Self::ConstructItem>>(
    self,
    channel: C
) -> Self::DeconstructFuture

Moves out of the Kind and deconstructs on to the provided channel. As with construct, this method should return immediately.

fn construct<C: Channel<Self::ConstructItem, Self::DeconstructItem>>(
    channel: C
) -> Self::ConstructFuture

Constructs the Kind from the provided channel. This method should return immediately and, if necessary, move channel into some shim structure, async block, or other owned state specified by ConstructFuture.

const USE_KIND_MACRO_TO_GENERATE_THIS_FIELD: [u8; 32]