exec_state: &mut CompExecState, inbox_main: &mut InboxMain,

    comp_ctx: &mut CompCtx, incoming_message: DataMessage,

    sched_ctx: &SchedulerCtx, control: &mut ControlLayer

) -> IncomingData {

    let port_handle = comp_ctx.get_port_handle(incoming_message.data_header.target_port);

    let port_index = comp_ctx.get_port_index(port_handle);

    let port_value_slot = &mut inbox_main[port_index];

    let target_port_id = incoming_message.data_header.target_port;

    if port_value_slot.is_none() {

        // We can put the value in the slot

        *port_value_slot = Some(incoming_message);

            return GetResult::Error((target_port_instruction, String::from(

                "Cannot get from this port, as this causes a deadlock. This happens if you `get` in a different order as another component `put`s"

            )));

        }

    } else {

        // We don't have a message waiting for us.

        let port_is_closed = port_info.state == PortState::Closed;

        if port_is_closed {

            let peer_id = port_info.peer_comp_id;

            return GetResult::Error((

                target_port_instruction,

                format!("Cannot get from this port, as the peer component (id:{}) shut down", peer_id.0)

                // Note that `port_was_used` does not mean that any messages

                // were actually received. It might also mean that e.g. the

                // component attempted a `get`, but there were no messages, so

                // now it is in the `BlockedGet` state.

                let port_was_used = last_instruction != PortInstruction::None;

                if exec_state.mode.is_in_sync_block() {

                    let closed_during_sync_round = content.closed_in_sync_round && port_was_used;

                        return Err((

                            last_instruction,

                            format!("Peer component (id:{}) shut down, so previous communication cannot have succeeded", peer_comp_id.0)

                        ));

                    }

                } else {

        default_handle_sync_decision(sched_ctx, exec_state, comp_ctx, decision, consensus);

    }

    // Iterating over ports by index to work around borrowing rules

    for port_index in 0..comp_ctx.num_ports() {

        let port = comp_ctx.get_port_by_index_mut(port_index);

            // Already closed, or in the process of being closed

            continue;

        }

        // Mark as closed

        let port_id = port.self_id;

    /// until the participants in the round (hopefully) reach a conclusion.

    pub(crate) fn notify_sync_end_success(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx) -> SyncRoundDecision {

        debug_assert_eq!(self.mode, Mode::SyncBusy);

        self.mode = Mode::SyncAwaitingSolution;

        let local_solution = self.generate_local_solution(comp_ctx, false);

        return decision;

    }

    /// Notifies the consensus management that the component has encountered a

    /// critical error during the synchronous round. Hence we should report that

    /// we've failed and wait until all the participants have been notified of

    /// the error.

    pub(crate) fn notify_sync_end_failure(&mut self, sched_ctx: &SchedulerCtx, comp_ctx: &CompCtx) -> SyncRoundDecision {

        debug_assert_eq!(self.mode, Mode::SyncBusy);

        self.mode = Mode::SyncAwaitingSolution;

        let local_solution = self.generate_local_solution(comp_ctx, true);

        return decision;

    }

    /// Notifies that a decision has been reached. Note that the caller should

    /// still take the appropriate actions based on the decision it is supplying

    /// to the consensus layer.

        match message.content {

            SyncMessageContent::NotificationOfLeader => {

                return SyncRoundDecision::None;

            },

            SyncMessageContent::LocalSolution(solution_generator_id, local_solution) => {

            },

            SyncMessageContent::PartialSolution(partial_solution) => {

                return self.handle_partial_solution(sched_ctx, comp_ctx, partial_solution);

            },

            SyncMessageContent::GlobalSolution => {

                debug_assert_eq!(self.mode, Mode::SyncAwaitingSolution); // leader can only find global- if we submitted local solution

        self.send_to_leader(sched_ctx, comp_ctx, Message::Sync(SyncMessage{

            sync_header: self.create_sync_header(comp_ctx),

            content: SyncMessageContent::PartialSolution(partial_solution),

        }));

    }

        if self.highest_id == comp_ctx.id {

            // We are the leader

            self.solution.combine_with_local_solution(solution_sender_id, solution);

            if round_decision != SyncRoundDecision::None {

                self.broadcast_decision(sched_ctx, comp_ctx, round_decision);

            }

            return round_decision;

        } else {

            // Forward the solution

            let message = SyncMessage{