crate-type = ["cdylib"]

[features]

ffi = [] # no feature dependencies

    pub(crate) connector_id: ConnectorId,

    pub(crate) u32_suffix: PortSuffix,

}

pub struct U32Stream {

    next: u32,

}

    Active,  // calls connect()

    Passive, // calls bind() listen() accept()

}

#[derive(Debug, Clone)]

pub(crate) enum NonsyncBlocker {

    Inconsistent,

        write!(f, "ptID({}'{})", self.0.connector_id, self.0.u32_suffix)

    }

}

impl Debug for ProtoComponentId {

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

        write!(f, "pcID({}'{})", self.0.connector_id, self.0.u32_suffix)

            comm.round_index

        );

        // 1. run all proto components to Nonsync blockers

        let mut branching_proto_components =

            HashMap::<ProtoComponentId, BranchingProtoComponent>::default();

            "Translating {} native batches into branches...",

            comm.native_batches.len()

        );

        let mut branching_native = BranchingNative { branches: Default::default() };

        {

            let predicate = {

                // assign trues for ports that fire

                let firing_ports: HashSet<PortId> =

                    to_get.iter().chain(to_put.keys()).copied().collect();

                for &port in to_get.iter().chain(to_put.keys()) {

                }

                // assign falses for silent ports

                for &port in cu.native_ports.difference(&firing_ports) {

                        log!(cu.logger, "Native branch index={} contains internal inconsistency wrt. {:?}. Skipping", index, var);

                        continue 'native_branches;

                    }

                );

            }

            let branch = NativeBranch { index, gotten: Default::default(), to_get };

            }

        }

        // restore the invariant

        for (predicate, mut branch) in draining.drain() {

            log!(cu.logger, "visiting native branch {:?} with {:?}", &branch, &predicate);

            // check if this branch expects to receive it

            let mut feed_branch = |branch: &mut NativeBranch, predicate: &Predicate| {

                let was = branch.gotten.insert(getter, send_payload_msg.payload.clone());

                assert!(was.is_none());

                    );

                }

            };

                // optimization. Don't bother trying this branch

                log!(

                    cu.logger,

                finished.insert(predicate, branch);

                continue;

            }

                    // this branch does not receive the message

                    log!(

                        cu.logger,

                    );

                    finished.insert(predicate, branch);

                }

                    // retain the existing predicate, but add this payload

                    feed_branch(&mut branch, &predicate);

                    log!(cu.logger, "branch pred covers it! Accept the msg");

                    finished.insert(predicate, branch);

                }

                    // fork branch, give fork the message and payload predicate. original branch untouched

                    let mut branch2 = branch.clone();

                    let predicate2 = send_payload_msg.predicate.clone();

                    finished.insert(predicate, branch);

                    finished.insert(predicate2, branch2);

                }

                    // fork branch, give fork the message and the new predicate. original branch untouched

                    let mut branch2 = branch.clone();

                    feed_branch(&mut branch2, &predicate2);

            self.branches.keys()

        );

        for (branch_predicate, branch) in self.branches {

                let NativeBranch { index, gotten, .. } = branch;

                log!(logger, "Collapsed native has gotten {:?}", &gotten);

                return RoundOk { batch_index: index, gotten };

                B::SyncBlockEnd => {

                    // make concrete all variables

                    for &port in ports.iter() {

                    }

                    // submit solution for this component

                    solution_storage.submit_and_digest_subtree_solution(

                }

                B::CouldntCheckFiring(port) => {

                    // sanity check

                    assert!(predicate.query(var).is_none());

                    // keep forks in "unblocked"

                }

                B::PutMsg(putter, payload) => {

                    // sanity check

                    assert_eq!(Some(&Putter), cu.port_info.polarities.get(&putter));

                    // overwrite assignment

                        log!(cu.logger, "Proto component {:?} tried to PUT on port {:?} when pred said var {:?}==Some(false). inconsistent!", proto_component_id, putter, var);

                        // discard forever

                        drop((predicate, branch));

                blocked.insert(predicate, branch);

                continue;

            }

            log!(logger, "visiting branch with pred {:?}", &predicate);

                    // this branch does not receive the message

                    log!(logger, "skipping branch");

                    blocked.insert(predicate, branch);

                }

                    // retain the existing predicate, but add this payload

                    log!(logger, "feeding this branch without altering its predicate");

                    branch.feed_msg(getter, send_payload_msg.payload.clone());

                    unblocked.insert(predicate, branch);

                }

                    // fork branch, give fork the message and payload predicate. original branch untouched

                    log!(logger, "Forking this branch, giving it the predicate of the msg");

                    let mut branch2 = branch.clone();

                    blocked.insert(predicate, branch);

                    unblocked.insert(predicate2, branch2);

                }

                    // fork branch, give fork the message and the new predicate. original branch untouched

                    log!(logger, "Forking this branch with new predicate {:?}", &predicate2);

                    let mut branch2 = branch.clone();

    fn collapse_with(self, solution_predicate: &Predicate) -> ProtoComponent {

        let BranchingProtoComponent { ports, branches } = self;

        for (branch_predicate, branch) in branches {

                let ProtoComponentBranch { state, .. } = branch;

                return ProtoComponent { state, ports };

            }

}

impl SyncProtoContext<'_> {

    pub(crate) fn is_firing(&mut self, port: PortId) -> Option<bool> {

    }

    pub(crate) fn read_msg(&mut self, port: PortId) -> Option<&Payload> {

        self.inbox.get(&port)

    port_info: &'a PortInfo,

    inbox: &'a HashMap<PortId, Payload>,

}

#[derive(Debug)]

struct RoundOk {

    batch_index: usize,

    payload: Payload,

}

#[derive(Debug, PartialEq)]

    FormerNotLatter,

    LatterNotFormer,

    Equivalent,

    proto_component_suffix_stream: U32Stream,

}

#[derive(Debug)]

struct EndpointManager {

    // invariants:

    // 1. endpoint N is registered READ | WRITE with poller

}

#[derive(Default, Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]

struct Predicate {

}

#[derive(Debug, Default)]

struct NativeBatch {

    }

}

impl PortInfo {

            Getter => port,

            Putter => *self.peers.get(&port).unwrap(),

        })

    }

}

impl IdManager {

    fn new(connector_id: ConnectorId) -> Self {

        Self {

            proto_component_suffix_stream: Default::default(),

        }

    }

    fn new_port_id(&mut self) -> PortId {

        Id { connector_id: self.connector_id, u32_suffix: self.port_suffix_stream.next() }.into()

    }

}

impl Predicate {

    #[inline]

        self.assigned.insert(k, v);

        self

    }

    // returns true IFF self.unify would return Equivalent OR FormerNotLatter

            }

        }

        true

    /// If the resulting predicate is equivlanet to self, other, or both,

    /// FormerNotLatter, LatterNotFormer and Equivalent are returned respectively.

    /// otherwise New(N) is returned.

        // iterators over assignments of both predicates. Rely on SORTED ordering of BTreeMap's keys.

        let [mut s_it, mut o_it] = [self.assigned.iter(), other.assigned.iter()];

        let [mut s, mut o] = [s_it.next(), o_it.next()];

                    } else if sb != ob {

                        assert_eq!(sid, oid);

                        // both predicates assign the variable but differ on the value

                    } else {

                        // both predicates assign the variable to the same value

                        s = s_it.next();

        }

        // Observed zero inconsistencies. A unified predicate exists...

        match [s_not_o.is_empty(), o_not_s.is_empty()] {

            [false, false] => {

                // ... which is the union of the predicates' assignments but

                //     is equivalent to neither self nor other.

                for (&id, &b) in o_not_s {

                    new.assigned.insert(id, b);

                }

            }

        }

    }

        }

        Some(res)

    }

        self.assigned.get(&var).copied()

    }

}

}

impl Debug for Predicate {

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

    }

}

impl serde::Serialize for SerdeProtocolDescription {

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

    }

}

}

                    native_batches: vec![Default::default()],

                    round_result: Ok(None),

                };

                log!(cu.logger, "connect() finished. setup phase complete");

                self.phased = ConnectorPhased::Communication(Box::new(comm));

                Ok(())

    })

    .unwrap();

}