Struct spectrusty::memory::MemPageableRomRamExRom

pub struct MemPageableRomRamExRom<M: MemoryBlock> { /* fields omitted */ }

Trait Implementations

impl<M: MemoryBlock> Clone for MemPageableRomRamExRom<M> where
    M: Clone,
    M::Pages: Copy,
    &'a mut M::Pages: IntoIterator<Item = &'a mut NonNull<<M::Pages as MemoryPages>::PagePtrType>>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: MemoryBlock> Default for MemPageableRomRamExRom<M>

fn default() -> Self

Returns the "default value" for a type.

impl<'de, M: MemoryBlock> Deserialize<'de> for MemPageableRomRamExRom<M> where
    Box<M>: MemDeExt,
    &'a mut M::Pages: IntoIterator<Item = &'a mut NonNull<<M::Pages as MemoryPages>::PagePtrType>>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<M: MemoryBlock> Serialize for MemPageableRomRamExRom<M> where
    M::Pages: Copy,
    &'a Box<M>: MemSerExt,
    &'a M::Pages: IntoIterator<Item = &'a NonNull<<M::Pages as MemoryPages>::PagePtrType>>, 

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

Serialize this value into the given Serde serializer.

impl<M> ZxMemory for MemPageableRomRamExRom<M> where
    M: MemoryBlock, 

const PAGE_SIZE: usize

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

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
    F: FnMut() -> u8,
    R: RangeBounds<u16>, 

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