cpp98/ValueFederate.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
*/
#ifndef HELICS_CPP98_VALUE_FEDERATE_HPP_
#define HELICS_CPP98_VALUE_FEDERATE_HPP_
#pragma once
 
#include "Federate.hpp"
#include "Input.hpp"
#include "Publication.hpp"
#include "helics/helics.h"
 
#include <exception>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
 
namespace helicscpp {
enum PubSubTypes {
    STRING_TYPE = HELICS_DATA_TYPE_STRING,
    DOUBLE_TYPE = HELICS_DATA_TYPE_DOUBLE,
    INT_TYPE = HELICS_DATA_TYPE_INT,
    COMPLEX_TYPE = HELICS_DATA_TYPE_COMPLEX,
    VECTOR_TYPE = HELICS_DATA_TYPE_VECTOR,
    TIME_TYPE = HELICS_DATA_TYPE_TIME,
    BOOLEAN_TYPE = HELICS_DATA_TYPE_BOOLEAN,
    RAW_TYPE = HELICS_DATA_TYPE_RAW
};
 
class ValueFederate: public virtual Federate {
  private:
    std::vector<HelicsInput> ipts;
    std::vector<HelicsPublication> pubs;
 
  public:
    friend class helicscpp::FederateInfo;
    explicit ValueFederate(const std::string& fedName, FederateInfo& fedInfo)
    {
        fed = helicsCreateValueFederate(fedName.c_str(), fedInfo.getInfo(), hThrowOnError());
        if (fed == NULL) {
            throw(HelicsException(HELICS_ERROR_REGISTRATION_FAILURE, "Fed==NULL"));
        }
    }
    explicit ValueFederate(const std::string& configString)
    {
        fed = helicsCreateValueFederateFromConfig(configString.c_str(), hThrowOnError());
        if (fed == NULL) {
            throw(HelicsException(HELICS_ERROR_REGISTRATION_FAILURE, "Fed==NULL"));
        }
    }
    ValueFederate(const ValueFederate& vfed): Federate(vfed), ipts(vfed.ipts), pubs(vfed.pubs) {}
    ValueFederate& operator=(const ValueFederate& fedObj)
    {
        Federate::operator=(fedObj);
        ipts = fedObj.ipts;
        pubs = fedObj.pubs;
        if (fed == NULL) {
            throw(HelicsException(HELICS_ERROR_REGISTRATION_FAILURE, "Fed==NULL move constructor"));
        }
        return *this;
    }
#ifdef HELICS_HAS_RVALUE_REFS
    ValueFederate(ValueFederate&& fedObj) HELICS_NOTHROW:
        Federate(),
        ipts(std::move(fedObj.ipts)),
        pubs(std::move(fedObj.pubs))
    {
        Federate::operator=(std::move(fedObj));
    }
    ValueFederate& operator=(ValueFederate&& fedObj) HELICS_NOTHROW
    {
        ipts = std::move(fedObj.ipts);
        pubs = std::move(fedObj.pubs);
        Federate::operator=(std::move(fedObj));
        return *this;
    }
#endif
    ValueFederate() HELICS_NOTHROW {}
 
    Publication registerPublication(const std::string& name,
                                    const std::string& type,
                                    const std::string& units = "")
    {
        HelicsPublication pub = helicsFederateRegisterTypePublication(
            fed, name.c_str(), type.c_str(), units.c_str(), hThrowOnError());
        pubs.push_back(pub);
        return Publication(pub);
    }
 
    Publication registerPublication(const std::string& name,
                                    HelicsDataTypes type,
                                    const std::string& units = "")
    {
        HelicsPublication pub = helicsFederateRegisterPublication(
            fed, name.c_str(), type, units.c_str(), hThrowOnError());
        pubs.push_back(pub);
        return Publication(pub);
    }
 
    Publication registerGlobalPublication(const std::string& name,
                                          const std::string& type,
                                          const std::string& units = "")
    {
        HelicsPublication pub = helicsFederateRegisterGlobalTypePublication(
            fed, name.c_str(), type.c_str(), units.c_str(), hThrowOnError());
        pubs.push_back(pub);
        return Publication(pub);
    }
 
    Publication registerGlobalPublication(const std::string& key,
                                          HelicsDataTypes type,
                                          const std::string& units = "")
    {
        HelicsPublication pub = helicsFederateRegisterGlobalPublication(
            fed, key.c_str(), type, units.c_str(), hThrowOnError());
        pubs.push_back(pub);
        return Publication(pub);
    }
 
    Publication registerIndexedPublication(const std::string& key,
                                           int index1,
                                           HelicsDataTypes type,
                                           const std::string& units = "")
    {
        std::string indexed_name = key + '_' + toStr(index1);
        return registerGlobalPublication(indexed_name, type, units);
    }
 
    Publication registerIndexedPublication(const std::string& key,
                                           int index1,
                                           int index2,
                                           HelicsDataTypes type,
                                           const std::string& units = std::string())
    {
        std::string indexed_name = key + '_' + toStr(index1) + '_' + toStr(index2);
        return registerGlobalPublication(indexed_name, type, units);
    }
 
    Publication registerPublicationIndexed(const std::string& key,
                                           int index1,
                                           HelicsDataTypes type,
                                           const std::string& units = "")
    {
        return registerIndexedPublication(key, index1, type, units);
    }
 
    Publication registerPublicationIndexed(const std::string& key,
                                           int index1,
                                           int index2,
                                           HelicsDataTypes type,
                                           const std::string& units = std::string())
    {
        return registerIndexedPublication(key, index1, index2, type, units);
    }
    void registerFromPublicationJSON(const std::string& json)
    {
        helicsFederateRegisterFromPublicationJSON(fed, json.c_str(), hThrowOnError());
    }
    HELICS_NODISCARD Publication getPublication(const std::string& name)
    {
        return Publication(helicsFederateGetPublication(fed, name.c_str(), hThrowOnError()));
    }
    HELICS_NODISCARD Publication getPublication(int index)
    {
        return Publication(helicsFederateGetPublicationByIndex(fed, index, hThrowOnError()));
    }
 
    Input registerSubscription(const std::string& name, const std::string& units = std::string())
    {
        HelicsInput sub =
            helicsFederateRegisterSubscription(fed, name.c_str(), units.c_str(), hThrowOnError());
        ipts.push_back(sub);
        return Input(sub);
    }
 
    Input registerIndexedSubscription(const std::string& name,
                                      int index1,
                                      const std::string& units = "")
    {
        std::string indexed_name = name + '_' + toStr(index1);
        return registerSubscription(indexed_name, units);
    }
 
    Input registerIndexedSubscription(const std::string& name,
                                      int index1,
                                      int index2,
                                      const std::string& units = "")
    {
        std::string indexed_name = name + '_' + toStr(index1) + '_' + toStr(index2);
        return registerSubscription(indexed_name, units);
    }
 
    Input registerSubscriptionIndexed(const std::string& name,
                                      int index1,
                                      const std::string& units = "")
    {
        return registerIndexedSubscription(name, index1, units);
    }
 
    Input registerSubscriptionIndexed(const std::string& name,
                                      int index1,
                                      int index2,
                                      const std::string& units = "")
    {
        return registerIndexedSubscription(name, index1, index2, units);
    }
 
    Input registerInput(const std::string& name,
                        const std::string& type,
                        const std::string& units = "")
    {
        HelicsInput ipt = helicsFederateRegisterTypeInput(
            fed, name.c_str(), type.c_str(), units.c_str(), hThrowOnError());
        ipts.push_back(ipt);
        return Input(ipt);
    }
 
    Input
        registerInput(const std::string& name, HelicsDataTypes type, const std::string& units = "")
    {
        HelicsInput ipt = helicsFederateRegisterPublication(
            fed, name.c_str(), type, units.c_str(), hThrowOnError());
        pubs.push_back(ipt);
        return Input(ipt);
    }
 
    Input registerGlobalInput(const std::string& name,
                              const std::string& type,
                              const std::string& units = "")
    {
        HelicsInput ipt = helicsFederateRegisterGlobalTypeInput(
            fed, name.c_str(), type.c_str(), units.c_str(), hThrowOnError());
        ipts.push_back(ipt);
        return Input(ipt);
    }
 
    Input registerGlobalInput(const std::string& key,
                              HelicsDataTypes type,
                              const std::string& units = "")
    {
        HelicsInput inp = helicsFederateRegisterGlobalInput(
            fed, key.c_str(), type, units.c_str(), hThrowOnError());
        ipts.push_back(inp);
        return Input(inp);
    }
 
    Input registerIndexedInput(const std::string& key,
                               int index1,
                               HelicsDataTypes type,
                               const std::string& units = "")
    {
        std::string indexed_name = key + '_' + toStr(index1);
        return registerGlobalInput(indexed_name, type, units);
    }
 
    Input registerIndexedInput(const std::string& key,
                               int index1,
                               int index2,
                               HelicsDataTypes type,
                               const std::string& units = std::string())
    {
        std::string indexed_name = key + '_' + toStr(index1) + '_' + toStr(index2);
        return registerGlobalInput(indexed_name, type, units);
    }
 
    HELICS_NODISCARD Input getInput(const std::string& name)
    {
        return Input(helicsFederateGetInput(fed, name.c_str(), hThrowOnError()));
    }
 
    HELICS_NODISCARD Input getInputByTarget(const std::string& target)
    {
        return Input(helicsFederateGetInputByTarget(fed, target.c_str(), hThrowOnError()));
    }
 
    HELICS_NODISCARD Input getInput(int index)
    {
        return Input(helicsFederateGetInputByIndex(fed, index, hThrowOnError()));
    }
    HELICS_NODISCARD int getInputCount() const { return helicsFederateGetInputCount(fed); }
    HELICS_NODISCARD int getPublicationCount() const
    {
        return helicsFederateGetPublicationCount(fed);
    }
    // TODO(PT): use c api to implement this method... callbacks too?
    std::vector<HelicsInput> queryUpdates() { return std::vector<HelicsInput>(); }
 
    void clearUpdates() { helicsFederateClearUpdates(fed); }
    void publishJSON(const std::string& json)
    {
        helicsFederatePublishJSON(fed, json.c_str(), hThrowOnError());
    }
 
  private:
    // Utility function for converting numbers to string
    template<typename T>
    std::string toStr(T num)
    {
        std::ostringstream ss;
        ss << num;
        return ss.str();
    }
};
}  // namespace helicscpp
#endif