round_robin_initiator.h

// Copyright 2023 The SOLA authors
//
// This file is part of DAISI.
//
// DAISI is free software: you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation; version 2.
//
// DAISI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
// Public License for more details.
//
// You should have received a copy of the GNU General Public License along with DAISI. If not, see
// <https://www.gnu.org/licenses/>.
//
// SPDX-License-Identifier: GPL-2.0-only
 
#ifndef DAISI_CPPS_LOGICAL_ALGORITHMS_ASSIGNMENT_ROUND_ROBIN_INITIATOR_H_
#define DAISI_CPPS_LOGICAL_ALGORITHMS_ASSIGNMENT_ROUND_ROBIN_INITIATOR_H_
 
#include <map>
#include <queue>
#include <random>
#include <unordered_map>
 
#include "centralized_initiator.h"
#include "cpps/common/cpps_communicator.h"
 
namespace daisi::cpps::logical {
class RoundRobinInitiator : public CentralizedInitiator {
public:
  RoundRobinInitiator(daisi::cpps::common::CppsCommunicatorPtr communicator,
                      std::shared_ptr<CppsLoggerNs3> logger);
  ~RoundRobinInitiator() override = default;
 
  REGISTER_IMPLEMENTATION(AssignmentResponse)
 
  
  REGISTER_IMPLEMENTATION(StatusUpdate)
 
  
  void logMaterialFlowContent(const std::string &material_flow_uuid) override;
 
private:
  struct ParticipantInfoRoundRobin : public ParticipantInfo {
    uint32_t assignment_counter = 0;
 
    bool operator<(const ParticipantInfoRoundRobin &other) const {
      return assignment_counter < other.assignment_counter;
    }
    bool operator>(const ParticipantInfoRoundRobin &other) const {
      return assignment_counter > other.assignment_counter;
    }
  };
 
  void storeParticipant(ParticipantInfo &info) override;
 
  void distributeMFTasks(uint32_t index, bool previously_allocated) override;
 
  void assignTask(const material_flow::Task &task);
 
  std::shared_ptr<ParticipantInfoRoundRobin> chooseParticipantForTask(
      const material_flow::Task &task);
 
  void processAssignmentAcceptions(uint32_t index);
 
  std::map<std::string, std::vector<material_flow::Task>> unallocated_tasks_per_mf_;
 
  std::unordered_map<amr::AmrStaticAbility,
                     std::priority_queue<ParticipantInfoRoundRobin,
                                         std::vector<ParticipantInfoRoundRobin>, std::greater<>>,
                     amr::AmrStaticAbilityHasher>
      participants_per_ability_;
};
}  // namespace daisi::cpps::logical
 
#endif