Struct apis::process::Def

pub struct Def<CTX: Context> { /* private fields */ }

Process definition.

Implementations

impl<CTX: Context> Def<CTX>

pub fn define(
    id: CTX::PID,
    kind: Kind,
    sourcepoints: Vec<CTX::CID>,
    endpoints: Vec<CTX::CID>
) -> Result<Self, Vec<DefineError>>

The only method to create a valid process def struct. Checks for duplicate sourcepoints or endpoints, self-loops, and restrictions on process kind (asynchronous processes are incompatible with certain combinations of backends).

Errors

Duplicate sourcepoint:

let result = process::Def::<Mycontext>::define (
  ProcessId::A,
  process::Kind::isochronous_default(),
  vec![ChannelId::X, ChannelId::Z, ChannelId::X],
  vec![ChannelId::Y]);
assert_eq!(
  result, Err (vec![process::DefineError::DuplicateSourcepoint]));

Duplicate endpoint:

let result = process::Def::<Mycontext>::define (
  ProcessId::A,
  process::Kind::isochronous_default(),
  vec![ChannelId::X, ChannelId::Z],
  vec![ChannelId::Y, ChannelId::Y]);
assert_eq!(
  result, Err (vec![process::DefineError::DuplicateEndpoint]));

Self-loop:

let result = process::Def::<Mycontext>::define (
  ProcessId::A,
  process::Kind::isochronous_default(),
  vec![ChannelId::X, ChannelId::Z],
  vec![ChannelId::Y, ChannelId::Z]);
assert_eq!(
  result, Err (vec![process::DefineError::SourcepointEqEndpoint]));

Asynchronous process zero endpoints:

let result = process::Def::<Mycontext>::define (
  ProcessId::A,
  process::Kind::asynchronous_default(),
  vec![ChannelId::Z],
  vec![]);
assert_eq!(
  result,
  Err (vec![process::DefineError::AsynchronousZeroEndpoints]));

Asynchronous process multiple endpoints:

let result = process::Def::<Mycontext>::define (
  ProcessId::A,
  process::Kind::asynchronous_default(),
  vec![ChannelId::Z],
  vec![ChannelId::X, ChannelId::Y]);
assert_eq!(
  result,
  Err (vec![process::DefineError::AsynchronousMultipleEndpoints]));

pub fn id(&self) -> &CTX::PID

pub fn kind(&self) -> &Kind

pub fn sourcepoints(&self) -> &Vec<CTX::CID>

pub fn endpoints(&self) -> &Vec<CTX::CID>

Trait Implementations

impl<CTX: Clone + Context> Clone for Def<CTX> where
    CTX::PID: Clone,
    CTX::CID: Clone,
    CTX::CID: Clone, 

fn clone(&self) -> Def<CTX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<CTX: Debug + Context> Debug for Def<CTX> where
    CTX::PID: Debug,
    CTX::CID: Debug,
    CTX::CID: Debug, 

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

Formats the value using the given formatter.

impl<CTX: PartialEq + Context> PartialEq<Def<CTX>> for Def<CTX> where
    CTX::PID: PartialEq,
    CTX::CID: PartialEq,
    CTX::CID: PartialEq, 

fn eq(&self, other: &Def<CTX>) -> bool

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

fn ne(&self, other: &Def<CTX>) -> bool

This method tests for !=.

impl<CTX: Eq + Context> Eq for Def<CTX> where
    CTX::PID: Eq,
    CTX::CID: Eq,
    CTX::CID: Eq, 

impl<CTX: Context> StructuralEq for Def<CTX>

impl<CTX: Context> StructuralPartialEq for Def<CTX>