Struct hexodsp::matrix::Cell

pub struct Cell {
    node_id: NodeId,
    x: u8,
    y: u8,
    out1: Option<u8>,
    out2: Option<u8>,
    out3: Option<u8>,
    in1: Option<u8>,
    in2: Option<u8>,
    in3: Option<u8>,
}

This is a cell/tile of the hexagonal Matrix.

The Matrix stores it to keep track of the graphical representation of the hexagonal tilemap. Using Matrix::place you can place new cells.

 use hexodsp::*;

 let (node_conf, mut node_exec) = new_node_engine();
 let mut matrix = Matrix::new(node_conf, 3, 3);

 matrix.place(
     2, 2,
     Cell::empty(NodeId::Sin(0))
     .input(Some(0), None, None)
     .out(None, None, Some(0)));

 matrix.sync().unwrap();

Fields

node_id: NodeId

x: u8

y: u8

out1: Option<u8>

Top-Right output

out2: Option<u8>

Bottom-Right output

out3: Option<u8>

Bottom output

in1: Option<u8>

Top input

in2: Option<u8>

Top-Left input

in3: Option<u8>

Bottom-Left input

Implementations

impl Cell

pub fn empty(node_id: NodeId) -> Self

This is the main contructor of a Cell. Empty means that there is no associated position of this cell and no inputs/outputs have been assigned. Use the methods Cell::input and Cell::out to assign inputs / outputs.

 use hexodsp::*;

 let some_cell =
     Cell::empty(NodeId::Sin(0))
     .input(None, Some(0), Some(0))
     .out(None, Some(0), Some(0));

pub fn empty_at(node_id: NodeId, x: u8, y: u8) -> Self

This is an alternative constructor, in case you know the position of the cell before you got it from the Matrix.

pub fn to_repr(&self) -> CellRepr

Returns a serializable representation of this Matrix Cell.

See also CellRepr.

 use hexodsp::*;

 let some_cell =
     Cell::empty(NodeId::Sin(0))
     .input(None, Some(0), Some(0))
     .out(None, Some(0), Some(0));

 let repr = some_cell.to_repr();
 assert_eq!(
     repr.serialize().to_string(),
     "[\"sin\",0,0,0,[-1,\"freq\",\"freq\"],[-1,\"sig\",\"sig\"]]");

pub fn from_repr(repr: &CellRepr) -> Self

pub fn with_pos_of(&self, other: Cell) -> Self

pub fn is_empty(&self) -> bool

pub fn node_id(&self) -> NodeId

pub fn set_node_id(&mut self, new_id: NodeId)

pub fn set_node_id_keep_ios(&mut self, node_id: NodeId)

pub fn label<'a>(&self, buf: &'a mut [u8]) -> Option<&'a str>

pub fn pos(&self) -> (usize, usize)

pub fn offs_dir(&mut self, dir: CellDir) -> bool

pub fn has_dir_set(&self, dir: CellDir) -> bool

pub fn local_port_idx(&self, dir: CellDir) -> Option<u8>

pub fn clear_io_dir(&mut self, dir: CellDir)

pub fn set_io_dir(&mut self, dir: CellDir, idx: usize)

pub fn set_input_by_name(&mut self, name: &str, dir: CellDir) -> Result<(), ()>

This is a helper function to quickly set an input by name and direction.

 use hexodsp::*;

 let mut cell = Cell::empty(NodeId::Sin(0));
 cell.set_input_by_name("freq", CellDir::T).unwrap();

pub fn set_output_by_name(&mut self, name: &str, dir: CellDir) -> Result<(), ()>

This is a helper function to quickly set an output by name and direction.

 use hexodsp::*;

 let mut cell = Cell::empty(NodeId::Sin(0));
 cell.set_output_by_name("sig", CellDir::B).unwrap();

pub fn input(self, i1: Option<u8>, i2: Option<u8>, i3: Option<u8>) -> Self

pub fn out(self, o1: Option<u8>, o2: Option<u8>, o3: Option<u8>) -> Self

pub fn find_first_adjacent_free(
    &self,
    m: &Matrix,
    dir: CellDir
) -> Option<(CellDir, Option<u8>)>

Finds the first free input or output (one without an adjacent cell). If any free input/output has an assigned input, that edge is returned before any else. With dir you can specify input with CellDir::T, output with CellDir::B and any with CellDir::C.

pub fn find_all_adjacent_free(
    &self,
    m: &Matrix,
    dir: CellDir
) -> Vec<(CellDir, (usize, usize))>

Finds the all adjacent free places around the current cell. With dir you can specify input with CellDir::T, output with CellDir::B and any with CellDir::C.

pub fn find_unconnected_ports(&self, m: &Matrix, dir: CellDir) -> Vec<CellDir>

Finds all dangling ports in the specified direction. With dir you can specify input with CellDir::T, output with CellDir::B and any with CellDir::C.

pub fn is_port_dir_connected(
    &self,
    m: &Matrix,
    dir: CellDir
) -> Option<(usize, usize)>

If the port is connected, it will return the position of the other cell.

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl Ord for Cell

fn cmp(&self, other: &Cell) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Cell> for Cell

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Cell> for Cell

fn partial_cmp(&self, other: &Cell) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Cell

impl Eq for Cell

impl StructuralEq for Cell

impl StructuralPartialEq for Cell