Struct CuSimBridge 

pub struct CuSimBridge<Tx, Rx>
where
    Tx: BridgeChannelSet + 'static,
    Rx: BridgeChannelSet + 'static,
{ /* private fields */ }

Placeholder bridge used in simulation when a bridge is configured with run_in_sim: false.

This bridge is parameterized directly by the Tx/Rx channel sets generated from configuration, so the original bridge type does not need to compile in simulation mode.

Trait Implementations

impl<Tx, Rx> CuBridge for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static,

type Tx = Tx

Outgoing channels (Copper -> external world).

type Rx = Rx

Incoming channels (external world -> Copper).

type Resources<'r> = ()

Resources required by the bridge.

fn new( _config: Option<&ComponentConfig>, _tx_channels: &[BridgeChannelConfig<<<CuSimBridge<Tx, Rx> as CuBridge>::Tx as BridgeChannelSet>::Id>], _rx_channels: &[BridgeChannelConfig<<<CuSimBridge<Tx, Rx> as CuBridge>::Rx as BridgeChannelSet>::Id>], _resources: <CuSimBridge<Tx, Rx> as CuBridge>::Resources<'_>, ) -> Result<CuSimBridge<Tx, Rx>, CuError>

where CuSimBridge<Tx, Rx>: Sized,

Constructs a new bridge.

fn send<'a, Payload>( &mut self, _ctx: &CuContext, _channel: &'static BridgeChannel<<<CuSimBridge<Tx, Rx> as CuBridge>::Tx as BridgeChannelSet>::Id, Payload>, _msg: &CuStampedData<Payload, CuMsgMetadata>, ) -> Result<(), CuError>

where Payload: CuMsgPayload + 'a,

Sends a message on the selected outbound channel.

fn receive<'a, Payload>( &mut self, _ctx: &CuContext, _channel: &'static BridgeChannel<<<CuSimBridge<Tx, Rx> as CuBridge>::Rx as BridgeChannelSet>::Id, Payload>, _msg: &mut CuStampedData<Payload, CuMsgMetadata>, ) -> Result<(), CuError>

where Payload: CuMsgPayload + 'a,

Receives a message from the selected inbound channel.

fn start(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Called before the first send/receive cycle.

fn preprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Gives the bridge a chance to prepare buffers before I/O.

fn postprocess(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Called once the send/receive pair completed.

fn stop(&mut self, _ctx: &CuContext) -> Result<(), CuError>

Notifies the bridge that no more I/O will happen until a subsequent [start].

impl<Tx, Rx> Freezable for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static,

fn freeze<E>(&self, encoder: &mut E) -> Result<(), EncodeError>

where E: Encoder,

This method is called by the framework when it wants to save the task state. The default implementation is to encode nothing (stateless). If you have a state, you need to implement this method.

fn thaw<D>(&mut self, _decoder: &mut D) -> Result<(), DecodeError>

where D: Decoder,

This method is called by the framework when it wants to restore the task to a specific state. Here it is similar to Decode but the framework will give you a new instance of the task (the new method will be called)

impl<Tx, Rx> GetTypeRegistration for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, CuSimBridge<Tx, Rx>: Any + Send + Sync,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<Tx, Rx> PartialReflect for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, CuSimBridge<Tx, Rx>: Any + Send + Sync,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<CuSimBridge<Tx, Rx>>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<CuSimBridge<Tx, Rx>>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect( self: Box<CuSimBridge<Tx, Rx>>, ) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<Tx, Rx> Reflect for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, CuSimBridge<Tx, Rx>: Any + Send + Sync,

fn into_any(self: Box<CuSimBridge<Tx, Rx>>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<CuSimBridge<Tx, Rx>>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl<Tx, Rx> Struct for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, CuSimBridge<Tx, Rx>: Any + Send + Sync,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl<Tx, Rx> TypePath for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl<Tx, Rx> Typed for CuSimBridge<Tx, Rx>

where Tx: BridgeChannelSet + 'static, Rx: BridgeChannelSet + 'static, CuSimBridge<Tx, Rx>: Any + Send + Sync,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.