Enum tydi::logical::LogicalStreamType

pub enum LogicalStreamType {
    Null,
    Bits(Positive),
    Group(Group),
    Union(Union),
    Stream(Stream),
}

Types of logical streams.

This structure is at the heart of the logical stream specification. It is used both to specify the type of a logical stream and internally for the process of lowering the recursive structure down to physical streams and signals.

The logical stream type is defined recursively by means of a number of stream types. Two classes of stream types are defined: stream-manipulating types, and element-manipulating types.

Examples

Reference

Variants

Null

The Null stream type indicates the transferrence of one-valued data: it is only valid value is ∅ (null).

Reference

Bits(Positive)

The Bits stream type, defined as Bits(b), indicates the transferrence of 2^b-valued data carried by means of a group of b bits, whereb is a positive integer.

Reference

Group(Group)

The Group stream type acts as a product type (composition).

Reference

Union(Union)

The Union stream type acts as a sum type (exclusive disjunction).

Reference

Stream(Stream)

The Stream type is used to define a new physical stream.

Reference

Methods

impl LogicalStreamType

pub fn try_new_bits(bit_count: NonNegative) -> Result<Self>

Returns a new Bits stream type with the provided bit count as number of bits. Returns an error when the bit count is zero.

Examples

use tydi::{Error, logical::LogicalStreamType, Positive};

let bits = LogicalStreamType::try_new_bits(4);
let zero = LogicalStreamType::try_new_bits(0);

assert_eq!(bits, Ok(LogicalStreamType::Bits(Positive::new(4).unwrap())));
assert_eq!(zero, Err(Error::InvalidArgument("bit count cannot be zero".to_string())));

pub fn try_new_group(
    group: impl IntoIterator<Item = (impl TryInto<Name, Error = impl Into<Box<dyn Error>>>, impl TryInto<LogicalStreamType, Error = impl Into<Box<dyn Error>>>)>
) -> Result<Self>

Returns a new Group stream type from the provided iterator of names and stream types. Returns an error when the values cannot be converted into valid names, or valid logical stream types as required by Group.

Examples

use tydi::{Error, logical::{Group, LogicalStreamType}};

let group = LogicalStreamType::try_new_group(
    vec![
        ("a", 4), // TryFrom<NonNegative> for LogicalStreamType::Bits.
        ("b", 12),
    ]
)?;

assert!(match group {
    LogicalStreamType::Group(_) => true,
    _ => false,
});

assert_eq!(
    LogicalStreamType::try_new_group(vec![("1badname", 4)]),
    Err(Error::InvalidArgument("name cannot start with a digit".to_string()))
);
assert_eq!(
    LogicalStreamType::try_new_group(vec![("good_name", 0)]),
    Err(Error::InvalidArgument("bit count cannot be zero".to_string()))
);

pub fn try_new_union(
    union: impl IntoIterator<Item = (impl TryInto<Name, Error = impl Into<Box<dyn Error>>>, impl TryInto<LogicalStreamType, Error = impl Into<Box<dyn Error>>>)>
) -> Result<Self>

pub fn is_element_only(&self) -> bool

Returns true if this logical stream consists of only element- manipulating stream types. This recursively checks all inner stream types.

Examples

use tydi::logical::LogicalStreamType;

assert!(LogicalStreamType::Null.is_element_only());
assert!(LogicalStreamType::try_new_bits(3)?.is_element_only());

pub fn is_null(&self) -> bool

Returns true if and only if this logical stream does not result in any signals.

Reference

pub fn fields(&self) -> Fields

Flattens a logical stream type consisting of Null, Bits, Group and Union stream types into a Fields.

Reference

pub fn synthesize(&self) -> LogicalStream

pub fn compatible(&self, other: &LogicalStreamType) -> bool

Trait Implementations

impl Clone for LogicalStreamType

fn clone(&self) -> LogicalStreamType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalStreamType

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

Formats the value using the given formatter.

impl From<Group> for LogicalStreamType

fn from(group: Group) -> Self

Wraps this group in a LogicalStreamType.

impl From<NonZeroU32> for LogicalStreamType

fn from(bit_count: Positive) -> Self

Performs the conversion.

impl From<Stream> for LogicalStreamType

fn from(stream: Stream) -> Self

Wraps this stream in a LogicalStreamType.

impl From<Union> for LogicalStreamType

fn from(union: Union) -> Self

Wraps this union in a LogicalStreamType.

impl PartialEq<LogicalStreamType> for LogicalStreamType

fn eq(&self, other: &LogicalStreamType) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &LogicalStreamType) -> bool

This method tests for !=.

impl StructuralPartialEq for LogicalStreamType

impl TryFrom<u32> for LogicalStreamType

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bit_count: NonNegative) -> Result<Self>

Returns a new Bits stream type with the provided bit count as number of bits. Returns an error when the bit count is zero.

impl Typify for LogicalStreamType

fn user(&self, prefix: impl Into<String>) -> Option<Type>

This implementation for LogicalStreamType assumes the LogicalStreamType has already been flattened through synthesize.

fn canonical(&self, prefix: impl Into<String>) -> Vec<Signal>