Struct origen::core::dut::Dut

pub struct Dut {

    pub name: String,
    pub models: Vec<Model>,
    pub bits: Vec<Bit>,
    pub timesets: Vec<Timeset>,
    pub wavetables: Vec<Wavetable>,
    pub wave_groups: Vec<WaveGroup>,
    pub waves: Vec<Wave>,
    pub wave_events: Vec<Event>,
    pub pins: Vec<Pin>,
    pub pin_groups: Vec<PinGroup>,
    pub pin_headers: Vec<PinHeader>,
    pub id_mappings: Vec<IndexMap<String, usize>>,
    pub reg_descriptions: IndexMap<String, IndexMap<usize, String>>,
    // some fields omitted
}

The DUT stores all objects associated with a particular device. Each object type is organized into vectors, where a particular object’s position within the vector is considered its unique ID. A register then (for example) does not embed its bit objects but rather contains a list of bit IDs. This approach allows bits to be easily passed around by ID to enable the creation of bit collections that are small (a subset of a register’s bits) or very large (all bits in a memory map).

Fields

name: String

models: Vec<Model>

bits: Vec<Bit>

timesets: Vec<Timeset>

wavetables: Vec<Wavetable>

wave_groups: Vec<WaveGroup>

waves: Vec<Wave>

wave_events: Vec<Event>

pins: Vec<Pin>

pin_groups: Vec<PinGroup>

pin_headers: Vec<PinHeader>

id_mappings: Vec<IndexMap<String, usize>>

reg_descriptions: IndexMap<String, IndexMap<usize, String>>

Cache of descriptions parsed from reg definition files

Implementations

impl Dut

pub fn get_timeset(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&Timeset>

pub fn get_mut_timeset(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut Timeset>

pub fn _get_timeset(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&Timeset, Error>

pub fn _get_mut_timeset(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut Timeset, Error>

pub fn _get_cloned_timeset(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<Timeset, Error>

impl Dut

pub fn get_wavetable(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&Wavetable>

pub fn get_mut_wavetable(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut Wavetable>

pub fn _get_wavetable(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&Wavetable, Error>

pub fn _get_mut_wavetable(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut Wavetable, Error>

pub fn _get_cloned_wavetable(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<Wavetable, Error>

impl Dut

pub fn get_wave_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&WaveGroup>

pub fn get_mut_wave_group(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut WaveGroup>

pub fn _get_wave_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&WaveGroup, Error>

pub fn _get_mut_wave_group(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut WaveGroup, Error>

pub fn _get_cloned_wave_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<WaveGroup, Error>

impl Dut

pub fn get_wave(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&Wave>

pub fn get_mut_wave(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut Wave>

pub fn _get_wave(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&Wave, Error>

pub fn _get_mut_wave(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut Wave, Error>

pub fn _get_cloned_wave(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<Wave, Error>

impl Dut

pub fn get_event(
    &self,
    parent_field_id: usize,
    identifier: usize
) -> Option<&Event>

pub fn get_mut_event(
    &mut self,
    parent_field_id: usize,
    identifier: usize
) -> Option<&mut Event>

pub fn _get_event(
    &self,
    parent_field_id: usize,
    identifier: usize
) -> Result<&Event, Error>

pub fn _get_mut_event(
    &mut self,
    parent_field_id: usize,
    identifier: usize
) -> Result<&mut Event, Error>

pub fn _get_cloned_event(
    &self,
    parent_field_id: usize,
    identifier: usize
) -> Result<Event, Error>

impl Dut

pub fn get_pin(&self, parent_field_id: usize, identifier: &str) -> Option<&Pin>

pub fn get_mut_pin(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut Pin>

pub fn _get_pin(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&Pin, Error>

pub fn _get_mut_pin(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut Pin, Error>

pub fn _get_cloned_pin(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<Pin, Error>

impl Dut

pub fn get_pin_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&PinGroup>

pub fn get_mut_pin_group(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut PinGroup>

pub fn _get_pin_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&PinGroup, Error>

pub fn _get_mut_pin_group(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut PinGroup, Error>

pub fn _get_cloned_pin_group(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<PinGroup, Error>

impl Dut

pub fn get_pin_header(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&PinHeader>

pub fn get_mut_pin_header(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Option<&mut PinHeader>

pub fn _get_pin_header(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&PinHeader, Error>

pub fn _get_mut_pin_header(
    &mut self,
    parent_field_id: usize,
    identifier: &str
) -> Result<&mut PinHeader, Error>

pub fn _get_cloned_pin_header(
    &self,
    parent_field_id: usize,
    identifier: &str
) -> Result<PinHeader, Error>

impl Dut

pub fn new(name: &str) -> Dut

pub fn change(&mut self, name: &str) -> Result<()>

Change the DUT, this replaces the existing mode with a fresh one (i.e. deletes all current DUT metadata and state, and updates the name/ID field with the given value

pub fn mut_model(&mut self) -> &mut Model

Returns a mutable reference to the top-level model

pub fn model(&self) -> &Model

Returns an immutable reference to the top-level model

pub fn get_mut_model(&mut self, id: usize) -> Result<&mut Model>

Get a mutable reference to the model with the given ID

pub fn get_model(&self, id: usize) -> Result<&Model>

Get a read-only reference to the model with the given ID, use get_mut_model if you need to modify it

pub fn get_mut_memory_map(&mut self, id: usize) -> Result<&mut MemoryMap>

Get a mutable reference to the memory map with the given ID

pub fn get_memory_map(&self, id: usize) -> Result<&MemoryMap>

Get a read-only reference to the memory map with the given ID, use get_mut_memory_map if you need to modify it

pub fn get_mut_address_block(&mut self, id: usize) -> Result<&mut AddressBlock>

Get a mutable reference to the address block with the given ID

pub fn get_address_block(&self, id: usize) -> Result<&AddressBlock>

Get a read-only reference to the address block with the given ID, use get_mut_address_block if you need to modify it

pub fn get_mut_register_file(&mut self, id: usize) -> Result<&mut RegisterFile>

Get a mutable reference to the register file with the given ID

pub fn get_register_file(&self, id: usize) -> Result<&RegisterFile>

Get a read-only reference to the register file with the given ID, use get_mut_register_file if you need to modify it

pub fn get_mut_register(&mut self, id: usize) -> Result<&mut Register>

Get a mutable reference to the register with the given ID

pub fn get_register(&self, id: usize) -> Result<&Register>

Get a read-only reference to the register with the given ID, use get_mut_register if you need to modify it

pub fn get_mut_bit(&mut self, id: usize) -> Result<&mut Bit>

Get a mutable reference to the bit with the given ID

pub fn get_bit(&self, id: usize) -> Result<&Bit>

Get a read-only reference to the bit with the given ID, use get_mut_bit if you need to modify it

pub fn create_model(
    &mut self,
    parent_id: Option<usize>,
    name: &str,
    offset: Option<u128>
) -> Result<usize>

Create a new model adding it to the existing parent model with the given ID. The ID of the newly created model is returned to the caller who should save it if they want to access this model directly again (will also be accessible by name via the parent model).

pub fn create_memory_map(
    &mut self,
    model_id: usize,
    name: &str,
    address_unit_bits: Option<u32>
) -> Result<usize>

pub fn create_address_block(
    &mut self,
    memory_map_id: usize,
    name: &str,
    offset: Option<u128>,
    range: Option<u64>,
    width: Option<u64>,
    access: Option<AccessType>
) -> Result<usize>

pub fn create_reg(
    &mut self,
    address_block_id: usize,
    register_file_id: Option<usize>,
    name: &str,
    offset: usize,
    size: Option<usize>,
    bit_order: &str,
    filename: Option<String>,
    lineno: Option<usize>,
    description: Option<String>
) -> Result<usize>

pub fn create_test_bit(&mut self) -> usize

Creates a bit for testing bit collections and so on, does not add the new bit to a parent register

pub fn get_reg_description(
    &mut self,
    filename: &str,
    lineno: usize
) -> Option<String>

impl Dut

pub fn create_pin_header(
    &mut self,
    model_id: usize,
    name: &str,
    pins: Vec<String>
) -> Result<&PinHeader, Error>

impl Dut

pub fn add_pin(
    &mut self,
    model_id: usize,
    name: &str,
    width: Option<u32>,
    offset: Option<u32>,
    reset_action: Option<Vec<PinAction>>,
    endianness: Option<Endianness>
) -> Result<&PinGroup>

pub fn add_pin_alias(
    &mut self,
    model_id: usize,
    name: &str,
    alias: &str
) -> Result<()>

pub fn group_pins_by_name(
    &mut self,
    model_id: usize,
    name: &str,
    pins: Vec<String>,
    endianness: Option<Endianness>
) -> Result<&PinGroup>

pub fn verify_names(
    &self,
    model_id: usize,
    names: &Vec<String>
) -> Result<Vec<String>>

Given a group/collection of pin names, verify: * Each pin exist * Each pin is unique (no duplicate pins) AND it points to a unique physical pin. That is, each pin is unique after resolving aliases. If all the above is met, we can group/collect these names.

pub fn collect_grp_ids_as_pin_ids(
    &self,
    grps: &Vec<(String, usize)>
) -> Result<Vec<usize>>

pub fn collect(
    &self,
    grps: &Vec<(String, usize)>,
    endianness: Option<Endianness>
) -> Result<PinStore>

pub fn pin_names_contain(
    &self,
    model_id: usize,
    names: &Vec<String>,
    query_name: &str
) -> Result<bool>

pub fn find_in_names(
    &self,
    model_id: usize,
    names: &Vec<String>,
    query_name: &str
) -> Result<Option<usize>>

pub fn index_of(
    &self,
    model_id: usize,
    name: &str,
    query_name: &str
) -> Result<Option<usize>>

Given a pin or alias name, finds either its name or alias in the group.

pub fn resolve_to_physical_pin(
    &self,
    model_id: usize,
    name: &str
) -> Option<&Pin>

pub fn data_fits_in_pins(&mut self, pins: &Vec<String>, data: u32) -> Result<()>

pub fn verify_data_fits(&mut self, width: u32, data: u32) -> Result<()>

pub fn verify_action_string_fits(
    &self,
    width: u32,
    action_string: &Vec<u8>
) -> Result<()>

pub fn pin_group_contains(
    &self,
    model_id: usize,
    name: &str,
    query_name: &str
) -> Result<bool>

Given a pin name, check if the pin or any of its aliases are present in pin group.

pub fn contains(&self, model_id: usize, name: &str) -> bool

pub fn _contains(&self, model_id: usize, name: &str) -> bool

pub fn _resolve_group_to_physical_pins(
    &self,
    model_id: usize,
    name: &str
) -> Result<Vec<&Pin>>

pub fn _resolve_groups_to_physical_pin_ids(
    &self,
    pins: &Vec<(usize, String)>
) -> Result<Vec<Vec<usize>>>

pub fn _resolve_to_flattened_pins(
    &self,
    pins: &Vec<(usize, String)>
) -> Result<Vec<&Pin>>

pub fn pin_group_to_ids(
    &self,
    model_id: usize,
    pin_grp_name: &str
) -> Result<(Vec<usize>, usize)>

Given a pin group name and model ID, converts it to a tuple containing: [0] -> Vec containing the physical pin IDs of the pins in this group [1] -> usize -> the resolved pin group ID

impl Dut

pub fn apply_wave_id_to_pins(
    &mut self,
    wave_id: usize,
    pins: &Vec<(usize, String)>
) -> Result<(), Error>

impl Dut

pub fn create_timeset(
    &mut self,
    model_id: usize,
    name: &str,
    period: Option<Box<dyn ToString>>,
    default_period: Option<f64>,
    targets: Vec<&TesterSource>
) -> Result<&Timeset, Error>

pub fn create_wavetable(
    &mut self,
    timeset_id: usize,
    name: &str
) -> Result<&Wavetable, Error>

pub fn create_wave_group(
    &mut self,
    wavetable_id: usize,
    name: &str,
    derived_from: Option<Vec<usize>>
) -> Result<&WaveGroup, Error>

pub fn create_wave(
    &mut self,
    wave_group_id: usize,
    indicator: &str,
    derived_from: Option<Vec<String>>
) -> Result<&Wave, Error>

pub fn create_event(
    &mut self,
    wave_id: usize,
    at: Box<dyn ToString>,
    unit: Option<String>,
    action: &str
) -> Result<&Event, Error>

Trait Implementations

impl Debug for Dut

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.