Struct moa_z80::Z80Port

pub struct Z80Port<MemBus, IOBus, Instant>
where
    MemBus: BusAccess<Z80Address, Instant = Instant>,
    IOBus: BusAccess<Z80IOAddress, Instant = Instant>,
{
    mem_bus: MemBus,
    io_bus: IOBus,
    instant: PhantomData<Instant>,
}

Fields

mem_bus: MemBus

io_bus: IOBus

instant: PhantomData<Instant>

Implementations

impl<MemBus, IOBus, Instant> Z80Port<MemBus, IOBus, Instant>

where MemBus: BusAccess<Z80Address, Instant = Instant>, IOBus: BusAccess<Z80IOAddress, Instant = Instant>,

pub fn new(mem_bus: MemBus, io_bus: IOBus) -> Self

Trait Implementations

impl<MemBus, IOBus, Instant> BusAccess<Z80AddressSpace> for Z80Port<MemBus, IOBus, Instant>

where Instant: EmuInstant, MemBus: BusAccess<Z80Address, Instant = Instant>, IOBus: BusAccess<Z80IOAddress, Instant = Instant>,

type Instant = Instant

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

type Error = Z80BusError<<MemBus as BusAccess<u16>>::Error, <IOBus as BusAccess<u16>>::Error>

The type of an error returned by this bus

fn read( &mut self, now: Self::Instant, addr: Z80AddressSpace, 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: Z80AddressSpace, 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