Struct spectrusty::memory::SinglePageMemory

pub struct SinglePageMemory<const MEM_SIZE: usize, const RAM_BOT: u16> { /* private fields */ }

Trait Implementations

impl<const MEM_SIZE: usize, const RAM_BOT: u16> Clone for SinglePageMemory<MEM_SIZE, RAM_BOT>

fn clone(&self) -> SinglePageMemory<MEM_SIZE, RAM_BOT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const MEM_SIZE: usize, const RAM_BOT: u16> Default for SinglePageMemory<MEM_SIZE, RAM_BOT>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const MEM_SIZE: usize, const RAM_BOT: u16> Deserialize<'de> for SinglePageMemory<MEM_SIZE, RAM_BOT>

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 RAM_BOT: u16> Serialize for SinglePageMemory<MEM_SIZE, RAM_BOT>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const MEM_SIZE: usize, const RAM_BOT: u16> ZxMemory for SinglePageMemory<MEM_SIZE, RAM_BOT>

const ROM_SIZE: usize = 16_384usize

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

const RAMTOP: u16 = _

The last available memory address.

const PAGES_MAX: u8 = 1u8

A maximum value allowed for a page argument.

const SCR_BANKS_MAX: usize = 1usize

A maximum value allowed for a screen_bank argument

const ROM_BANKS_MAX: usize = 0usize

A maximum value allowed for a rom_bank argument

const RAM_BANKS_MAX: usize = 0usize

A maximum value allowed for a ram_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 page_index_at(&self, address: u16) -> Result<MemPageOffset>

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

const PAGE_SIZE: usize = 16_384usize

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

fn map_exrom(
    &mut self,
    _exrom_bank: Rc<[u8]>,
    _page: u8
) -> Result<(), ZxMemoryError>

Maps EX-ROM bank at the specified page.

fn unmap_exrom(&mut self, _exrom_bank: &Rc<[u8]>)

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: &Rc<[u8]>) -> bool

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

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.