Struct spectrusty_core::bus::DynamicBus

pub struct DynamicBus<D: BusDevice> { /* private fields */ }

A pseudo bus device that allows for adding and removing devices of different types at run time.

The penalty is that the access to the devices must be done using a virtual call dispatch. Also the device of this type can’t be cloned (nor the ControlUnit with this device attached).

DynamicBus<D> implements BusDevice itself, so obviously it’s possible to declare a statically dispatched downstream BusDevice as its parameter D.

Currently only types implementing BusDevice that are directly terminated with NullDevice can be attached as dynamically dispatched objects.

Implementations

impl<D> DynamicBus<D>where
    D: BusDevice,

pub fn len(&self) -> usize

Returns the number of attached devices.

Examples found in repository

src/bus/dynbus.rs (line 92)

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

pub fn is_empty(&self) -> bool

Returns true if there are no devices in the dynamic chain. Otherwise returns false.

pub fn append_device<B>(&mut self, device: B) -> usizewhere
    B: Into<BoxNamedDynDevice<D::Timestamp>>,

Appends an instance of a device at the end of the daisy-chain. Returns its index position in the dynamic device chain.

pub fn remove_device(&mut self) -> Option<BoxNamedDynDevice<D::Timestamp>>

Removes the last device from the dynamic daisy-chain and returns an instance of the boxed dynamic object.

Examples found in repository

src/bus/dynbus.rs (line 153)

    pub fn remove_as_device<B>(&mut self) -> Option<Box<B>>
        where B: NamedBusDevice<D::Timestamp> + 'static
    {
        self.remove_device().map(|boxdev|
            boxdev.downcast::<B>().expect("wrong dynamic device type removed")
        )
    }

pub fn swap_remove_device(
    &mut self,
    index: usize
) -> BoxNamedDynDevice<D::Timestamp>

Replaces a device at the given index position and returns it.

The removed device is replaced by the last device of the chain.

Panics

Panics if a device doesn’t exist at index.

Examples found in repository

src/bus/dynbus.rs (line 166)

    pub fn swap_remove_as_device<B>(&mut self, index: usize) -> Box<B>
        where B: NamedBusDevice<D::Timestamp> + 'static
    {
        self.swap_remove_device(index).downcast::<B>().expect("wrong dynamic device type removed")
    }

pub fn replace_device<B>(
    &mut self,
    index: usize,
    device: B
) -> BoxNamedDynDevice<D::Timestamp>where
    B: Into<BoxNamedDynDevice<D::Timestamp>>,

Replaces a device at the given index position. Returns the previous device occupying the replaced spot.

Panics

Panics if a device doesn’t exist at index.

pub fn clear(&mut self)

Removes all dynamic devices from the dynamic daisy-chain.

pub fn get_device_ref(
    &self,
    index: usize
) -> Option<&NamedDynDevice<D::Timestamp>>

Returns a reference to a dynamic device at index position in the dynamic daisy-chain.

pub fn get_device_mut(
    &mut self,
    index: usize
) -> Option<&mut NamedDynDevice<D::Timestamp>>

Returns a mutable reference to a dynamic device at index position in the dynamic daisy-chain.

impl<D> DynamicBus<D>where
    D: BusDevice,
    D::Timestamp: 'static,

pub fn remove_as_device<B>(&mut self) -> Option<Box<B>>where
    B: NamedBusDevice<D::Timestamp> + 'static,

Removes the last device from the dynamic daisy-chain.

Panics

Panics if a device is not of a type given as parameter B.

pub fn swap_remove_as_device<B>(&mut self, index: usize) -> Box<B>where
    B: NamedBusDevice<D::Timestamp> + 'static,

Replaces a device at the given index and returns it.

The removed device is replaced by the last device of the chain.

Panics

Panics if a device doesn’t exist at index or if a device is not of a type given as parameter B.

pub fn as_device_ref<B>(&self, index: usize) -> &Bwhere
    B: NamedBusDevice<D::Timestamp> + 'static,

Returns a reference to a device of a type B at index in the dynamic daisy-chain.

Panics

Panics if a device doesn’t exist at index or if a device is not of a type given as parameter B.

pub fn as_device_mut<B>(&mut self, index: usize) -> &mut Bwhere
    B: NamedBusDevice<D::Timestamp> + 'static,

Returns a mutable reference to a device of a type B at index in the dynamic daisy-chain.

Panics

Panics if a device doesn’t exist at index or if a device is not of a type given as parameter B.

pub fn is_device<B>(&self, index: usize) -> boolwhere
    B: NamedBusDevice<D::Timestamp> + 'static,

Returns true if a device at index is of a type given as parameter B.

pub fn position_device<B>(&self) -> Option<usize>where
    B: NamedBusDevice<D::Timestamp> + 'static,

Searches for a first device of a type given as parameter B, returning its index.

pub fn find_device_ref<B>(&self) -> Option<&B>where
    B: NamedBusDevice<D::Timestamp> + 'static,

Searches for a first device of a type given as parameter B, returning a reference to a device.

pub fn find_device_mut<B>(&mut self) -> Option<&mut B>where
    B: NamedBusDevice<D::Timestamp> + 'static,

Searches for a first device of a type given as parameter B, returning a mutable reference to a device.

Trait Implementations

impl<D: BusDevice> AsMut<[Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>]> for DynamicBus<D>

fn as_mut(&mut self) -> &mut [BoxNamedDynDevice<D::Timestamp>]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<D: BusDevice> AsRef<[Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>]> for DynamicBus<D>

fn as_ref(&self) -> &[BoxNamedDynDevice<D::Timestamp>]

Converts this type into a shared reference of the (usually inferred) input type.

impl<D> BusDevice for DynamicBus<D>where
    D: BusDevice,
    D::Timestamp: Debug + Copy,

type Timestamp = <D as BusDevice>::Timestamp

A type used as a time-stamp.

type NextDevice = D

A type of the next device in a daisy chain.

fn next_device_mut(&mut self) -> &mut Self::NextDevice

Returns a mutable reference to the next device.

fn next_device_ref(&self) -> &Self::NextDevice

Returns a reference to the next device.

fn into_next_device(self) -> Self::NextDevice

Destructs self and returns the instance of the next bus device.

fn reset(&mut self, timestamp: Self::Timestamp)

Resets the device and all devices in this chain.

fn update_timestamp(&mut self, timestamp: Self::Timestamp)

This method should be called near the end of each frame.

fn next_frame(&mut self, timestamp: Self::Timestamp)

This method should be called just before the T-state counter of the control unit is wrapped when preparing for the next frame.

fn read_io(
    &mut self,
    port: u16,
    timestamp: Self::Timestamp
) -> Option<(u8, Option<NonZeroU16>)>

This method is called by the control unit during an I/O read cycle.

fn write_io(
    &mut self,
    port: u16,
    data: u8,
    timestamp: Self::Timestamp
) -> Option<u16>

This method is called by the control unit during an I/O write cycle.

fn type_id(&self) -> TypeIdwhere
    Self: 'static,

Gets the TypeId of self.

impl<D: Debug + BusDevice> Debug for DynamicBus<D>where
    D::Timestamp: Debug,

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

Formats the value using the given formatter.

impl<D: Default + BusDevice> Default for DynamicBus<D>where
    D::Timestamp: Default,

fn default() -> DynamicBus<D>

Returns the “default value” for a type.

impl<'de, D> Deserialize<'de> for DynamicBus<D>where
    D: Deserialize<'de> + Default + BusDevice,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S, D: BusDevice> From<DynamicBus<D>> for DynamicSerdeBus<S, D>

fn from(dynamic_bus: DynamicBus<D>) -> Self

Converts to this type from the input type.

impl<S, D: BusDevice> From<DynamicSerdeBus<S, D>> for DynamicBus<D>

fn from(dynamic_bus: DynamicSerdeBus<S, D>) -> Self

Converts to this type from the input type.

impl<D: BusDevice> Index<usize> for DynamicBus<D>

type Output = dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<D: BusDevice> IndexMut<usize> for DynamicBus<D>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, D: BusDevice> IntoIterator for &'a DynamicBus<D>

type Item = &'a Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, D: BusDevice> IntoIterator for &'a mut DynamicBus<D>

type Item = &'a mut Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D: BusDevice> IntoIterator for DynamicBus<D>

type Item = Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>

The type of the elements being iterated over.

type IntoIter = IntoIter<Box<dyn NamedBusDevice<<D as BusDevice>::Timestamp, Timestamp = <D as BusDevice>::Timestamp, NextDevice = NullDevice<<D as BusDevice>::Timestamp>> + 'static, Global>, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<D> Serialize for DynamicBus<D>where
    D: Serialize + BusDevice,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.