ValueFederateManager.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 "../common/GuardedTypes.hpp"
#include "../core/LocalFederateId.hpp"
#include "Inputs.hpp"
#include "ValueFederate.hpp"
#include "data_view.hpp"
#include "gmlc/containers/DualStringMappedVector.hpp"
#include "helicsTypes.hpp"
 
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace helics {
class Core;
class ValueFederate;
 
struct publication_info {
    std::string name;  
    std::string type;  
    std::string units;  
    InterfaceHandle coreID;  
    PublicationId id;  
    int size{-1};  
    bool forward{true};
    publication_info(std::string_view n_name, std::string_view n_type, std::string_view n_units):
        name(n_name), type(n_type), units(n_units)
    {
    }
};
struct InputData {
    InterfaceHandle coreID;  
    InputId id;  
    data_view lastData;  
    Time lastUpdate{0.0};  
    Time lastQuery{0.0};  
    int sourceIndex{0};  
    std::string name;  
    std::string type;  
    std::string units;  
    std::string pubtype;  
 
    std::function<void(Input&, Time)> callback;  
    bool hasUpdate = false;  
    InputData(std::string_view n_name, std::string_view n_type, std::string_view n_units):
        name(n_name), type(n_type), units(n_units)
    {
    }
};
 
class ValueFederateManager {
  public:
    ValueFederateManager(Core* coreOb,
                         ValueFederate* vfed,
                         LocalFederateId id,
                         bool singleThreaded);
    ~ValueFederateManager();
 
    Publication&
        registerPublication(std::string_view key, std::string_view type, std::string_view units);
    Input& registerInput(std::string_view key, std::string_view type, std::string_view units);
 
    void addAlias(const Input& inp, std::string_view shortcutName);
 
    void addAlias(const Publication& pub, std::string_view shortcutName);
    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);
 
    void setDefaultValue(const Input& inp, const data_view& block);
 
    data_view getValue(const Input& inp);
 
    void publish(const Publication& pub, const data_view& block);
 
    static bool hasUpdate(const Input& inp);
    static Time getLastUpdateTime(const Input& inp);
 
    void updateTime(Time newTime, Time oldTime);
    void startupToInitializeStateTransition();
    void initializeToExecuteStateTransition(iteration_time result);
    std::string localQuery(std::string_view queryStr) const;
    std::vector<int> queryUpdates();
 
    const std::string& getTarget(const Input& inp) const;
 
    Input& getInput(std::string_view key);
    const Input& getInput(std::string_view key) const;
    Input& getInput(int index);
    const Input& getInput(int index) const;
 
    const Input& getInputByTarget(std::string_view key) const;
    Input& getInputByTarget(std::string_view key);
 
    Publication& getPublication(std::string_view key);
    const Publication& getPublication(std::string_view key) const;
 
    Publication& getPublication(int index);
    const Publication& getPublication(int index) const;
 
    void setInputNotificationCallback(std::function<void(Input&, Time)> callback);
    static void setInputNotificationCallback(const Input& inp,
                                             std::function<void(Input&, Time)> callback);
 
    void disconnect();
 
    int getPublicationCount() const;
    int getInputCount() const;
    void clearUpdates();
    static void clearUpdate(const Input& inp);
    bool getUpdateFromCore(Input& inp);
 
  public:
    bool useJsonSerialization{false};  
  private:
    LocalFederateId fedID;  
    shared_guarded_m_opt<gmlc::containers::DualStringMappedVector<Input, InterfaceHandle>> inputs;
    shared_guarded_m_opt<gmlc::containers::DualStringMappedVector<Publication, InterfaceHandle>>
        publications;
    Time CurrentTime{-1.0};  
    Core* coreObject{nullptr};  
    ValueFederate* fed{nullptr};
    atomic_guarded<std::function<void(Input&, Time)>> allCallback;
    shared_guarded_opt<std::deque<InputData>> inputData;
    shared_guarded_opt<std::multimap<std::string, InterfaceHandle>> targetIDs;
    shared_guarded_opt<std::multimap<InterfaceHandle, std::string>> inputTargets;
 
  private:
    void getUpdateFromCore(InterfaceHandle handle);
};
 
}  // namespace helics