match self.phased {

            ConnectorPhased::Setup(..) => false,

            ConnectorPhased::Communication(..) => true,

        }

    }

    /// Enables the connector's current logger to be swapped out for another

    pub fn swap_logger(&mut self, mut new_logger: Box<dyn Logger>) -> Box<dyn Logger> {

        std::mem::swap(&mut self.unphased.logger, &mut new_logger);

        new_logger

    }

    /// Access the connector's current logger

    pub fn get_logger(&mut self) -> &mut dyn Logger {

        &mut *self.unphased.logger

    }

    /// Create a new synchronous channel, returning its ends as a pair of ports,

    /// with polarity output, input respectively. Available during either setup/communication phase.

    /// # Panics

    /// This function panics if the connector's (large) port id space is exhausted.

    pub fn new_port_pair(&mut self) -> [PortId; 2] {

        let cu = &mut self.unphased;

        // adds two new associated ports, related to each other, and exposed to the native

        let mut new_cid = || cu.ips.id_manager.new_port_id();

        // allocate two fresh port identifiers

        let [o, i] = [new_cid(), new_cid()];

        // store info for each:

        // - they are each others' peers

        // - they are owned by a local component with id `cid`

        // - polarity putter, getter respectively

        cu.ips.port_info.map.insert(

            o,

            PortInfo {

                route: Route::LocalComponent,

                peer: Some(i),

                owner: cu.native_component_id,

                polarity: Putter,

            },

        );

        cu.ips.port_info.map.insert(

            i,

            PortInfo {

                route: Route::LocalComponent,

                peer: Some(o),

                owner: cu.native_component_id,

                polarity: Getter,

            },

        );

        cu.ips

            .port_info

            .owned

            .entry(cu.native_component_id)

            .or_default()

            .extend([o, i].iter().copied());

        log!(cu.logger, "Added port pair (out->in) {:?} -> {:?}", o, i);

        [o, i]

    }

    /// Instantiates a new component for the connector runtime to manage, and passing

    /// the given set of ports from the interface of the native component, to that of the

    /// newly created component (passing their ownership).

    /// # Errors

    /// Error is returned if the moved ports are not owned by the native component,

    /// if the given component name is not defined in the connector's protocol,

    /// the given sequence of ports contains a duplicate port,

    /// or if the component is unfit for instantiation with the given port sequence.

    /// # Panics

    /// This function panics if the connector's (large) component id space is exhausted.

    pub fn add_component(

        &mut self,

        identifier: &[u8],

        ports: &[PortId],

    ) -> Result<(), AddComponentError> {

        // Check for error cases first before modifying `cu`

        use AddComponentError as Ace;

        let cu = &self.unphased;

        if let Some(port) = duplicate_port(ports) {

            return Err(Ace::DuplicatePort(port));

        }

        let expected_polarities = cu.proto_description.component_polarities(identifier)?;

        if expected_polarities.len() != ports.len() {

            return Err(Ace::WrongNumberOfParamaters { expected: expected_polarities.len() });

        }

        for (&expected_polarity, &port) in expected_polarities.iter().zip(ports.iter()) {

            let info = cu.ips.port_info.map.get(&port).ok_or(Ace::UnknownPort(port))?;

            if info.owner != cu.native_component_id {

                return Err(Ace::UnknownPort(port));

            }

            if info.polarity != expected_polarity {

                return Err(Ace::WrongPortPolarity { port, expected_polarity });

            }

        }

        // No errors! Time to modify `cu`

        // create a new component and identifier

        let new_cid = cu.ips.id_manager.new_component_id();

        cu.proto_components.insert(new_cid, cu.proto_description.new_component(identifier, ports));

        // update the ownership of moved ports

        for port in ports.iter() {

            match cu.ips.port_info.map.get_mut(port) {

                Some(port_info) => port_info.owner = new_cid,

                None => unreachable!(),

            }

        }

        if let Some(set) = cu.ips.port_info.owned.get_mut(&cu.native_component_id) {

            set.retain(|x| !ports.contains(x));

        }

        Ok(())

    }

}

impl Predicate {

    #[inline]

    pub fn singleton(k: SpecVar, v: SpecVal) -> Self {

        Self::default().inserted(k, v)

    }

    #[inline]

    pub fn inserted(mut self, k: SpecVar, v: SpecVal) -> Self {

        self.assigned.insert(k, v);

        self

    }

    // Return true whether `self` is a subset of `maybe_superset`

    pub fn assigns_subset(&self, maybe_superset: &Self) -> bool {

        for (var, val) in self.assigned.iter() {

            match maybe_superset.assigned.get(var) {

                Some(val2) if val2 == val => {}

                _ => return false, // var unmapped, or mapped differently

            }

        }

        // `maybe_superset` mirrored all my assignments!

        true

    }

    /// Given the two predicates {self, other}, return that whose

    /// assignments are the union of those of both.

    fn assignment_union(&self, other: &Self) -> AssignmentUnionResult {

        use AssignmentUnionResult as Aur;

        // 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()];

        // populate lists of assignments in self but not other and vice versa.

        // do this by incrementally unfolding the iterators, keeping an eye

        // on the ordering between the head elements [s, o].

        // whenever s<o, other is certainly missing element 's', etc.

        let [mut s_not_o, mut o_not_s] = [vec![], vec![]];

        loop {

            match [s, o] {

                [None, None] => break, // both iterators are empty

                [None, Some(x)] => {

                    // self's iterator is empty.

                    // all remaning elements are in other but not self

                    o_not_s.push(x);

                    o_not_s.extend(o_it);

                    break;

                }

                [Some(x), None] => {

                    // other's iterator is empty.

                    // all remaning elements are in self but not other

                    s_not_o.push(x);

                    s_not_o.extend(s_it);

                    break;

                }

                [Some((sid, sb)), Some((oid, ob))] => {

                    if sid < oid {

                        // o is missing this element

                        s_not_o.push((sid, sb));

                        s = s_it.next();

                    } else if sid > oid {

                        // s is missing this element

                        o_not_s.push((oid, ob));

                        o = o_it.next();

                    } else if sb != ob {

                        assert_eq!(sid, oid);

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

                        // No predicate exists which satisfies both!

                        return Aur::Nonexistant;

                    } else {

                        // both predicates assign the variable to the same value

                        s = s_it.next();

                        o = o_it.next();

                    }

                }

            }

        }

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

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

            [true, true] => Aur::Equivalent,       // ... equivalent to both.

            [false, true] => Aur::FormerNotLatter, // ... equivalent to self.

            [true, false] => Aur::LatterNotFormer, // ... equivalent to other.

            [false, false] => {

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

                //     is equivalent to neither self nor other.

                let mut new = self.clone();

                for (&id, &b) in o_not_s {

                    new.assigned.insert(id, b);

                }

                Aur::New(new)

            }

        }

    }

    // Compute the union of the assignments of the two given predicates, if it exists.

    // It doesn't exist if there is some value which the predicates assign to different values.