Struct emulator_hal::BusAdapter

pub struct BusAdapter<AddressIn, AddressOut, Bus, ErrorOut>
where
    AddressIn: Copy,
    AddressOut: Copy,
    Bus: BusAccess<AddressOut>,
    ErrorOut: From<Bus::Error>,
{
    pub inner: Bus,
    pub translate: fn(_: AddressIn) -> AddressOut,
    /* private fields */
}

An adapter that applies an address translation before accessing a wrapped bus object

This object implements the BusAccess trait, and takes address of type AddressIn, applies the provided address translation function 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

translate: fn(_: AddressIn) -> AddressOut

The translation function applied

Implementations

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

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

pub fn new(inner: Bus, translate: fn(_: AddressIn) -> AddressOut) -> Self

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

Trait Implementations

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

where AddressIn: Copy, AddressOut: 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