cpp98/MessageFederate.hpp

/*
Copyright (c) 2017-2025,
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
*/
 
#ifndef HELICS_CPP98_MESSAGE_FEDERATE_HPP_
#define HELICS_CPP98_MESSAGE_FEDERATE_HPP_
#pragma once
 
#include "Endpoint.hpp"
#include "Federate.hpp"
#include "helics/helics.h"
 
#include <string>
#include <vector>
 
namespace helicscpp {
class MessageFederate: public virtual Federate {
  public:
    MessageFederate(const std::string& fedName, FederateInfo& fedInfo)
    {
        fed = helicsCreateMessageFederate(fedName.c_str(), fedInfo.getInfo(), hThrowOnError());
    }
 
    explicit MessageFederate(const std::string& configString)
    {
        fed = helicsCreateMessageFederateFromConfig(configString.c_str(), hThrowOnError());
    }
 
    MessageFederate() HELICS_NOTHROW {}
 
    Endpoint registerEndpoint(const std::string& name, const std::string& type = std::string())
    {
        HelicsEndpoint ep =
            helicsFederateRegisterEndpoint(fed, name.c_str(), type.c_str(), hThrowOnError());
        local_endpoints.push_back(ep);
        return Endpoint(ep);
    }
 
    Endpoint registerGlobalEndpoint(const std::string& name,
                                    const std::string& type = std::string())
    {
        HelicsEndpoint ep =
            helicsFederateRegisterGlobalEndpoint(fed, name.c_str(), type.c_str(), hThrowOnError());
        local_endpoints.push_back(ep);
        return Endpoint(ep);
    }
 
    Endpoint getEndpoint(const std::string& name)
    {
        return Endpoint(helicsFederateGetEndpoint(fed, name.c_str(), hThrowOnError()));
    }
    Endpoint getEndpoint(int index)
    {
        return Endpoint(helicsFederateGetEndpointByIndex(fed, index, hThrowOnError()));
    }
 
    bool hasMessage() const
    {
        // returns int, 1 = true, 0 = false
        return (helicsFederateHasMessage(fed) > 0);
    }
 
    int pendingMessageCount() const { return helicsFederatePendingMessageCount(fed); }
 
    Message getMessage() { return Message(helicsFederateGetMessage(fed)); }
 
    Message createMessage() { return Message(helicsFederateCreateMessage(fed, hThrowOnError())); }
    int getEndpointCount() const { return helicsFederateGetEndpointCount(fed); }
 
  private:
    std::vector<HelicsEndpoint> local_endpoints;
};
// this code needs the definition of federate before it can de defined
inline Message::Message(const Federate& fed):
    mo(helicsFederateCreateMessage(fed.getObject(), hThrowOnError()))
{
}
 
inline Message& Message::newMessageObject(const Federate& fed)
{
    HelicsMessage newmo = helicsFederateCreateMessage(fed.getObject(), hThrowOnError());
    if (mo != HELICS_NULL_POINTER) {
        helicsMessageFree(mo);
    }
    mo = newmo;
    return *this;
}
}  // namespace helicscpp
#endif