Type Definition moore_vhdl::ty2::PhysicalSubtype

pub type PhysicalSubtype<'t> = ScalarSubtype<'t, dyn PhysicalType, BigInt>;

A subtype of an integer type.

Implementations

impl<'t> PhysicalSubtype<'t>

pub fn new(
    mark: &'t TypeMark<'t>,
    range: Range<BigInt>
) -> Option<PhysicalSubtype<'t>>

Create a new integer subtype.

Returns Some(...) if range is a subrange of the integer, or None otherwise.

Example

use moore_vhdl::ty2::{Type, TypeMark, PhysicalUnit, PhysicalBasetype, PhysicalSubtype, Range};
use moore_common::name::get_name_table;

let ty = PhysicalBasetype::new(Range::ascending(-1000isize, 1000isize), vec![
    PhysicalUnit::primary(get_name_table().intern("fs", false), 1),
    PhysicalUnit::secondary(get_name_table().intern("ps", false), 1000, 1000, 0),
], 0);
let tm = TypeMark::new(
    get_name_table().intern("TIME", false),
    &ty,
);
let a = PhysicalSubtype::new(&tm, Range::ascending(0isize, 100isize)).unwrap();
let b = PhysicalSubtype::new(&tm, Range::descending(100isize, 0isize)).unwrap();

assert_eq!(format!("{}", a), "TIME range 0 to 100");
assert_eq!(format!("{}", b), "TIME range 100 downto 0");

Trait Implementations

impl<'t> Display for PhysicalSubtype<'t>

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

Formats the value using the given formatter.

impl<'t> PhysicalType for PhysicalSubtype<'t>

fn as_type(&self) -> &dyn Type

Convert to a type.

fn range(&self) -> &Range<BigInt>

The range of values this physical type can assume.

fn units(&self) -> &[PhysicalUnit]

The units of measure of this type.

fn primary_index(&self) -> usize

The index of the primary unit.

fn base_type(&self) -> &dyn Type

The base type of this physical type.

fn as_subtype(&self) -> Option<&PhysicalSubtype<'_>>

Returns Some if self is a PhysicalSubtype, None otherwise.

fn is_equal(&self, other: &dyn PhysicalType) -> bool

Check if two physical types are equal.

fn resolution_func(&self) -> Option<usize>

The resolution function associated with this type.

fn as_basetype(&self) -> Option<&PhysicalBasetype>

Returns Some if self is a PhysicalBasetype, None otherwise.

fn unwrap_basetype(&self) -> &PhysicalBasetype

Returns an &PhysicalBasetype or panics if the type is not a basetype.

fn unwrap_subtype(&self) -> &PhysicalSubtype<'_>

Returns an &PhysicalSubtype or panics if the type is not a subtype.

impl<'t> Type for PhysicalSubtype<'t>

fn is_scalar(&self) -> bool

Check if this is a scalar type.

fn is_discrete(&self) -> bool

Check if this is a discrete type.

fn is_numeric(&self) -> bool

Check if this is a numeric type.

fn is_composite(&self) -> bool

Check if this is a composite type.

fn as_any(&self) -> AnyType<'_>

Converts from &Type to AnyType.

fn into_owned<'a>(self) -> OwnedType<'a> where
    Self: 'a, 

Convert into an owned type.

fn to_owned<'a>(&self) -> OwnedType<'a> where
    Self: 'a, 

Clone this type.

fn is_equal(&self, other: &dyn Type) -> bool

Check if two types are equal.

fn is_implicitly_castable(&self, _into: &dyn Type) -> bool

Check if the type can be implicitly cast to another.