Struct emulator_hal::AutoBusAdapter

pub struct AutoBusAdapter<AddressIn, AddressOut, Bus, ErrorOut>
where
    AddressOut: FromAddress<AddressIn> + Copy,
    Bus: BusAccess<AddressOut>,
    ErrorOut: From<Bus::Error>,
{
    pub inner: Bus,
    /* private fields */
}

An adapter that uses the FromAddress trait to translate an address before accessing a wrapped bus object

This object implements the BusAccess trait, and takes address of type AddressIn, applies FromAddress<AddressIn> trait to produce an address of type AddressOut, and then calls the equivalent trait method with that produced address, return the result

Fields

inner: Bus

The underlying object implementing BusAccess that this object adapts

Implementations

impl<AddressIn, AddressOut, Bus, ErrorOut> AutoBusAdapter<AddressIn, AddressOut, Bus, ErrorOut>

where AddressOut: FromAddress<AddressIn> + Copy, Bus: BusAccess<AddressOut>, ErrorOut: From<Bus::Error>,

pub fn new(inner: Bus) -> Self

Construct a new instance of an adapter for the given bus object

Trait Implementations

impl<AddressIn, AddressOut, Bus, ErrorOut> BusAccess<AddressIn> for AutoBusAdapter<AddressIn, AddressOut, Bus, ErrorOut>

where AddressIn: Copy, AddressOut: FromAddress<AddressIn> + Copy, Bus: BusAccess<AddressOut>, ErrorOut: ErrorType + From<Bus::Error>,

type Instant = <Bus as BusAccess<AddressOut>>::Instant

The type of an instant in simulated time that the bus access is meant to occur at

type Error = ErrorOut

The type of an error returned by this bus

fn read( &mut self, now: Self::Instant, addr: AddressIn, data: &mut [u8] ) -> Result<usize, Self::Error>

Read an arbitrary length of bytes from this device, at time now

fn write( &mut self, now: Self::Instant, addr: AddressIn, data: &[u8] ) -> Result<usize, Self::Error>

Write an arbitrary length of bytes into this device, at time now

fn read_u8( &mut self, now: Self::Instant, addr: Address ) -> Result<u8, Self::Error>

Read a single u8 value at the given address

fn read_beu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in big endian byte order at the given address

fn read_leu16( &mut self, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in little endian byte order at the given address

fn read_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u16, Self::Error>

Read a single u16 value in the given byte order at the given address

fn read_beu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in big endian byte order at the given address

fn read_leu32( &mut self, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in little endian byte order at the given address

fn read_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u32, Self::Error>

Read a single u32 value in the given byte order at the given address

fn read_beu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in big endian byte order at the given address

fn read_leu64( &mut self, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in little endian byte order at the given address

fn read_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address ) -> Result<u64, Self::Error>

Read a single u64 value in the given byte order at the given address

fn write_u8( &mut self, now: Self::Instant, addr: Address, value: u8 ) -> Result<(), Self::Error>

Write a single u8 value to the given address

fn write_beu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in big endian byte order to the given address

fn write_leu16( &mut self, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in little endian byte order to the given address

fn write_u16( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u16 ) -> Result<(), Self::Error>

Write the given u16 value in the given byte order to the given address

fn write_beu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in big endian byte order to the given address

fn write_leu32( &mut self, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in little endian byte order to the given address

fn write_u32( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u32 ) -> Result<(), Self::Error>

Write the given u32 value in the given byte order to the given address

fn write_beu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in big endian byte order to the given address

fn write_leu64( &mut self, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in little endian byte order to the given address

fn write_u64( &mut self, order: ByteOrder, now: Self::Instant, addr: Address, value: u64 ) -> Result<(), Self::Error>

Write the given u64 value in the given byte order to the given address