Struct MemPageableRomRamExRom 

pub struct MemPageableRomRamExRom<const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> { /* private fields */ }

Trait Implementations

impl<const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> Clone for MemPageableRomRamExRom<MEM_SIZE, PAGE_SIZE, NUM_PAGES>

where Self: MemoryConfig,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> Default for MemPageableRomRamExRom<MEM_SIZE, PAGE_SIZE, NUM_PAGES>

where Self: MemoryConfig,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> Deserialize<'de> for MemPageableRomRamExRom<MEM_SIZE, PAGE_SIZE, NUM_PAGES>

where Self: MemoryConfig,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> Serialize for MemPageableRomRamExRom<MEM_SIZE, PAGE_SIZE, NUM_PAGES>

where Self: MemoryConfig,

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const MEM_SIZE: usize, const PAGE_SIZE: usize, const NUM_PAGES: usize> ZxMemory for MemPageableRomRamExRom<MEM_SIZE, PAGE_SIZE, NUM_PAGES>

where Self: MemoryConfig,

const PAGE_SIZE: usize = PAGE_SIZE

This is just a hint. Actual page sizes may vary.

const ROM_SIZE: usize

The size of the whole ROM, not just one bank.

const RAMTOP: u16

The last available memory address.

const PAGES_MAX: u8 = Self::PAGES_MASK

A maximum value allowed for a page argument.

const SCR_BANKS_MAX: usize

A maximum value allowed for a screen_bank argument

const RAM_BANKS_MAX: usize

A maximum value allowed for a ram_bank argument

const ROM_BANKS_MAX: usize

A maximum value allowed for a rom_bank argument

fn reset(&mut self)

Resets memory banks.

fn read(&self, addr: u16) -> u8

If addr is above RAMTOP the function should return std::u8::MAX.

fn read16(&self, addr: u16) -> u16

If addr is above RAMTOP the function should return std::u16::MAX.

fn write(&mut self, addr: u16, val: u8)

If addr is above RAMTOP the function should do nothing.

fn write16(&mut self, addr: u16, val: u16)

If addr is above RAMTOP the function should do nothing.

fn read_screen(&self, screen_bank: usize, addr: u16) -> u8

Reads a byte from screen memory at the given addr.

fn mem_ref(&self) -> &[u8]

Provides a continuous view into the whole memory (all banks: ROM + RAM).

fn mem_mut(&mut self) -> &mut [u8]

Provides a continuous view into the whole memory (all banks: ROM + RAM).

fn screen_ref(&self, screen_bank: usize) -> Result<&ScreenArray>

Returns a reference to the screen memory.

fn screen_mut(&mut self, screen_bank: usize) -> Result<&mut ScreenArray>

Returns a mutable reference to the screen memory.

fn page_kind(&self, page: u8) -> Result<MemoryKind>

Returns an enum describing what kind of memory is currently paged at the specified page.

fn page_bank(&self, page: u8) -> Result<(MemoryKind, usize)>

Returns a tuple of an enum describing what kind of memory and which bank of that memory is currently paged at the specified page.

fn page_ref(&self, page: u8) -> Result<&[u8]>

page should be less or equal to PAGES_MAX.

fn page_mut(&mut self, page: u8) -> Result<&mut [u8]>

page should be less or equal to PAGES_MAX.

fn rom_bank_ref(&self, rom_bank: usize) -> Result<&[u8]>

rom_bank should be less or equal to ROM_BANKS_MAX.

fn rom_bank_mut(&mut self, rom_bank: usize) -> Result<&mut [u8]>

rom_bank should be less or equal to ROM_BANKS_MAX.

fn ram_bank_ref(&self, ram_bank: usize) -> Result<&[u8]>

ram_bank should be less or equal to RAM_BANKS_MAX.

fn ram_bank_mut(&mut self, ram_bank: usize) -> Result<&mut [u8]>

ram_bank should be less or equal to RAM_BANKS_MAX.

fn map_rom_bank(&mut self, rom_bank: usize, page: u8) -> Result<()>

rom_bank should be less or equal to ROM_BANKS_MAX and page should be less or equal to PAGES_MAX.

fn map_ram_bank(&mut self, ram_bank: usize, page: u8) -> Result<()>

ram_bank should be less or equal to RAM_BANKS_MAX and page should be less or equal to PAGES_MAX.

fn map_exrom(&mut self, exrom_bank: ExRom, page: u8) -> Result<()>

Maps EX-ROM bank at the specified page.

fn unmap_exrom(&mut self, exrom_bank: &ExRom)

Unmaps an external ROM if the currently mapped EX-ROM bank is the same as in the argument. Otherwise does nothing.

fn is_exrom_at(&self, page: u8) -> bool

Returns true if an EX-ROM bank is currently being mapped at the specified memory page.

fn has_mapped_exrom(&self, exrom_bank: &ExRom) -> bool

Returns true if a specified EX-ROM bank is currently being mapped.

fn page_index_at(&self, address: u16) -> Result<MemPageOffset, ZxMemoryError>

Returns Ok(MemPageOffset) if address is equal to or less than ZxMemory::RAMTOP.

fn rom_ref(&self) -> &[u8]

Provides a continuous view into the ROM memory (all banks).

fn rom_mut(&mut self) -> &mut [u8]

Provides a continuous mutable view into the ROM memory (all banks).

fn ram_ref(&self) -> &[u8]

Provides a continuous view into RAM (all banks).

fn ram_mut(&mut self) -> &mut [u8]

Provides a continuous mutable view into RAM (all banks).

fn load_into_rom<R>(&mut self, rd: R) -> Result<(), ZxMemoryError>

where R: Read,

The data read depends on how big ROM is ZxMemory::ROM_SIZE. Results in an error when the ROM data size is less than the ROM_SIZE.

fn load_into_rom_bank<R>( &mut self, rom_bank: usize, rd: R, ) -> Result<(), ZxMemoryError>

where R: Read,

Results in an error when the ROM data size is less than the ROM bank’s size.

fn iter_pages<A>( &self, address_range: A, ) -> Result<MemPageRefIter<'_, Self>, ZxMemoryError>

where A: RangeBounds<u16>,

Returns an iterator of memory page slice references intersecting with a given address range.

fn for_each_page_mut<A, F>( &mut self, address_range: A, f: F, ) -> Result<(), ZxMemoryError>

where A: RangeBounds<u16>, F: for<'a> FnMut(PageMutSlice<'a>) -> Result<(), ZxMemoryError>,

Iterates over mutable memory page slices PageMutSlice intersecting with a given address range passing the slices to the closure f.

fn load_into_mem<A, R>( &mut self, address_range: A, rd: R, ) -> Result<(), ZxMemoryError>

where A: RangeBounds<u16>, R: Read,

Reads data into a paged-in memory area at the given address range.

fn fill_mem<R, F>( &mut self, address_range: R, f: F, ) -> Result<(), ZxMemoryError>

where R: RangeBounds<u16>, F: FnMut() -> u8,

Fills currently paged-in pages with the data produced by the closure F.