# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

[dev-dependencies]

# test-generator = "0.3.0"

crossbeam-utils = "0.7.2"

lazy_static = "1.4.0"

[lib]

# compile target: dynamically linked library using C ABI

crate-type = ["cdylib"]

[features]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

#define RW_WRONG_STATE -2

typedef enum {

  EndpointPolarity_Active,

  EndpointPolarity_Passive,

} EndpointPolarity;

typedef enum {

  Polarity_Putter,

  Polarity_Getter,

} Polarity;

typedef struct Arc_ProtocolDescription Arc_ProtocolDescription;

typedef struct Connector Connector;

typedef uint32_t ConnectorId;

typedef uint32_t U32Suffix;

typedef struct {

  ConnectorId connector_id;

  U32Suffix u32_suffix;

typedef struct {

  uint8_t ipv4[4];

  uint16_t port;

} FfiSocketAddr;

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a string slice for the component's identifier in the connector's configured protocol description,

 * - a set of ports (represented as a slice; duplicates are ignored) in the native component's interface,

 * the connector creates a new (internal) protocol component C, such that the set of native ports are moved to C.

 * Usable in {setup, communication} states.

 */

int connector_add_component(Connector *connector,

                            const uint8_t *ident_ptr,

                            uintptr_t ident_len,

                            const PortId *ports_ptr,

                            uintptr_t ports_len);

/**

 * Given

 * - an initialized connector in setup or connecting state,

 * - a utf-8 encoded socket address,

            Statement::Goto(result) => result,

            _ => panic!("Unable to cast `Statement` to `GotoStatement`"),

        }

    }

    pub fn as_new(&self) -> &NewStatement {

        match self {

            Statement::New(result) => result,

            _ => panic!("Unable to cast `Statement` to `NewStatement`"),

        }

    }

    pub fn as_put(&self) -> &PutStatement {

        match self {

            Statement::Put(result) => result,

            _ => panic!("Unable to cast `Statement` to `PutStatement`"),

        }

    }

    pub fn as_expression(&self) -> &ExpressionStatement {

        match self {

            Statement::Expression(result) => result,

            _ => panic!("Unable to cast `Statement` to `ExpressionStatement`"),

        }

    }

    pub fn link_next(&mut self, next: StatementId) {

        match self {

            Statement::Local(stmt) => match stmt {

                LocalStatement::Channel(stmt) => stmt.next = Some(next),

                LocalStatement::Memory(stmt) => stmt.next = Some(next),

            },

            Statement::Skip(stmt) => stmt.next = Some(next),

            Statement::EndIf(stmt) => stmt.next = Some(next),

            Statement::EndWhile(stmt) => stmt.next = Some(next),

            Statement::EndSynchronous(stmt) => stmt.next = Some(next),

            Statement::Assert(stmt) => stmt.next = Some(next),

            Statement::New(stmt) => stmt.next = Some(next),

            Statement::Put(stmt) => stmt.next = Some(next),

            Statement::Expression(stmt) => stmt.next = Some(next),

        }

    }

}

impl SyntaxElement for Statement {

    fn position(&self) -> InputPosition {

        match self {

            Statement::Block(stmt) => stmt.position(),

            Statement::Local(stmt) => stmt.position(),

            Statement::Skip(stmt) => stmt.position(),

            Statement::Labeled(stmt) => stmt.position(),

            Statement::If(stmt) => stmt.position(),

            Statement::EndIf(stmt) => stmt.position(),

            Statement::While(stmt) => stmt.position(),

            Statement::EndWhile(stmt) => stmt.position(),

            Statement::Break(stmt) => stmt.position(),

            Statement::Continue(stmt) => stmt.position(),

            Statement::Synchronous(stmt) => stmt.position(),

            Statement::EndSynchronous(stmt) => stmt.position(),

            Statement::Return(stmt) => stmt.position(),

            Statement::Assert(stmt) => stmt.position(),

            Statement::Goto(stmt) => stmt.position(),

            Statement::New(stmt) => stmt.position(),

            Statement::Put(stmt) => stmt.position(),

                }

            }

            Expression::Unary(expr) => {

                let mut value = self.eval(h, ctx, expr.expression)?;

                match expr.operation {

                    UnaryOperation::PostIncrement => {

                        self.update(h, ctx, expr.expression, value.plus(&ONE))?;

                    }

                    UnaryOperation::PreIncrement => {

                        value = value.plus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    UnaryOperation::PostDecrement => {

                        self.update(h, ctx, expr.expression, value.minus(&ONE))?;

                    }

                    UnaryOperation::PreDecrement => {

                        value = value.minus(&ONE);

                        self.update(h, ctx, expr.expression, value.clone())?;

                    }

                    _ => unimplemented!(),

                }

                Ok(value)

            }

            Expression::Indexing(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Select(expr) => self.get(h, ctx, expr.this.upcast()),

            Expression::Array(expr) => {

                let mut elements = Vec::new();

                for &elem in expr.elements.iter() {

                    elements.push(self.eval(h, ctx, elem)?);

                }

                todo!()

            }

            Expression::Constant(expr) => Ok(Value::from_constant(&expr.value)),

            Expression::Call(expr) => match expr.method {

                Method::Create => {

                    assert_eq!(1, expr.arguments.len());

                    let length = self.eval(h, ctx, expr.arguments[0])?;

                    Ok(Value::create_message(length))

                }

                Method::Fires => {

                    assert_eq!(1, expr.arguments.len());

                    let value = self.eval(h, ctx, expr.arguments[0])?;

                    match ctx.fires(value.clone()) {

                        None => Err(EvalContinuation::BlockFires(value)),

                        Some(result) => Ok(result),

                    }

                }

                Method::Get => {

                    assert_eq!(1, expr.arguments.len());

                    let value = self.eval(h, ctx, expr.arguments[0])?;

                    match ctx.get(value.clone()) {

                        None => Err(EvalContinuation::BlockGet(value)),

                        Some(result) => Ok(result),

                    }

                }

            },

            Expression::Variable(expr) => self.get(h, ctx, expr.this.upcast()),

        }

    }

}

type EvalResult = Result<Value, EvalContinuation>;

pub enum EvalContinuation {

    Stepping,

    Inconsistent,

    Terminal,

    SyncBlockStart,

    SyncBlockEnd,

    NewComponent(DeclarationId, Vec<Value>),

    BlockFires(Value),

    BlockGet(Value),

    Put(Value, Value),

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub(crate) struct Prompt {

    definition: DefinitionId,

    store: Store,

    position: Option<StatementId>,

                self.position = stmt.target.map(|x| x.upcast());

                Err(EvalContinuation::Stepping)

            }

            Statement::New(stmt) => {

                let expr = &h[stmt.expression];

                let mut args = Vec::new();

                for &arg in expr.arguments.iter() {

                    let value = self.store.eval(h, ctx, arg)?;

                    args.push(value);

                }

                self.position = stmt.next;

                Err(EvalContinuation::NewComponent(expr.declaration.unwrap(), args))

            }

            Statement::Put(stmt) => {

                // Evaluate port and message

                let port = self.store.eval(h, ctx, stmt.port)?;

                let message = self.store.eval(h, ctx, stmt.message)?;

                // Continue to next statement

                self.position = stmt.next;

                // Signal the put upwards

                Err(EvalContinuation::Put(port, message))

            }

            Statement::Expression(stmt) => {

                // Evaluate expression

                // Continue to next statement

                self.position = stmt.next;

                Err(EvalContinuation::Stepping)

            }

        }

    }

    // let mut prompt = Self::new(h, fun.upcast(), args);

    // let mut context = EvalContext::None;

    // loop {

    //     let result = prompt.step(h, &mut context);

    //     match result {

    //         Ok(val) => return Some(val),

    //         Err(cont) => match cont {

    //             EvalContinuation::Stepping => continue,

    //             EvalContinuation::Inconsistent => return None,

    //             // Functions never terminate without returning

    //             EvalContinuation::Terminal => unreachable!(),

    //             // Functions never encounter any blocking behavior

    //             EvalContinuation::SyncBlockStart => unreachable!(),

    //             EvalContinuation::SyncBlockEnd => unreachable!(),

    //             EvalContinuation::NewComponent(_, _) => unreachable!(),

    //             EvalContinuation::BlockFires(val) => unreachable!(),

    //             EvalContinuation::BlockGet(val) => unreachable!(),

    //             EvalContinuation::Put(port, msg) => unreachable!(),

    //         },

    //     }

    // }

}

// #[cfg(test)]

// mod tests {

//     extern crate test_generator;

//     use std::fs::File;

//     use std::io::Read;

//     use std::path::Path;

//     use test_generator::test_resources;

//     use super::*;

//     #[test_resources("testdata/eval/positive/*.pdl")]

//     fn batch1(resource: &str) {

//         let path = Path::new(resource);

//         let expect = path.with_extension("txt");

//         let mut heap = Heap::new();

//         let mut source = InputSource::from_file(&path).unwrap();

//         let mut parser = Parser::new(&mut source);

//         let pd = parser.parse(&mut heap).unwrap();

//         let def = heap[pd].get_definition_ident(&heap, b"test").unwrap();

//         let fun = heap[def].as_function().this;

//         let args = Vec::new();

    for &param in h[def].parameters.clone().iter() {

        recursive_parameter_as_variable(this, h, param)?;

    }

    this.visit_statement(h, h[def].body)

}

fn recursive_variable_declaration<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    decl: VariableId,

) -> VisitorResult {

    match h[decl].clone() {

        Variable::Parameter(decl) => this.visit_parameter_declaration(h, decl.this),

        Variable::Local(decl) => this.visit_local_declaration(h, decl.this),

    }

}

fn recursive_statement<T: Visitor>(this: &mut T, h: &mut Heap, stmt: StatementId) -> VisitorResult {

    match h[stmt].clone() {

        Statement::Block(stmt) => this.visit_block_statement(h, stmt.this),

        Statement::Local(stmt) => this.visit_local_statement(h, stmt.this()),

        Statement::Skip(stmt) => this.visit_skip_statement(h, stmt.this),

        Statement::Labeled(stmt) => this.visit_labeled_statement(h, stmt.this),

        Statement::If(stmt) => this.visit_if_statement(h, stmt.this),

        Statement::While(stmt) => this.visit_while_statement(h, stmt.this),

        Statement::Break(stmt) => this.visit_break_statement(h, stmt.this),

        Statement::Continue(stmt) => this.visit_continue_statement(h, stmt.this),

        Statement::Synchronous(stmt) => this.visit_synchronous_statement(h, stmt.this),

        Statement::Return(stmt) => this.visit_return_statement(h, stmt.this),

        Statement::Assert(stmt) => this.visit_assert_statement(h, stmt.this),

        Statement::Goto(stmt) => this.visit_goto_statement(h, stmt.this),

        Statement::New(stmt) => this.visit_new_statement(h, stmt.this),

        Statement::Put(stmt) => this.visit_put_statement(h, stmt.this),

        Statement::Expression(stmt) => this.visit_expression_statement(h, stmt.this),

    }

}

fn recursive_block_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    block: BlockStatementId,

) -> VisitorResult {

    for &local in h[block].locals.clone().iter() {

        recursive_local_as_variable(this, h, local)?;

    }

    for &stmt in h[block].statements.clone().iter() {

        this.visit_statement(h, stmt)?;

    }

    Ok(())

}

fn recursive_local_statement<T: Visitor>(

    this: &mut T,

    h: &mut Heap,

    stmt: LocalStatementId,

) -> VisitorResult {

    match h[stmt].clone() {

        LocalStatement::Channel(stmt) => this.visit_channel_statement(h, stmt.this),

                return match h[decl].clone() {

                    Declaration::Defined(defined) => Err(ParseError::new(

                        h[defined.definition].position(),

                        format!("Defined symbol clash: {}", h[id]),

                    )),

                    Declaration::Imported(imported) => Err(ParseError::new(

                        h[imported.import].position(),

                        format!("Imported symbol clash: {}", h[id]),

                    )),

                };

            }

        }

        self.declarations.push(decl);

        Ok(())

    }

}

impl Visitor for BuildSymbolDeclarations {

    fn visit_protocol_description(&mut self, h: &mut Heap, pd: RootId) -> VisitorResult {

        recursive_protocol_description(self, h, pd)?;

        // Move all collected declarations to the protocol description

        h[pd].declarations.append(&mut self.declarations);

        Ok(())

    }

        todo!()

        // let vec = library::get_declarations(h, import)?;

        // // Destructively iterate over the vector

        // for decl in vec {

        //     self.checked_add(h, decl)?;

        // }

        // Ok(())

    }

    fn visit_symbol_definition(&mut self, h: &mut Heap, definition: DefinitionId) -> VisitorResult {

        let signature = Signature::from_definition(h, definition);

        let decl = h

            .alloc_defined_declaration(|this| DefinedDeclaration { this, definition, signature })

            .upcast();

        self.checked_add(h, decl)?;

        Ok(())

    }

}

struct LinkCallExpressions {

    pd: Option<RootId>,

    composite: bool,

    new_statement: bool,

}

        h[stmt].parent_scope = self.scope;

        // Then move scope down to current block

        self.scope = Some(Scope::Block(stmt));

        recursive_block_statement(self, h, stmt)?;

        // Move scope back up

        self.scope = old;

        Ok(())

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        assert!(!self.scope.is_none());

        let old = self.scope;

        // First store the current scope

        h[stmt].parent_scope = self.scope;

        // Then move scope down to current sync

        self.scope = Some(Scope::Synchronous(stmt));

        recursive_synchronous_statement(self, h, stmt)?;

        // Move scope back up

        self.scope = old;

        Ok(())

    }

        Ok(())

    }

}

struct ResolveVariables {

    scope: Option<Scope>,

}

impl ResolveVariables {

    fn new() -> Self {

        ResolveVariables { scope: None }

    }

    fn get_variable(&self, h: &Heap, id: SourceIdentifierId) -> Result<VariableId, ParseError> {

        if let Some(var) = self.find_variable(h, id) {

            Ok(var)

        } else {

            Err(ParseError::new(h[id].position, "Unresolved variable"))

        }

    }

    fn find_variable(&self, h: &Heap, id: SourceIdentifierId) -> Option<VariableId> {

        ResolveVariables::find_variable_impl(h, self.scope, id)

    }

    fn find_variable_impl(

        h: &Heap,

        // otherwise, there is some variable defined in the parent scope. This check

        // imposes that the order in which find_variable looks is significant!

        let id = h[decl].identifier();

        let check_same = self.find_variable(h, id);

        if let Some(check_same) = check_same {

            if check_same != decl {

                return Err(ParseError::new(h[id].position, "Declared variable clash"));

            }

        }

        recursive_variable_declaration(self, h, decl)

    }

    fn visit_memory_statement(&mut self, h: &mut Heap, stmt: MemoryStatementId) -> VisitorResult {

        assert!(!self.scope.is_none());

        let var = h[stmt].variable;

        let id = h[var].identifier;

        // First check whether variable with same identifier is in scope

        let check_duplicate = self.find_variable(h, id);

        if check_duplicate.is_some() {

            return Err(ParseError::new(h[id].position, "Declared variable clash"));

        }

        // Then check the expression's variables (this should not refer to own variable)

        recursive_memory_statement(self, h, stmt)?;

        // Finally, we may add the variable to the scope, which is guaranteed to be a block

        {

            block.locals.push(var);

        }

        Ok(())

    }

    fn visit_channel_statement(&mut self, h: &mut Heap, stmt: ChannelStatementId) -> VisitorResult {

        assert!(!self.scope.is_none());

        // First handle the from variable

        {

            let var = h[stmt].from;

            let id = h[var].identifier;

            let check_duplicate = self.find_variable(h, id);

            if check_duplicate.is_some() {

                return Err(ParseError::new(h[id].position, "Declared variable clash"));

            }

            block.locals.push(var);

        }

        // Then handle the to variable (which may not be the same as the from)

        {

            let var = h[stmt].to;

            let id = h[var].identifier;

            let check_duplicate = self.find_variable(h, id);

            if check_duplicate.is_some() {

                return Err(ParseError::new(h[id].position, "Declared variable clash"));

            }

            block.locals.push(var);

        }

        Ok(())

    }

    fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {

        assert!(!self.scope.is_none());

        let old = self.scope;

        self.scope = Some(Scope::Block(stmt));

        recursive_block_statement(self, h, stmt)?;

        self.scope = old;

        Ok(())

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        assert!(!self.scope.is_none());

        let old = self.scope;

        self.scope = Some(Scope::Synchronous(stmt));

        recursive_synchronous_statement(self, h, stmt)?;

        self.scope = old;

        Ok(())

    }

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        // Allocate a pseudo-statement, that is added for helping the evaluator to issue a command

        // that marks the end of the synchronous block. Every evaluation has to pause at this

        // point, only to resume later when the thread is selected as unique thread to continue.

        let position = h[stmt].position;

        let pseudo = h

            .alloc_end_synchronous_statement(|this| EndSynchronousStatement {

                this,

                position,

                next: None,

            })

            .upcast();

        assert!(self.prev.is_none());

        self.visit_statement(h, h[stmt].body)?;

        // The body's next statement points to the pseudo element

        if let Some(UniqueStatementId(prev)) = std::mem::replace(&mut self.prev, None) {

            h[prev].link_next(pseudo);

        }

        // Use the pseudo-statement as the statement where the next pointer is updated

        self.prev = Some(UniqueStatementId(pseudo));

        Ok(())

    }

        Ok(())

    }

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_goto_statement(&mut self, _h: &mut Heap, _stmt: GotoStatementId) -> VisitorResult {

        Ok(())

    }

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

    fn visit_expression_statement(

        &mut self,

        stmt: ExpressionStatementId,

    ) -> VisitorResult {

        self.prev = Some(UniqueStatementId(stmt.upcast()));

        Ok(())

    }

        Ok(())

    }

}

struct BuildLabels {

    block: Option<BlockStatementId>,

    sync_enclosure: Option<SynchronousStatementId>,

}

impl BuildLabels {

    fn new() -> Self {

        BuildLabels { block: None, sync_enclosure: None }

    }

}

impl Visitor for BuildLabels {

    fn visit_block_statement(&mut self, h: &mut Heap, stmt: BlockStatementId) -> VisitorResult {

        assert_eq!(self.block, h[stmt].parent_block(h));

        let old = self.block;

        self.block = Some(stmt);

        recursive_block_statement(self, h, stmt)?;

        self.block = old;

        Ok(())

    }

    fn visit_labeled_statement(&mut self, h: &mut Heap, stmt: LabeledStatementId) -> VisitorResult {

        assert!(!self.block.is_none());

        // Store label in current block (on the fly)

        h[self.block.unwrap()].labels.push(stmt);

        // Update synchronous scope of label

        h[stmt].in_sync = self.sync_enclosure;

        recursive_labeled_statement(self, h, stmt)

    }

    fn visit_while_statement(&mut self, h: &mut Heap, stmt: WhileStatementId) -> VisitorResult {

        h[stmt].in_sync = self.sync_enclosure;

        recursive_while_statement(self, h, stmt)

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        assert!(self.sync_enclosure.is_none());

        self.sync_enclosure = Some(stmt);

        recursive_synchronous_statement(self, h, stmt)?;

        self.sync_enclosure = None;

        Ok(())

    }

        Ok(())

    }

}

struct ResolveLabels {

    block: Option<BlockStatementId>,

    while_enclosure: Option<WhileStatementId>,

    sync_enclosure: Option<SynchronousStatementId>,

}

impl ResolveLabels {

    fn new() -> Self {

        ResolveLabels { block: None, while_enclosure: None, sync_enclosure: None }

    }

    fn check_duplicate_impl(

        h: &Heap,

        block: Option<BlockStatementId>,

        stmt: LabeledStatementId,

    ) -> VisitorResult {

        if let Some(block) = block {

            // Checking the parent first is important. Otherwise, labels

            // overshadow previously defined labels: and this is illegal!

            ResolveLabels::check_duplicate_impl(h, h[block].parent_block(h), stmt)?;

            // For the current block, check for a duplicate.

        Ok(())

    }

    fn visit_synchronous_statement(

        &mut self,

        h: &mut Heap,

        stmt: SynchronousStatementId,

    ) -> VisitorResult {

        assert!(self.sync_enclosure.is_none());

        self.sync_enclosure = Some(stmt);

        recursive_synchronous_statement(self, h, stmt)?;

        self.sync_enclosure = None;

        Ok(())

    }

    fn visit_goto_statement(&mut self, h: &mut Heap, stmt: GotoStatementId) -> VisitorResult {

        let target = self.get_target(h, h[stmt].label)?;

        if h[target].in_sync != self.sync_enclosure {

            return Err(ParseError::new(

                h[stmt].position,

                "Illegal goto: synchronous statement escape",

            ));

        }

        h[stmt].target = Some(target);

        Ok(())

    }

        Ok(())

    }

}

struct AssignableExpressions {

    assignable: bool,

}

impl AssignableExpressions {

    fn new() -> Self {

        AssignableExpressions { assignable: false }

    }

    fn error(&self, position: InputPosition) -> VisitorResult {

        Err(ParseError::new(position, "Unassignable expression"))

    }

}

impl Visitor for AssignableExpressions {

    fn visit_assignment_expression(

        &mut self,

        h: &mut Heap,

        expr: AssignmentExpressionId,

    ) -> VisitorResult {

        if self.assignable {

        } else {

            recursive_array_expression(self, h, expr)

        }

    }

    fn visit_call_expression(&mut self, h: &mut Heap, expr: CallExpressionId) -> VisitorResult {

        if self.assignable {

            self.error(h[expr].position)

        } else {

            recursive_call_expression(self, h, expr)

        }

    }

    fn visit_constant_expression(

        &mut self,

        h: &mut Heap,

        expr: ConstantExpressionId,

    ) -> VisitorResult {

        if self.assignable {

            self.error(h[expr].position)

        } else {

            Ok(())

        }

    }

    fn visit_variable_expression(

        &mut self,

    ) -> VisitorResult {

        Ok(())

    }

}

struct IndexableExpressions {

    indexable: bool,

}

impl IndexableExpressions {

    fn new() -> Self {

        IndexableExpressions { indexable: false }

    }

    fn error(&self, position: InputPosition) -> VisitorResult {

        Err(ParseError::new(position, "Unindexable expression"))

    }

}

impl Visitor for IndexableExpressions {

    fn visit_assignment_expression(

        &mut self,

        h: &mut Heap,

        expr: AssignmentExpressionId,

    ) -> VisitorResult {

        D: serde::Deserializer<'de>,

    {

        let inner: ProtocolDescription = ProtocolDescription::deserialize(deserializer)?;

        Ok(Self(Arc::new(inner)))

    }

}

impl IdParts for SpecVar {

    fn id_parts(self) -> (ConnectorId, U32Suffix) {

        self.0.id_parts()

    }

}

impl Debug for SpecVar {

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

        let (a, b) = self.id_parts();

        write!(f, "v{}_{}", a, b)

    }

}

impl SpecVal {

    const FIRING: Self = SpecVal(1);

    const SILENT: Self = SpecVal(0);

    fn is_firing(self) -> bool {

        self == Self::FIRING

        // all else treated as SILENT

    }

    fn iter_domain() -> impl Iterator<Item = Self> {

        (0..).map(SpecVal)

    }

}

impl Debug for SpecVal {

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

        self.0.fmt(f)

    }

}

impl Default for UdpInBuffer {

    fn default() -> Self {

        let mut byte_vec = Vec::with_capacity(Self::CAPACITY);

        unsafe {

            // safe! this vector is guaranteed to have sufficient capacity

            byte_vec.set_len(Self::CAPACITY);

        }

        Self { byte_vec }