Publications.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-exceptions.hpp"
#include "Federate.hpp"
#include "HelicsPrimaryTypes.hpp"
 
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace units {
class precise_unit;
}  // namespace units
 
namespace helics {
class ValueFederate;
class HELICS_CXX_EXPORT Publication: public Interface {
  protected:
    ValueFederate* fed{nullptr};  
  private:
    int referenceIndex{-1};  
    void* dataReference{nullptr};  
    double delta{-1.0};  
  protected:
    DataType pubType{DataType::HELICS_ANY};  
    bool changeDetectionEnabled{false};  
    bool disableAssign{false};  
  private:
    size_t customTypeHash{
        0};  
    mutable defV prevValue;  
    std::string pubUnits;  
    std::shared_ptr<units::precise_unit>
        pubUnitType;  
  public:
    Publication() = default;
    Publication(ValueFederate* valueFed,
                InterfaceHandle id,
                std::string_view key,
                std::string_view type,
                std::string_view units);
 
    Publication(ValueFederate* valueFed,
                std::string_view key,
                std::string_view type,
                std::string_view units = std::string_view{});
 
    template<class FedPtr>
    Publication(FedPtr valueFed,
                std::string_view key,
                std::string_view type = std::string_view(),
                std::string_view units = std::string_view()):
        Publication(std::addressof(*valueFed), key, type, units)
    {
        static_assert(
            std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
            "first argument must be a pointer to a ValueFederate");
    }
    Publication(InterfaceVisibility locality,
                ValueFederate* valueFed,
                std::string_view key,
                std::string_view type,
                std::string_view units = std::string_view());
    template<class FedPtr>
    Publication(InterfaceVisibility locality,
                FedPtr& valueFed,
                std::string_view key,
                std::string_view type,
                std::string_view units = std::string_view()):
        Publication(locality, std::addressof(*valueFed), key, type, units)
    {
        static_assert(
            std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
            "first argument must be a pointer to a ValueFederate");
    }
 
    Publication(ValueFederate* valueFed,
                std::string_view key,
                DataType type,
                std::string_view units = std::string_view()):
        Publication(valueFed, key, typeNameStringRef(type), units)
    {
    }
    template<class FedPtr>
    Publication(FedPtr& valueFed,
                std::string_view key,
                DataType type,
                std::string_view units = std::string_view()):
        Publication(valueFed, key, typeNameStringRef(type), units)
    {
    }
    Publication(InterfaceVisibility locality,
                ValueFederate* valueFed,
                std::string_view key,
                DataType type,
                std::string_view units = std::string_view()):
        Publication(locality, valueFed, key, typeNameStringRef(type), units)
    {
    }
 
    template<class FedPtr>
    Publication(InterfaceVisibility locality,
                FedPtr& valueFed,
                std::string_view key,
                DataType type,
                std::string_view units = std::string_view()):
        Publication(locality, valueFed, key, typeNameStringRef(type), units)
    {
    }
 
    const std::string& getType() const { return getExtractionType(); }
    const std::string& getUnits() const { return pubUnits; }
    void addTarget(std::string_view target) { addDestinationTarget(target); }
    void addInputTarget(std::string_view target) { addDestinationTarget(target); }
    void publish(double val);
    void publish(const std::vector<std::string>& val);
    void publish(const std::vector<double>& val);
    void publish(const double* vals, int size);
    void publish(const std::vector<std::complex<double>>& val);
    void publishComplex(const double* vals, int size);
    void publish(std::complex<double> val);
 
    void publish(bool val);
    void publish(Time val);
    void publish(char val);
    void publish(const NamedPoint& np);
    void publish(std::string_view field, double val);
    void publish(double val, const std::string& units);
    void publish(double val, const units::precise_unit& units);
 
    template<class X>
    std::enable_if_t<(std::is_constructible_v<std::string_view, X>), void> publish(const X& val)
    {
        publishString(val);
    }
 
    template<class X>
    std::enable_if_t<(std::is_same_v<defV, remove_cv_ref<X>>), void> publish(const X& val)
    {
        publishDefV(val);
    }
 
    template<class X>
    std::enable_if_t<(std::is_integral_v<X> && !std::is_same_v<remove_cv_ref<X>, char>), void>
        publish(X val)
    {
        publishInt(static_cast<int64_t>(val));
    }
 
    void setMinimumChange(double deltaV) noexcept
    {
        if (delta < 0.0) {
            changeDetectionEnabled = true;
        }
        delta = deltaV;
        if (delta < 0.0) {
            changeDetectionEnabled = false;
        }
    }
    void enableChangeDetection(bool enabled = true) noexcept { changeDetectionEnabled = enabled; }
 
    virtual const std::string& getDisplayName() const override { return getName(); }
 
  private:
    void publishInt(int64_t val);
    void publishString(std::string_view val);
    void publishDefV(const defV& val);
    friend class ValueFederateManager;
};
 
}  // namespace helics