application_api/MessageFederate.hpp

/*
Copyright (c) 2017-2026,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Energy
Innovation LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
#pragma once
 
#include "Endpoints.hpp"
#include "Federate.hpp"
#include "data_view.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <string_view>
 
namespace helics {
class MessageFederateManager;
class Endpoint;
class HELICS_CXX_EXPORT MessageFederate:
    public virtual Federate  // using virtual inheritance to allow combination federate
{
  public:
    MessageFederate(std::string_view fedName, const FederateInfo& fedInfo);
    MessageFederate(std::string_view fedName,
                    const std::shared_ptr<Core>& core,
                    const FederateInfo& fedInfo = FederateInfo{});
 
    MessageFederate(std::string_view fedName,
                    CoreApp& core,
                    const FederateInfo& fedInfo = FederateInfo{});
 
    MessageFederate(std::string_view name, const std::string& configString);
    explicit MessageFederate(const std::string& configString);
 
    explicit MessageFederate(const char* configString);
    MessageFederate(MessageFederate&& mFed) noexcept;
    MessageFederate(const MessageFederate& mFed) = delete;
    MessageFederate();
    explicit MessageFederate(bool res);
    // copy constructor and copy assignment are disabled
    virtual ~MessageFederate();
    MessageFederate& operator=(MessageFederate&& mFed) noexcept;
    MessageFederate& operator=(const MessageFederate& mFed) = delete;
 
  protected:
    virtual void startupToInitializeStateTransition() override;
    virtual void initializeToExecuteStateTransition(iteration_time result) override;
    virtual void updateTime(Time newTime, Time oldTime) override;
    virtual std::string localQuery(std::string_view queryStr) const override;
 
  public:
    Endpoint& registerEndpoint(std::string_view eptName = std::string_view(),
                               std::string_view type = std::string_view());
 
    Endpoint& registerTargetedEndpoint(std::string_view eptName = std::string_view(),
                                       std::string_view type = std::string_view());
 
    Endpoint& registerGlobalEndpoint(std::string_view eptName,
                                     std::string_view type = std::string_view());
 
    Endpoint& registerGlobalTargetedEndpoint(std::string_view eptName,
                                             std::string_view type = std::string_view());
 
    Endpoint& registerIndexedEndpoint(std::string_view eptName,
                                      int index1,
                                      std::string_view type = std::string_view())
    {
        return registerGlobalEndpoint(std::string(eptName) + '_' + std::to_string(index1), type);
    }
 
    Endpoint& registerDataSink(std::string_view sinkName = std::string_view());
 
    virtual void registerInterfaces(const std::string& configString) override;
 
    void registerMessageInterfaces(const std::string& configString);
 
  private:
    void loadFederateData();
    void registerMessageInterfacesJson(const std::string& jsonString);
 
    void registerMessageInterfacesJsonDetail(const fileops::JsonBuffer&, bool defaultGlobal);
 
    void registerMessageInterfacesToml(const std::string& tomlString);
 
    Endpoint& registerEndpoint(std::string_view eptName,
                               std::string_view type,
                               bool global,
                               bool targeted);
 
  public:
    void subscribe(const Endpoint& ept, std::string_view key);
    bool hasMessage() const;
    /* check if a given endpoint has any unread messages*/
    bool hasMessage(const Endpoint& ept) const;
 
    uint64_t pendingMessageCount(const Endpoint& ept) const;
    uint64_t pendingMessageCount() const;
    std::unique_ptr<Message> getMessage(const Endpoint& ept);
    std::unique_ptr<Message> getMessage();
 
    Endpoint& getEndpoint(std::string_view name) const;
 
    Endpoint& getEndpoint(int index) const;
 
    Endpoint& getDataSink(std::string_view name) const;
 
    void setMessageNotificationCallback(const std::function<void(Endpoint&, Time)>& callback);
    void setMessageNotificationCallback(const Endpoint& ept,
                                        const std::function<void(Endpoint&, Time)>& callback);
 
    virtual void disconnect() override;
 
    int getEndpointCount() const;
 
  private:
    std::unique_ptr<MessageFederateManager> mfManager;
};
}  // namespace helics