return !self.first.is_valid();

    }

}

const NUM_QUEUES: usize = 3;

pub(crate) enum QueueKind {

    Runnable,

    AwaitingMessage,

    FinishedSync,

}

    pub fn queue_is_empty(&self, kind: QueueKind) -> bool {

        return self.queues[kind.as_index()].is_empty();

    }

    /// Pops a branch (ID) from a queue.

    pub fn pop_from_queue(&mut self, kind: QueueKind) -> Option<BranchId> {

        let queue = &mut self.queues[kind.as_index()];

        if queue.is_empty() {

            return None;

        } else {

            let first_branch = &mut self.branches[queue.first.index as usize];

            queue.first = first_branch.next_in_queue;

    /// Returns the non-sync branch (TODO: better name?)

    pub fn base_branch_mut(&mut self) -> &mut Branch {

        debug_assert!(!self.is_in_sync());

        return &mut self.branches[0];

    }

        let queue = &self.queues[kind.as_index()];

        return BranchQueueIter {

            branches: self.branches.as_slice(),

            index,

        }

    }

/// connector.rs

///

/// Represents a component. A component (and the scheduler that is running it)

/// has many properties that are not easy to subdivide into aspects that are

/// conceptually handled by particular data structures. That is to say: the code

/// that we run governs: running PDL code, keeping track of ports, instantiating

#[derive(Eq, PartialEq)]

pub(crate) enum ConnectorScheduling {

    Immediate,      // Run again, immediately

    Later,          // Schedule for running, at some later point in time

    NotNow,         // Do not reschedule for running

}

pub(crate) struct ConnectorPDL {

    tree: ExecTree,

    consensus: Consensus,

}

impl RunContext for ConnectorRunContext{

    fn did_put(&mut self, port: PortId) -> bool {

    }

    fn get(&mut self, port: PortId) -> Option<ValueGroup> {

    }

    fn fires(&mut self, port: PortId) -> Option<Value> {

    }

    fn get_channel(&mut self) -> Option<(Value, Value)> {

    }

}

impl Connector for ConnectorPDL {

    fn run(&mut self, sched_ctx: SchedulerCtx, comp_ctx: &mut ComponentCtxFancy) -> ConnectorScheduling {

    }

}

impl ConnectorPDL {

    pub fn new(initial: ComponentState) -> Self {

        Self{

        self.consensus.handle_received_sync_header(&message.sync_header, ctx);

        todo!("handle content of message?");

    }

    // --- Running code

        // Check if we have any branch that needs running

        debug_assert!(self.tree.is_in_sync() && self.consensus.is_in_sync());

        let branch_id = self.tree.pop_from_queue(QueueKind::Runnable);

        if branch_id.is_none() {

            return ConnectorScheduling::NotNow;

        }

        // Retrieve the branch and run it

        let branch_id = branch_id.unwrap();

        let branch = &mut self.tree[branch_id];

        let run_result = branch.code_state.run(&mut run_context, &sched_ctx.runtime.protocol_description);

        // Handle the returned result. Note that this match statement contains

        // explicit returns in case the run result requires that the component's

        // code is ran again immediately

        match run_result {

            return ConnectorScheduling::NotNow;

        } else {

            return ConnectorScheduling::Later;

        }

    }

        debug_assert!(!self.tree.is_in_sync() && !self.consensus.is_in_sync());

        let branch = self.tree.base_branch_mut();

        debug_assert!(branch.sync_state == SpeculativeState::RunningNonSync);

        let run_result = branch.code_state.run(&mut run_context, &sched_ctx.runtime.protocol_description);

        match run_result {

            RunResult::ComponentTerminated => {

                branch.sync_state = SpeculativeState::Finished;

use crate::protocol::eval::ValueGroup;

use crate::runtime2::branch::{BranchId, ExecTree, QueueKind};

use crate::runtime2::ConnectorId;

use crate::runtime2::inbox2::{DataHeader, SyncHeader};

use crate::runtime2::port::{Port, PortIdLocal};

use crate::runtime2::scheduler::ComponentCtxFancy;

///

/// The type itself serves as an experiment to see how code should be organized.

// TODO: Flatten all datastructures

// TODO: Have a "branch+port position hint" in case multiple operations are

//  performed on the same port to prevent repeated lookups

pub(crate) struct Consensus {

    highest_connector_id: ConnectorId,

    branch_annotations: Vec<BranchAnnotation>,

    workspace_ports: Vec<PortIdLocal>,

}

#[derive(Clone, Copy, PartialEq, Eq)]

pub(crate) enum Consistency {

    Valid,

impl Consensus {

    pub fn new() -> Self {

        return Self {

            highest_connector_id: ConnectorId::new_invalid(),

            branch_annotations: Vec::new(),

        }

    }

    // --- Controlling sync round and branches

    /// Returns whether the consensus algorithm is running in sync mode

    pub fn is_in_sync(&self) -> bool {

        return !self.branch_annotations.is_empty();

    }

    /// Sets up the consensus algorithm for a new synchronous round. The

    /// provided ports should be the ports the component owns at the start of

    /// the sync round.

    pub fn start_sync(&mut self, ports: &[Port]) {

        debug_assert!(self.branch_annotations.is_empty());

        debug_assert!(!self.highest_connector_id.is_valid());

        };

        self.branch_annotations.push(new_branch_annotations);

    }

    /// Notifies the consensus algorithm that a branch has reached the end of

    /// the sync block. A final check for consistency will be performed that the

    pub fn notify_of_finished_branch(&self, branch_id: BranchId) -> Consistency {

        let branch = &self.branch_annotations[branch_id.index as usize];

        for mapping in &branch.port_mapping {

            match mapping.expected_firing {

                Some(expected) => {

                    if expected != mapping.registered_id.is_some() {

                        // Inconsistent speculative state and actual state

        return Consistency::Valid;

    }

    /// Notifies the consensus algorithm that a particular branch has assumed

    /// a speculative value for its port mapping.

    pub fn notify_of_speculative_mapping(&mut self, branch_id: BranchId, port_id: PortIdLocal, does_fire: bool) -> Consistency {

        let branch = &mut self.branch_annotations[branch_id.index as usize];

        for mapping in &mut branch.port_mapping {

            if mapping.port_id == port_id {

                match mapping.expected_firing {

                    None => {

                        // Not yet mapped, perform speculative mapping

            }

        }

        unreachable!("notify_of_speculative_mapping called with unowned port");

    }

    pub fn end_sync(&mut self, branch_id: BranchId, final_ports: &mut Vec<PortIdLocal>) {

    }

    // --- Handling messages

    /// Prepares a message for sending. Caller should have made sure that

    /// sending the message is consistent with the speculative state.

    /// execution tree to see which branches may receive the data message's

    /// contents.

    ///

    /// This function is generally called for freshly received messages that

    /// should be matched against previously halted branches.

    pub fn handle_received_data_header(&mut self, exec_tree: &ExecTree, data_header: &DataHeader, target_ids: &mut Vec<BranchId>) {

            if branch.awaiting_port == data_header.target_port {

                // Found a branch awaiting the message, but we need to make sure

                // the mapping is correct

                if self.branch_can_receive(branch.id, data_header) {

                    target_ids.push(branch.id);

                }