Trait moa_core::Addressable

pub trait Addressable {
    // Required methods
    fn size(&self) -> usize;
    fn read(
        &mut self,
        clock: Instant,
        addr: Address,
        data: &mut [u8]
    ) -> Result<(), Error>;
    fn write(
        &mut self,
        clock: Instant,
        addr: Address,
        data: &[u8]
    ) -> Result<(), Error>;

    // Provided methods
    fn read_u8(&mut self, clock: Instant, addr: Address) -> Result<u8, Error> { ... }
    fn read_beu16(
        &mut self,
        clock: Instant,
        addr: Address
    ) -> Result<u16, Error> { ... }
    fn read_leu16(
        &mut self,
        clock: Instant,
        addr: Address
    ) -> Result<u16, Error> { ... }
    fn read_beu32(
        &mut self,
        clock: Instant,
        addr: Address
    ) -> Result<u32, Error> { ... }
    fn read_leu32(
        &mut self,
        clock: Instant,
        addr: Address
    ) -> Result<u32, Error> { ... }
    fn write_u8(
        &mut self,
        clock: Instant,
        addr: Address,
        value: u8
    ) -> Result<(), Error> { ... }
    fn write_beu16(
        &mut self,
        clock: Instant,
        addr: Address,
        value: u16
    ) -> Result<(), Error> { ... }
    fn write_leu16(
        &mut self,
        clock: Instant,
        addr: Address,
        value: u16
    ) -> Result<(), Error> { ... }
    fn write_beu32(
        &mut self,
        clock: Instant,
        addr: Address,
        value: u32
    ) -> Result<(), Error> { ... }
    fn write_leu32(
        &mut self,
        clock: Instant,
        addr: Address,
        value: u32
    ) -> Result<(), Error> { ... }
}

A device that can be addressed to read data from or write data to the device.

Required Methods

fn size(&self) -> usize

fn read( &mut self, clock: Instant, addr: Address, data: &mut [u8] ) -> Result<(), Error>

fn write( &mut self, clock: Instant, addr: Address, data: &[u8] ) -> Result<(), Error>

Provided Methods

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

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

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

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

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

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

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

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

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

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

Trait Implementations

impl BusAccess<u64> for &mut dyn Addressable

type Instant = Instant

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

type Error = Error

The type of an error returned by this bus

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

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

fn write( &mut self, now: Instant, addr: Address, 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

Implementors

impl Addressable for AddressRepeater

impl Addressable for AddressTranslator

impl Addressable for Bus

impl Addressable for BusPort

impl Addressable for MemoryBlock