application_api/ValueFederate.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 "../core/core-data.hpp"
#include "Federate.hpp"
#include "Inputs.hpp"
#include "Publications.hpp"
#include "ValueConverter.hpp"
#include "data_view.hpp"
 
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace helics {
class ValueFederateManager;
class HELICS_CXX_EXPORT ValueFederate:
    public virtual Federate  // using virtual inheritance to allow combination federate
{
  public:
    ValueFederate(std::string_view fedName, const FederateInfo& fedInfo);
 
    ValueFederate(std::string_view fedName,
                  const std::shared_ptr<Core>& core,
                  const FederateInfo& fedInfo = FederateInfo{});
 
    ValueFederate(std::string_view fedName,
                  CoreApp& core,
                  const FederateInfo& fedInfo = FederateInfo{});
 
    explicit ValueFederate(const std::string& configString);
 
    ValueFederate(std::string_view fedName, const std::string& configString);
 
    explicit ValueFederate();
 
    explicit ValueFederate(bool res);
 
    explicit ValueFederate(const char* configString);
 
    ValueFederate(const ValueFederate& fed) = delete;
    ValueFederate(ValueFederate&& fed) noexcept;
    virtual ~ValueFederate();
 
    ValueFederate& operator=(ValueFederate&& fed) noexcept;
    ValueFederate& operator=(const ValueFederate& fed) = delete;
    Publication& registerPublication(std::string_view name,
                                     std::string_view type,
                                     std::string_view units = std::string_view{});
    template<typename X>
    Publication& registerPublication(std::string_view name,
                                     std::string_view units = std::string_view{})
    {
        return registerPublication(name, ValueConverter<X>::type(), units);
    }
 
    Publication& registerGlobalPublication(std::string_view name,
                                           std::string_view type,
                                           std::string_view units = std::string_view{});
    template<typename X>
    Publication& registerGlobalPublication(std::string_view name,
                                           std::string_view units = std::string_view{})
    {
        return registerGlobalPublication(name, ValueConverter<X>::type(), units);
    }
 
    template<typename X>
    Publication& registerIndexedPublication(std::string_view name,
                                            int index1,
                                            std::string_view units = std::string_view{})
    {
        return registerGlobalPublication<X>(std::string(name) + '_' + std::to_string(index1),
                                            units);
    }
    template<typename X>
    Publication& registerIndexedPublication(std::string_view name,
                                            int index1,
                                            int index2,
                                            std::string_view units = std::string_view{})
    {
        return registerGlobalPublication<X>(std::string(name) + '_' + std::to_string(index1) + '_' +
                                                std::to_string(index2),
                                            units);
    }
 
    Input& registerInput(std::string_view name,
                         std::string_view type,
                         std::string_view units = std::string_view{});
 
    Input& registerGlobalInput(std::string_view name,
                               std::string_view type,
                               std::string_view units = std::string_view{});
    template<typename X>
    Input& registerInput(std::string_view name, std::string_view units = std::string_view{})
    {
        return registerInput(name, ValueConverter<X>::type(), units);
    }
    template<typename X>
    Input& registerGlobalInput(std::string_view name, std::string_view units = std::string_view{})
    {
        return registerGlobalInput(name, ValueConverter<X>::type(), units);
    }
 
    template<typename X>
    Input& registerIndexedInput(std::string_view name,
                                int index1,
                                std::string_view units = std::string_view())
    {
        return registerGlobalInput<X>(std::string(name) + '_' + std::to_string(index1), units);
    }
 
    template<typename X>
    Input& registerIndexedInput(std::string_view name,
                                int index1,
                                int index2,
                                std::string_view units = std::string_view())
    {
        return registerGlobalInput<X>(std::string(name) + '_' + std::to_string(index1) + '_' +
                                          std::to_string(index2),
                                      units);
    }
 
    Input& registerSubscription(std::string_view target,
                                std::string_view units = std::string_view{});
 
    Input& registerIndexedSubscription(std::string_view target,
                                       int index1,
                                       std::string_view units = std::string_view{})
    {
        return registerSubscription(std::string(target) + '_' + std::to_string(index1), units);
    }
 
    Input& registerIndexedSubscription(std::string_view target,
                                       int index1,
                                       int index2,
                                       std::string_view units = std::string_view{})
    {
        return registerSubscription(std::string(target) + '_' + std::to_string(index1) + '_' +
                                        std::to_string(index2),
                                    units);
    }
 
    using Federate::addAlias;
    void addAlias(const Input& inp, std::string_view shortcutName);
 
    void addAlias(const Publication& pub, std::string_view shortcutName);
 
    virtual void setFlagOption(int flag, bool flagValue = true) override;
 
    void setDefaultValue(const Input& inp, data_view block);
 
    virtual void registerInterfaces(const std::string& configString) override;
 
    void registerValueInterfaces(const std::string& configString);
 
  private:
    void loadFederateData();
 
    void registerValueInterfacesJson(const std::string& jsonString);
    void registerValueInterfacesJsonDetail(Json::Value& json, bool defaultGlobal);
    void registerValueInterfacesToml(const std::string& tomlString);
 
  public:
    data_view getBytes(const Input& inp);
 
    bool forceCoreUpdate(Input& inp);
 
    void publishBytes(const Publication& pub, data_view block);
 
    void publishBytes(const Publication& pub, const char* data, size_t data_size)
    {
        publishBytes(pub, data_view{data, data_size});
    }
 
    void registerFromPublicationJSON(const std::string& jsonString);
 
    void publishJSON(const std::string& jsonString);
 
    void addTarget(const Publication& pub, std::string_view target);
    void addTarget(const Input& inp, std::string_view target);
    void removeTarget(const Publication& pub, std::string_view target);
    void removeTarget(const Input& inp, std::string_view target);
 
    template<class iType>
    void addIndexedTarget(const iType& iObject, std::string_view target, int index1)
    {
        addTarget(iObject, std::string(target) + '_' + std::to_string(index1));
    }
 
    template<class iType>
    void addIndexedTarget(const iType& iObject, std::string_view target, int index1, int index2)
    {
        addTarget(iObject,
                  std::string(target) + '_' + std::to_string(index1) + '_' +
                      std::to_string(index2));
    }
 
    bool isUpdated(const Input& inp) const;
    Time getLastUpdateTime(const Input& inp) const;
 
    virtual void disconnect() override;
    void clearUpdates();
    void clearUpdate(const Input& inp);
 
  protected:
    virtual void updateTime(Time newTime, Time oldTime) override;
    virtual void startupToInitializeStateTransition() override;
    virtual void initializeToExecuteStateTransition(iteration_time result) override;
    virtual std::string localQuery(std::string_view queryStr) const override;
 
  public:
    std::vector<int> queryUpdates();
 
    const std::string& getTarget(const Input& inp) const;
    const Input& getInput(std::string_view name) const;
    Input& getInput(std::string_view name);
    const Input& getInput(int index) const;
    Input& getInput(int index);
    const Input& getInput(std::string_view name, int index1) const;
    const Input& getInput(std::string_view name, int index1, int index2) const;
 
    [[deprecated("Use getInputByTarget")]] const Input&
        getSubscription(std::string_view target) const
    {
        return getInputByTarget(target);
    }
 
    [[deprecated("Use getInputByTarget")]] Input& getSubscription(std::string_view target)
    {
        return getInputByTarget(target);
    }
 
    const Input& getInputByTarget(std::string_view target) const;
 
    Input& getInputByTarget(std::string_view target);
 
    Publication& getPublication(std::string_view name);
    const Publication& getPublication(std::string_view name) const;
    Publication& getPublication(int index);
    const Publication& getPublication(int index) const;
 
    const Publication& getPublication(std::string_view name, int index1) const;
    const Publication& getPublication(std::string_view name, int index1, int index2) const;
 
    void setInputNotificationCallback(std::function<void(Input&, Time)> callback);
    void setInputNotificationCallback(Input& inp, std::function<void(Input&, Time)> callback);
 
    int getPublicationCount() const;
    int getInputCount() const;
 
  private:
    std::unique_ptr<ValueFederateManager> vfManager;
};
 
template<class... Us>
void publish(ValueFederate& fed, std::string_view pubName, Us... pargs)
{
    fed.getPublication(pubName).publish(pargs...);
}
 
}  // namespace helics