MessageFederateManager.hpp

/*
Copyright (c) 2017-2024,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
Energy, LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "../common/GuardedTypes.hpp"
#include "../core/Core.hpp"
#include "../core/FederateIdExtra.hpp"
#include "Endpoints.hpp"
#include "data_view.hpp"
#include "gmlc/containers/DualStringMappedVector.hpp"
#include "gmlc/containers/SimpleQueue.hpp"
 
#include <cstdint>
#include <deque>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
namespace helics {
class Core;
class MessageFederate;
class MessageFederateManager {
  public:
    MessageFederateManager(Core* coreOb,
                           MessageFederate* mFed,
                           LocalFederateId id,
                           bool singleThreaded);
    ~MessageFederateManager();
    Endpoint& registerEndpoint(std::string_view name, std::string_view type);
 
    Endpoint& registerTargetedEndpoint(std::string_view name, std::string_view type);
 
    Endpoint& registerDataSink(std::string_view name);
 
    bool hasMessage() const;
    /* check if a given endpoint has any unread messages*/
    static bool hasMessage(const Endpoint& ept);
 
    static uint64_t pendingMessageCount(const Endpoint& ept);
    uint64_t pendingMessageCount() const;
    static std::unique_ptr<Message> getMessage(const Endpoint& ept);
    /* receive a communication message for any endpoint in the federate*/
    std::unique_ptr<Message> getMessage();
 
    void updateTime(Time newTime, Time oldTime);
    void startupToInitializeStateTransition();
    void initializeToExecuteStateTransition(iteration_time result);
    std::string localQuery(std::string_view queryStr) const;
 
    Endpoint& getEndpoint(std::string_view name);
    const Endpoint& getEndpoint(std::string_view name) const;
 
    Endpoint& getEndpoint(int index);
    const Endpoint& getEndpoint(int index) const;
 
    Endpoint& getDataSink(std::string_view name);
    const Endpoint& getDataSink(std::string_view name) const;
 
    void setEndpointNotificationCallback(const std::function<void(Endpoint&, Time)>& callback);
    static void
        setEndpointNotificationCallback(const Endpoint& ept,
                                        const std::function<void(Endpoint&, Time)>& callback);
 
    void disconnect();
    int getEndpointCount() const;
 
  private:
    class EndpointData {
      public:
        gmlc::containers::SimpleQueue<std::unique_ptr<Message>> messages;
        std::function<void(Endpoint&, Time)> callback;
    };
    shared_guarded_opt<gmlc::containers::DualStringMappedVector<Endpoint, InterfaceHandle>>
        mLocalEndpoints;
    atomic_guarded<std::function<void(Endpoint&, Time)>> allCallback;
    Time CurrentTime = Time::minVal();  
    Core* coreObject;  
    MessageFederate* mFed;  
    const LocalFederateId fedID;  
    shared_guarded_opt<std::deque<EndpointData>> eptData;
    guarded_opt<std::vector<unsigned int>> messageOrder;
 
  private:
    void removeOrderedMessage(unsigned int index);
};
}  // namespace helics