Changeset - 4776bcc45b33
[Not reviewed]
0 5 2
Christopher Esterhuyse - 5 years ago 2020-06-19 12:05:46
christopher.esterhuyse@gmail.com
serde for protocol {component state, description} + start of v2 connector internals
7 files changed with 430 insertions and 120 deletions:
0 comments (0 inline, 0 general)
src/protocol/ast.rs
Show inline comments
 
@@ -6,19 +6,19 @@ use super::arena::{Arena, Id};
 

	
 
use crate::protocol::inputsource::*;
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct RootId(Id<Root>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct PragmaId(Id<Pragma>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ImportId(Id<Import>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct IdentifierId(Id<Identifier>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct SourceIdentifierId(IdentifierId);
 

	
 
impl SourceIdentifierId {
 
@@ -27,7 +27,7 @@ impl SourceIdentifierId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct ExternalIdentifierId(IdentifierId);
 

	
 
impl ExternalIdentifierId {
 
@@ -36,13 +36,13 @@ impl ExternalIdentifierId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct TypeAnnotationId(Id<TypeAnnotation>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct VariableId(Id<Variable>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct ParameterId(VariableId);
 

	
 
impl ParameterId {
 
@@ -51,7 +51,7 @@ impl ParameterId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 
pub struct LocalId(VariableId);
 

	
 
impl LocalId {
 
@@ -63,7 +63,7 @@ impl LocalId {
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct DefinitionId(Id<Definition>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ComponentId(DefinitionId);
 

	
 
impl ComponentId {
 
@@ -72,7 +72,7 @@ impl ComponentId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct FunctionId(DefinitionId);
 

	
 
impl FunctionId {
 
@@ -81,7 +81,7 @@ impl FunctionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct CompositeId(ComponentId);
 

	
 
impl CompositeId {
 
@@ -90,7 +90,7 @@ impl CompositeId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct PrimitiveId(ComponentId);
 

	
 
impl PrimitiveId {
 
@@ -102,7 +102,7 @@ impl PrimitiveId {
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct StatementId(Id<Statement>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct BlockStatementId(StatementId);
 

	
 
impl BlockStatementId {
 
@@ -111,7 +111,7 @@ impl BlockStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct LocalStatementId(StatementId);
 

	
 
impl LocalStatementId {
 
@@ -120,7 +120,7 @@ impl LocalStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct MemoryStatementId(LocalStatementId);
 

	
 
impl MemoryStatementId {
 
@@ -129,7 +129,7 @@ impl MemoryStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ChannelStatementId(LocalStatementId);
 

	
 
impl ChannelStatementId {
 
@@ -138,7 +138,7 @@ impl ChannelStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct SkipStatementId(StatementId);
 

	
 
impl SkipStatementId {
 
@@ -147,7 +147,7 @@ impl SkipStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct LabeledStatementId(StatementId);
 

	
 
impl LabeledStatementId {
 
@@ -156,7 +156,7 @@ impl LabeledStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct IfStatementId(StatementId);
 

	
 
impl IfStatementId {
 
@@ -165,7 +165,7 @@ impl IfStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct EndIfStatementId(StatementId);
 

	
 
impl EndIfStatementId {
 
@@ -174,7 +174,7 @@ impl EndIfStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct WhileStatementId(StatementId);
 

	
 
impl WhileStatementId {
 
@@ -183,7 +183,7 @@ impl WhileStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct EndWhileStatementId(StatementId);
 

	
 
impl EndWhileStatementId {
 
@@ -192,7 +192,7 @@ impl EndWhileStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct BreakStatementId(StatementId);
 

	
 
impl BreakStatementId {
 
@@ -201,7 +201,7 @@ impl BreakStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ContinueStatementId(StatementId);
 

	
 
impl ContinueStatementId {
 
@@ -210,7 +210,7 @@ impl ContinueStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct SynchronousStatementId(StatementId);
 

	
 
impl SynchronousStatementId {
 
@@ -219,7 +219,7 @@ impl SynchronousStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct EndSynchronousStatementId(StatementId);
 

	
 
impl EndSynchronousStatementId {
 
@@ -228,7 +228,7 @@ impl EndSynchronousStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ReturnStatementId(StatementId);
 

	
 
impl ReturnStatementId {
 
@@ -237,7 +237,7 @@ impl ReturnStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct AssertStatementId(StatementId);
 

	
 
impl AssertStatementId {
 
@@ -246,7 +246,7 @@ impl AssertStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct GotoStatementId(StatementId);
 

	
 
impl GotoStatementId {
 
@@ -255,7 +255,7 @@ impl GotoStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct NewStatementId(StatementId);
 

	
 
impl NewStatementId {
 
@@ -264,7 +264,7 @@ impl NewStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct PutStatementId(StatementId);
 

	
 
impl PutStatementId {
 
@@ -273,7 +273,7 @@ impl PutStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ExpressionStatementId(StatementId);
 

	
 
impl ExpressionStatementId {
 
@@ -282,10 +282,10 @@ impl ExpressionStatementId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ExpressionId(Id<Expression>);
 

	
 
#[derive(Debug, Clone, Copy, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 
pub struct AssignmentExpressionId(ExpressionId);
 

	
 
impl AssignmentExpressionId {
 
@@ -294,7 +294,7 @@ impl AssignmentExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ConditionalExpressionId(ExpressionId);
 

	
 
impl ConditionalExpressionId {
 
@@ -303,7 +303,7 @@ impl ConditionalExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct BinaryExpressionId(ExpressionId);
 

	
 
impl BinaryExpressionId {
 
@@ -312,7 +312,7 @@ impl BinaryExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct UnaryExpressionId(ExpressionId);
 

	
 
impl UnaryExpressionId {
 
@@ -321,7 +321,7 @@ impl UnaryExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct IndexingExpressionId(ExpressionId);
 

	
 
impl IndexingExpressionId {
 
@@ -330,7 +330,7 @@ impl IndexingExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct SlicingExpressionId(ExpressionId);
 

	
 
impl SlicingExpressionId {
 
@@ -339,7 +339,7 @@ impl SlicingExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct SelectExpressionId(ExpressionId);
 

	
 
impl SelectExpressionId {
 
@@ -348,7 +348,7 @@ impl SelectExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ArrayExpressionId(ExpressionId);
 

	
 
impl ArrayExpressionId {
 
@@ -357,7 +357,7 @@ impl ArrayExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ConstantExpressionId(ExpressionId);
 

	
 
impl ConstantExpressionId {
 
@@ -366,7 +366,7 @@ impl ConstantExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct CallExpressionId(ExpressionId);
 

	
 
impl CallExpressionId {
 
@@ -375,7 +375,7 @@ impl CallExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct VariableExpressionId(ExpressionId);
 

	
 
impl VariableExpressionId {
 
@@ -384,10 +384,10 @@ impl VariableExpressionId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct DeclarationId(Id<Declaration>);
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct DefinedDeclarationId(DeclarationId);
 

	
 
impl DefinedDeclarationId {
 
@@ -396,7 +396,7 @@ impl DefinedDeclarationId {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, PartialEq, serde::Serialize, serde::Deserialize)]
 
pub struct ImportedDeclarationId(DeclarationId);
 

	
 
impl ImportedDeclarationId {
 
@@ -405,7 +405,7 @@ impl ImportedDeclarationId {
 
    }
 
}
 

	
 
#[derive(serde::Serialize)]
 
#[derive(serde::Serialize, serde::Deserialize)]
 
pub struct Heap {
 
    // Phase 0: allocation
 
    protocol_descriptions: Arena<Root>,
 
@@ -1200,7 +1200,7 @@ impl Index<DeclarationId> for Heap {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Root {
 
    pub this: RootId,
 
    // Phase 1: parser
 
@@ -1245,7 +1245,7 @@ impl SyntaxElement for Root {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Pragma {
 
    pub this: PragmaId,
 
    // Phase 1: parser
 
@@ -1259,7 +1259,7 @@ impl SyntaxElement for Pragma {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Import {
 
    pub this: ImportId,
 
    // Phase 1: parser
 
@@ -1273,7 +1273,7 @@ impl SyntaxElement for Import {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Identifier {
 
    External(ExternalIdentifier),
 
    Source(SourceIdentifier),
 
@@ -1325,7 +1325,7 @@ impl PartialEq<SourceIdentifier> for Identifier {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ExternalIdentifier {
 
    pub this: ExternalIdentifierId,
 
    // Phase 1: parser
 
@@ -1345,7 +1345,7 @@ impl Display for ExternalIdentifier {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct SourceIdentifier {
 
    pub this: SourceIdentifierId,
 
    // Phase 1: parser
 
@@ -1386,7 +1386,7 @@ impl PartialEq<SourceIdentifier> for SourceIdentifier {
 

	
 
type TypeData = Vec<u8>;
 

	
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 
pub enum PrimitiveType {
 
    Input,
 
    Output,
 
@@ -1399,7 +1399,7 @@ pub enum PrimitiveType {
 
    Symbolic(TypeData),
 
}
 

	
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 
pub struct Type {
 
    pub primitive: PrimitiveType,
 
    pub array: bool,
 
@@ -1466,7 +1466,7 @@ impl Display for Type {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct TypeAnnotation {
 
    pub this: TypeAnnotationId,
 
    // Phase 1: parser
 
@@ -1483,7 +1483,7 @@ impl SyntaxElement for TypeAnnotation {
 
type CharacterData = Vec<u8>;
 
type IntegerData = Vec<u8>;
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Constant {
 
    Null, // message
 
    True,
 
@@ -1492,7 +1492,7 @@ pub enum Constant {
 
    Integer(IntegerData),
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Method {
 
    Get,
 
    Fires,
 
@@ -1500,7 +1500,7 @@ pub enum Method {
 
    Symbolic(SourceIdentifierId),
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Field {
 
    Length,
 
    Symbolic(SourceIdentifierId),
 
@@ -1514,7 +1514,7 @@ impl Field {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 
pub enum Scope {
 
    Definition(DefinitionId),
 
    Block(BlockStatementId),
 
@@ -1552,7 +1552,7 @@ impl VariableScope for Scope {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Variable {
 
    Parameter(Parameter),
 
    Local(Local),
 
@@ -1600,7 +1600,7 @@ impl SyntaxElement for Variable {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Parameter {
 
    pub this: ParameterId,
 
    // Phase 1: parser
 
@@ -1615,7 +1615,7 @@ impl SyntaxElement for Parameter {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Local {
 
    pub this: LocalId,
 
    // Phase 1: parser
 
@@ -1629,7 +1629,7 @@ impl SyntaxElement for Local {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Definition {
 
    Component(Component),
 
    Function(Function),
 
@@ -1703,7 +1703,7 @@ impl VariableScope for Definition {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Component {
 
    Composite(Composite),
 
    Primitive(Primitive),
 
@@ -1757,7 +1757,7 @@ impl SyntaxElement for Component {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Composite {
 
    pub this: CompositeId,
 
    // Phase 1: parser
 
@@ -1773,7 +1773,7 @@ impl SyntaxElement for Composite {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Primitive {
 
    pub this: PrimitiveId,
 
    // Phase 1: parser
 
@@ -1789,7 +1789,7 @@ impl SyntaxElement for Primitive {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct Function {
 
    pub this: FunctionId,
 
    // Phase 1: parser
 
@@ -1806,7 +1806,7 @@ impl SyntaxElement for Function {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Declaration {
 
    Defined(DefinedDeclaration),
 
    Imported(ImportedDeclaration),
 
@@ -1836,7 +1836,7 @@ impl Declaration {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct DefinedDeclaration {
 
    pub this: DefinedDeclarationId,
 
    // Phase 2: linker
 
@@ -1844,7 +1844,7 @@ pub struct DefinedDeclaration {
 
    pub signature: Signature,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ImportedDeclaration {
 
    pub this: ImportedDeclarationId,
 
    // Phase 2: linker
 
@@ -1852,7 +1852,7 @@ pub struct ImportedDeclaration {
 
    pub signature: Signature,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Signature {
 
    Component(ComponentSignature),
 
    Function(FunctionSignature),
 
@@ -1899,20 +1899,20 @@ impl Signature {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ComponentSignature {
 
    pub identifier: IdentifierId,
 
    pub arity: Vec<Type>,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct FunctionSignature {
 
    pub return_type: Type,
 
    pub identifier: IdentifierId,
 
    pub arity: Vec<Type>,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Statement {
 
    Block(BlockStatement),
 
    Local(LocalStatement),
 
@@ -2149,7 +2149,7 @@ impl SyntaxElement for Statement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct BlockStatement {
 
    pub this: BlockStatementId,
 
    // Phase 1: parser
 
@@ -2210,7 +2210,7 @@ impl VariableScope for BlockStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum LocalStatement {
 
    Memory(MemoryStatement),
 
    Channel(ChannelStatement),
 
@@ -2252,7 +2252,7 @@ impl SyntaxElement for LocalStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct MemoryStatement {
 
    pub this: MemoryStatementId,
 
    // Phase 1: parser
 
@@ -2269,7 +2269,7 @@ impl SyntaxElement for MemoryStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ChannelStatement {
 
    pub this: ChannelStatementId,
 
    // Phase 1: parser
 
@@ -2286,7 +2286,7 @@ impl SyntaxElement for ChannelStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct SkipStatement {
 
    pub this: SkipStatementId,
 
    // Phase 1: parser
 
@@ -2301,7 +2301,7 @@ impl SyntaxElement for SkipStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct LabeledStatement {
 
    pub this: LabeledStatementId,
 
    // Phase 1: parser
 
@@ -2318,7 +2318,7 @@ impl SyntaxElement for LabeledStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct IfStatement {
 
    pub this: IfStatementId,
 
    // Phase 1: parser
 
@@ -2334,7 +2334,7 @@ impl SyntaxElement for IfStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct EndIfStatement {
 
    pub this: EndIfStatementId,
 
    // Phase 2: linker
 
@@ -2348,7 +2348,7 @@ impl SyntaxElement for EndIfStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct WhileStatement {
 
    pub this: WhileStatementId,
 
    // Phase 1: parser
 
@@ -2366,7 +2366,7 @@ impl SyntaxElement for WhileStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct EndWhileStatement {
 
    pub this: EndWhileStatementId,
 
    // Phase 2: linker
 
@@ -2380,7 +2380,7 @@ impl SyntaxElement for EndWhileStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct BreakStatement {
 
    pub this: BreakStatementId,
 
    // Phase 1: parser
 
@@ -2396,7 +2396,7 @@ impl SyntaxElement for BreakStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ContinueStatement {
 
    pub this: ContinueStatementId,
 
    // Phase 1: parser
 
@@ -2412,7 +2412,7 @@ impl SyntaxElement for ContinueStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct SynchronousStatement {
 
    pub this: SynchronousStatementId,
 
    // Phase 1: parser
 
@@ -2443,7 +2443,7 @@ impl VariableScope for SynchronousStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct EndSynchronousStatement {
 
    pub this: EndSynchronousStatementId,
 
    // Phase 2: linker
 
@@ -2457,7 +2457,7 @@ impl SyntaxElement for EndSynchronousStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ReturnStatement {
 
    pub this: ReturnStatementId,
 
    // Phase 1: parser
 
@@ -2471,7 +2471,7 @@ impl SyntaxElement for ReturnStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct AssertStatement {
 
    pub this: AssertStatementId,
 
    // Phase 1: parser
 
@@ -2487,7 +2487,7 @@ impl SyntaxElement for AssertStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct GotoStatement {
 
    pub this: GotoStatementId,
 
    // Phase 1: parser
 
@@ -2503,7 +2503,7 @@ impl SyntaxElement for GotoStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct NewStatement {
 
    pub this: NewStatementId,
 
    // Phase 1: parser
 
@@ -2519,7 +2519,7 @@ impl SyntaxElement for NewStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct PutStatement {
 
    pub this: PutStatementId,
 
    // Phase 1: parser
 
@@ -2536,7 +2536,7 @@ impl SyntaxElement for PutStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ExpressionStatement {
 
    pub this: ExpressionStatementId,
 
    // Phase 1: parser
 
@@ -2552,7 +2552,7 @@ impl SyntaxElement for ExpressionStatement {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum Expression {
 
    Assignment(AssignmentExpression),
 
    Conditional(ConditionalExpression),
 
@@ -2666,7 +2666,7 @@ impl SyntaxElement for Expression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub enum AssignmentOperator {
 
    Set,
 
    Multiplied,
 
@@ -2681,7 +2681,7 @@ pub enum AssignmentOperator {
 
    BitwiseOred,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct AssignmentExpression {
 
    pub this: AssignmentExpressionId,
 
    // Phase 1: parser
 
@@ -2697,7 +2697,7 @@ impl SyntaxElement for AssignmentExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ConditionalExpression {
 
    pub this: ConditionalExpressionId,
 
    // Phase 1: parser
 
@@ -2713,7 +2713,7 @@ impl SyntaxElement for ConditionalExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 
pub enum BinaryOperator {
 
    Concatenate,
 
    LogicalOr,
 
@@ -2736,7 +2736,7 @@ pub enum BinaryOperator {
 
    Remainder,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct BinaryExpression {
 
    pub this: BinaryExpressionId,
 
    // Phase 1: parser
 
@@ -2752,7 +2752,7 @@ impl SyntaxElement for BinaryExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
 
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 
pub enum UnaryOperation {
 
    Positive,
 
    Negative,
 
@@ -2764,7 +2764,7 @@ pub enum UnaryOperation {
 
    PostDecrement,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct UnaryExpression {
 
    pub this: UnaryExpressionId,
 
    // Phase 1: parser
 
@@ -2779,7 +2779,7 @@ impl SyntaxElement for UnaryExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct IndexingExpression {
 
    pub this: IndexingExpressionId,
 
    // Phase 1: parser
 
@@ -2794,7 +2794,7 @@ impl SyntaxElement for IndexingExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct SlicingExpression {
 
    pub this: SlicingExpressionId,
 
    // Phase 1: parser
 
@@ -2810,7 +2810,7 @@ impl SyntaxElement for SlicingExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct SelectExpression {
 
    pub this: SelectExpressionId,
 
    // Phase 1: parser
 
@@ -2825,7 +2825,7 @@ impl SyntaxElement for SelectExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ArrayExpression {
 
    pub this: ArrayExpressionId,
 
    // Phase 1: parser
 
@@ -2839,7 +2839,7 @@ impl SyntaxElement for ArrayExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct CallExpression {
 
    pub this: CallExpressionId,
 
    // Phase 1: parser
 
@@ -2856,7 +2856,7 @@ impl SyntaxElement for CallExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct ConstantExpression {
 
    pub this: ConstantExpressionId,
 
    // Phase 1: parser
 
@@ -2870,7 +2870,7 @@ impl SyntaxElement for ConstantExpression {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize)]
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
pub struct VariableExpression {
 
    pub this: VariableExpressionId,
 
    // Phase 1: parser
src/protocol/inputsource.rs
Show inline comments
 
@@ -5,7 +5,7 @@ use std::path::Path;
 

	
 
use backtrace::Backtrace;
 

	
 
#[derive(Clone, serde::Serialize)]
 
#[derive(Clone, serde::Serialize, serde::Deserialize)]
 
pub struct InputSource {
 
    filename: String,
 
    input: Vec<u8>,
 
@@ -120,7 +120,7 @@ impl fmt::Display for InputSource {
 
    }
 
}
 

	
 
#[derive(Debug, Clone, Copy, Default, serde::Serialize)]
 
#[derive(Debug, Clone, Copy, Default, serde::Serialize, serde::Deserialize)]
 
pub struct InputPosition {
 
    line: usize,
 
    column: usize,
src/protocol/mod.rs
Show inline comments
 
@@ -12,7 +12,7 @@ use crate::protocol::eval::*;
 
use crate::protocol::inputsource::*;
 
use crate::protocol::parser::*;
 

	
 
#[derive(serde::Serialize)]
 
#[derive(serde::Serialize, serde::Deserialize)]
 
pub struct ProtocolDescriptionImpl {
 
    heap: Heap,
 
    source: InputSource,
 
@@ -82,6 +82,7 @@ impl ProtocolDescription for ProtocolDescriptionImpl {
 
        }
 
        Ok(result)
 
    }
 
    // expects port polarities to be correct
 
    fn new_main_component(&self, identifier: &[u8], ports: &[Port]) -> ComponentStateImpl {
 
        let mut args = Vec::new();
 
        for (&x, y) in ports.iter().zip(self.component_polarities(identifier).unwrap()) {
src/runtime/experimental/mod.rs
Show inline comments
 
mod api;
 
mod bits;
 
mod vec_storage;
 
// mod api;
 
// mod bits;
 
mod pdl;
 
// mod vec_storage;
src/runtime/experimental/pdl.rs
Show inline comments
 
new file 100644
 
use crate::common::Port;
 

	
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
struct Pdl {
 
    ops: Vec<Op>,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
enum Op {
 
    JumpIfEq,  //
 
    SyncStart, //
 
    SyncEnd,   //
 
    Exit,      //
 
    Firing,    // pop port A. push bool B.
 
    Put,       // pop port A. pop payload B.
 
    Get,       // pop port A. push payload B.
 
    //
 
    PushConst(Value),
 
    Store, // pop unslong A. pop B. store[A] := B.
 
    Load,  // pop unslong A. push store[A].
 
    Dup,   // pop A. push A. push A.
 
    //
 
    Lt,  // pop A. pop B. push bool C.
 
    Eq,  // pop A. pop B. push bool C.
 
    Add, // pop integer A. pop integer B. push A+B
 
    Neg, // pop signed integer A. push -A.
 
    //
 
    Nand, // pop bool A. pop bool B. push nand(A,B)
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
struct State {
 
    op_index: usize,
 
    store: Vec<Value>, // TODO multiple frames
 
    stack: Vec<Value>,
 
}
 

	
 
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 
enum Value {
 
    Null,
 
    Int(i32),
 
    Bool(bool),
 
    UnsLong(u64),
 
    Payload(Vec<u8>),
 
    Port(Port),
 
}
src/runtime/mod.rs
Show inline comments
 
@@ -6,9 +6,9 @@ pub(crate) mod communication;
 
pub(crate) mod connector;
 
pub(crate) mod endpoint;
 
pub mod errors;
 
// pub mod experimental;
 
mod serde;
 
pub(crate) mod setup;
 
// mod v2;
 

	
 
pub(crate) type ProtocolD = crate::protocol::ProtocolDescriptionImpl;
 
pub(crate) type ProtocolS = crate::protocol::ComponentStateImpl;
 
@@ -42,7 +42,7 @@ struct SyncBatch {
 
pub enum Connector {
 
    Unconfigured(Unconfigured),
 
    Configured(Configured),
 
    Connected(Connected), // TODO consider boxing. currently takes up a lot of stack real estate
 
    Connected(Connected), // TODO consider boxing. currently takes up a lot of stack space
 
}
 
#[derive(Debug)]
 
pub struct Unconfigured {
src/runtime/v2.rs
Show inline comments
 
new file 100644
 
use crate::common::*;
 
use crate::runtime::endpoint::Endpoint;
 
use crate::runtime::endpoint::Msg;
 
use crate::runtime::ProtocolD;
 
use crate::runtime::ProtocolS;
 
use std::io::Write;
 

	
 
#[derive(Default)]
 
struct IntStream {
 
    next: u32,
 
}
 
struct IdManager {
 
    controller_id: ControllerId,
 
    port_suffix_stream: IntStream,
 
}
 

	
 
struct ProtoComponent {
 
    state: ProtocolS,
 
    ports: HashSet<PortId>,
 
}
 
enum InpRoute {
 
    NativeComponent,
 
    ProtoComponent { index: usize },
 
    Endpoint { index: usize },
 
}
 
trait Logger {
 
    fn line_writer(&mut self) -> &mut dyn Write;
 
}
 
#[derive(Clone)]
 
struct EndpointSetup {
 
    polarity: Polarity,
 
    sock_addr: SocketAddr,
 
    is_active: bool,
 
}
 
struct EndpointExt {
 
    net_endpoint: Endpoint,
 
    // data-messages emerging from this endpoint are destined for this inp
 
    inp: Port,
 
}
 
struct Neighborhood {
 
    parent: Option<usize>,
 
    children: Vec<usize>, // ordered, deduplicated
 
}
 
struct MemInMsg {
 
    inp: Port,
 
    msg: Payload,
 
}
 
struct EndpointPoller {
 
    poll: Poll,
 
    events: Events,
 
    undrained_endpoints: HashSet<usize>,
 
    delayed_inp_messages: Vec<(Port, Msg)>,
 
}
 
struct Connector {
 
    logger: Box<dyn Logger>,
 
    proto_description: Arc<ProtocolD>,
 
    id_manager: IdManager,
 
    native_ports: HashSet<PortId>,
 
    proto_components: Vec<ProtoComponent>,
 
    outp_to_inp: HashMap<PortId, PortId>,
 
    inp_to_route: HashMap<PortId, InpRoute>,
 
    phased: ConnectorPhased,
 
}
 
enum ConnectorPhased {
 
    Setup {
 
        endpoint_setups: Vec<(PortId, EndpointSetup)>,
 
        surplus_sockets: u16,
 
    },
 
    Communication {
 
        endpoint_poller: EndpointPoller,
 
        endpoint_exts: Vec<EndpointExt>,
 
        neighborhood: Neighborhood,
 
        mem_inbox: Vec<MemInMsg>,
 
    },
 
}
 
/////////////////////////////
 
impl IntStream {
 
    fn next(&mut self) -> u32 {
 
        if self.next == u32::MAX {
 
            panic!("NO NEXT!")
 
        }
 
        self.next += 1;
 
        self.next - 1
 
    }
 
}
 
impl IdManager {
 
    fn next_port(&mut self) -> PortId {
 
        let port_suffix = self.port_suffix_stream.next();
 
        let controller_id = self.controller_id;
 
        PortId { controller_id, port_index: port_suffix }
 
    }
 
    fn new(controller_id: ControllerId) -> Self {
 
        Self { controller_id, port_suffix_stream: Default::default() }
 
    }
 
}
 
impl Connector {
 
    pub fn new(
 
        logger: Box<dyn Logger>,
 
        proto_description: Arc<ProtocolD>,
 
        controller_id: ControllerId,
 
        surplus_sockets: u16,
 
    ) -> Self {
 
        Self {
 
            logger,
 
            proto_description,
 
            id_manager: IdManager::new(controller_id),
 
            native_ports: Default::default(),
 
            proto_components: Default::default(),
 
            outp_to_inp: Default::default(),
 
            inp_to_route: Default::default(),
 
            phased: ConnectorPhased::Setup { endpoint_setups: Default::default(), surplus_sockets },
 
        }
 
    }
 
    pub fn add_port_pair(&mut self) -> [PortId; 2] {
 
        let o = self.id_manager.next_port();
 
        let i = self.id_manager.next_port();
 
        self.outp_to_inp.insert(o, i);
 
        self.native_ports.insert(o);
 
        self.native_ports.insert(i);
 
        [o, i]
 
    }
 
    pub fn add_net_port(&mut self, endpoint_setup: EndpointSetup) -> Result<PortId, ()> {
 
        match &mut self.phased {
 
            ConnectorPhased::Setup { endpoint_setups, .. } => {
 
                let p = self.id_manager.next_port();
 
                endpoint_setups.push((p, endpoint_setup));
 
                Ok(p)
 
            }
 
            ConnectorPhased::Communication { .. } => Err(()),
 
        }
 
    }
 
    fn check_polarity(&self, port: &PortId) -> Polarity {
 
        if self.outp_to_inp.contains_key(port) {
 
            Polarity::Putter
 
        } else {
 
            assert!(self.inp_to_route.contains_key(port));
 
            Polarity::Getter
 
        }
 
    }
 
    pub fn add_proto_component(&mut self, identifier: &[u8], ports: &[PortId]) -> Result<(), ()> {
 
        let polarities = self.proto_description.component_polarities(identifier).map_err(drop)?;
 
        if polarities.len() != ports.len() {
 
            return Err(());
 
        }
 
        for (&expected_polarity, port) in polarities.iter().zip(ports.iter()) {
 
            if !self.native_ports.contains(port) {
 
                return Err(());
 
            }
 
            if expected_polarity != self.check_polarity(port) {
 
                return Err(());
 
            }
 
        }
 
        // ok!
 
        let state = self.proto_description.new_main_component(identifier, ports);
 
        let proto_component = ProtoComponent { ports: ports.iter().copied().collect(), state };
 
        let proto_component_index = self.proto_components.len();
 
        self.proto_components.push(proto_component);
 
        for port in ports.iter() {
 
            if let Polarity::Getter = self.check_polarity(port) {
 
                self.inp_to_route
 
                    .insert(*port, InpRoute::ProtoComponent { index: proto_component_index });
 
            }
 
        }
 
        Ok(())
 
    }
 
    pub fn connect(&mut self, timeout: Duration) -> Result<(), ()> {
 
        match &mut self.phased {
 
            ConnectorPhased::Communication { .. } => Err(()),
 
            ConnectorPhased::Setup { endpoint_setups, surplus_sockets } => {
 
                // connect all endpoints in parallel; send and receive peer ids through ports
 
                let (mut endpoint_exts, mut endpoint_poller) =
 
                    init_endpoints(endpoint_setups, timeout)?;
 
                write!(
 
                    self.logger.line_writer(),
 
                    "hello! I am controller_id:{}",
 
                    self.id_manager.controller_id
 
                );
 
                // leader election and tree construction
 
                let neighborhood = init_neighborhood(&mut endpoint_exts, &mut endpoint_poller)?;
 
                // TODO session optimization goes here
 
                self.phased = ConnectorPhased::Communication {
 
                    endpoint_poller,
 
                    endpoint_exts,
 
                    neighborhood,
 
                    mem_inbox: Default::default(),
 
                };
 
                Ok(())
 
            }
 
        }
 
    }
 
}
 

	
 
fn init_endpoints(
 
    endpoint_setups: &[(PortId, EndpointSetup)],
 
    timeout: Duration,
 
) -> Result<(Vec<EndpointExt>, EndpointPoller), ()> {
 
    let mut endpoint_poller = EndpointPoller {
 
        poll: Poll::new().map_err(drop)?,
 
        events: Events::with_capacity(64),
 
        undrained_endpoints: Default::default(),
 
        delayed_inp_messages: Default::default(),
 
    };
 
    const PORT_ID_LEN: usize = std::mem::size_of::<PortId>();
 
    enum MaybeRecvPort {
 
        Complete(Port),
 
        Partial { buf: [u8; PORT_ID_LEN], read: u8 },
 
    }
 
    struct Todo {
 
        endpoint: TodoEndpoint,
 
        polarity: Polarity,
 
        local_port: Port,
 
        sent_local_port: bool,
 
        recv_peer_port: MaybeRecvPort,
 
    }
 
    enum TodoEndpoint {
 
        Listener(mio::net::TcpListener),
 
        Stream(mio::net::TcpStream),
 
    }
 
    const BOTH: mio::Interest = mio::Interest::READABLE.add(mio::Interest::WRITABLE);
 
    fn init(
 
        token: Token,
 
        local_port: Port,
 
        endpoint_setup: &EndpointSetup,
 
        poll: &mut Poll,
 
    ) -> Result<Todo, ()> {
 
        let endpoint = if endpoint_setup.is_active {
 
            let mut stream =
 
                mio::net::TcpStream::connect(&endpoint_setup.sock_addr).map_err(drop)?;
 
            poll.registry().register(&mut stream, token, BOTH).unwrap();
 
            TodoEndpoint::Stream(stream)
 
        } else {
 
            let mut listener =
 
                mio::net::TcpListener::bind(&endpoint_setup.sock_addr).map_err(drop)?;
 
            poll.registry().register(&mut listener, token, BOTH).unwrap();
 
            TodoEndpoint::Listener(listener)
 
        };
 
        Ok(Todo {
 
            endpoint,
 
            endpoint_setup: endpoint_setup.clone(),
 
            local_port,
 
            sent_local_port: false,
 
            recv_peer_port: MaybeRecvPort::Partial { buf: [0; 8], read: 0 },
 
        })
 
    };
 

	
 
    let todos = endpoint_setups
 
        .iter()
 
        .enumerate()
 
        .map(|(index, (local_port, endpoint_setup))| {
 
            init(Token(index), local_port, endpoint_setup, &mut endpoint_poller.poll)
 
        })
 
        .collect::<Result<Vec<Todo>, _>>()?;
 
    let endpoint_exts = vec![];
 
    Ok((endpoint_exts, endpoint_poller))
 
}
 

	
 
fn init_neighborhood(
 
    endpoint_exts: &mut [EndpointExt],
 
    endpoint_poller: &mut EndpointPoller,
 
) -> Result<Neighborhood, ()> {
 
    todo!()
 
}
0 comments (0 inline, 0 general)