return Err(ChannelCreationError::InSync);

        }

        let (getter_port, putter_port) = self.runtime.create_channel(self.connector_id);

        debug_assert_eq!(getter_port.kind, PortKind::Getter);

        let getter_id = getter_port.self_id;

        let putter_id = putter_port.self_id;

        {

            let mut lock = self.job_queue.lock().unwrap();

            lock.push_back(ApplicationJob::NewChannel((getter_port, putter_port)));

        }

        // Add to owned ports for error checking while creating a connector

        self.owned_ports.reserve(2);

        self.owned_ports.push((PortKind::Putter, putter_id));

        self.owned_ports.push((PortKind::Getter, getter_id));

        return Ok(Channel{ putter_id, getter_id });

    }

    /// Creates a new connector. Note that it is not scheduled immediately, but

    /// depends on the `ApplicationConnector` to run, followed by the created

    /// connector being scheduled.

    pub fn create_connector(&mut self, module: &str, routine: &str, arguments: ValueGroup) -> Result<(), ComponentCreationError> {

        if self.is_in_sync {

            return Err(ComponentCreationError::InSync);

        }

        // Retrieve ports and make sure that we own the ones that are currently

        // specified. This is also checked by the scheduler, but that is done

        // asynchronously.

        let mut initial_ports = Vec::new();

        find_ports_in_value_group(&arguments, &mut initial_ports);

        for initial_port in &initial_ports {

            if !self.owned_ports.iter().any(|(_, v)| v == initial_port) {

                return Err(ComponentCreationError::UnownedPort);

            }

        }

        // We own all ports, so remove them on this side

        for initial_port in &initial_ports {

            let position = self.owned_ports.iter().position(|(_, v)| v == initial_port).unwrap();

            self.owned_ports.remove(position);

        }

        let state = self.runtime.protocol_description.new_component_v2(module.as_bytes(), routine.as_bytes(), arguments)?;

        let connector = ConnectorPDL::new(state);

        // Put on job queue

        {

            let mut queue = self.job_queue.lock().unwrap();

            queue.push_back(ApplicationJob::NewConnector(connector, initial_ports));

        }

        self.wake_up_connector_with_ping();

        return Ok(());

    }

    /// Queues up a description of a synchronous round to run. Will not actually

    /// run the synchronous behaviour in blocking fashion. The results *must* be

    /// retrieved using `try_wait` or `wait` for the interface to be considered

    /// in non-sync mode.

    pub fn perform_sync_round(&mut self, actions: Vec<ApplicationSyncAction>) -> Result<(), ApplicationStartSyncError> {

        if self.is_in_sync {

            return Err(ApplicationStartSyncError::AlreadyInSync);

        }

        // Check the action ports for consistency

        for action in &actions {

            let (port_id, expected_kind) = match action {

                ApplicationSyncAction::Put(port_id, _) => (*port_id, PortKind::Putter),

                ApplicationSyncAction::Get(port_id) => (*port_id, PortKind::Getter),

            };

            match self.find_port_by_id(port_id) {

                Some(port_kind) => {

                    if port_kind != expected_kind {

                        return Err(ApplicationStartSyncError::IncorrectPortKind)

                    }

                },

                None => {

                    return Err(ApplicationStartSyncError::UnownedPort);

                }

            }

        }

        // Everything is consistent, go into sync mode and send the actions off

        // to the component that will actually perform the sync round

        self.is_in_sync = true;

        {

            let (is_done, _) = &*self.sync_done;

            let mut lock = is_done.lock().unwrap();

            *lock = None;

        }

        {

            let mut lock = self.job_queue.lock().unwrap();

            lock.push_back(ApplicationJob::SyncRound(actions));

        }

        self.wake_up_connector_with_ping();

        return Ok(())

    }

    pub fn wait(&mut self) -> Result<Vec<ValueGroup>, ApplicationEndSyncError> {

        if !self.is_in_sync {

            return Err(ApplicationEndSyncError::NotInSync);

        }

        let (is_done, condition) = &*self.sync_done;

        let mut lock = is_done.lock().unwrap();

        lock = condition.wait_while(lock, |v| v.is_none()).unwrap(); // wait while not done

        self.is_in_sync = false;

        return Ok(lock.take().unwrap().inbox);

    }

    /// Called by runtime to set associated connector's ID.

    pub(crate) fn set_connector_id(&mut self, id: ConnectorId) {

        self.connector_id = id;

    }

    fn wake_up_connector_with_ping(&self) {

        let connector = self.runtime.get_component_public(self.connector_id);

        connector.inbox.insert_message(Message::Control(ControlMessage {

            id: 0,

            sending_component_id: self.connector_id,

            content: ControlContent::Ping,