Subscriptions.hpp

Go to the documentation of this file.

/*
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 "ValueFederate.hpp"
 
#include <algorithm>
#include <array>
#include <string>
#include <utility>
#include <vector>
 
namespace helics {
 
template<class X>
class VectorSubscription {
  private:
    ValueFederate* fed = nullptr;  
    std::string m_key;  
    std::string m_units;  
    std::vector<Input> ids;  
    std::function<void(int, Time)>
        update_callback;  
    std::vector<X> vals;  
  public:
    VectorSubscription() noexcept {};
    VectorSubscription(ValueFederate* valueFed,
                       std::string_view key,
                       int startIndex,
                       int count,
                       const X& defValue,
                       std::string_view units = std::string_view{}):
        fed(valueFed), m_key(key), m_units(units)
    {
        ids.reserve(count);
        vals.resize(count, defValue);
 
        for (auto ind = startIndex; ind < startIndex + count; ++ind) {
            auto id = fed->registerIndexedSubscription(m_key, ind, m_units);
            ids.push_back(id);
        }
 
        for (auto& id : ids) {
            fed->setInputNotificationCallback(id, [this](Input& inp, Time tm) {
                handleCallback(inp, tm);
            });
        }
    }
    template<class FedPtr>
    VectorSubscription(FedPtr valueFed,
                       std::string_view key,
                       int startIndex,
                       int count,
                       const X& defValue,
                       std::string_view units = std::string_view{}):
        VectorSubscription(std::addressof(*valueFed), key, startIndex, count, defValue, units)
    {
        static_assert(
            std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
            "first argument must be a pointer to a ValueFederate");
    }
 
    VectorSubscription(VectorSubscription&& vs) noexcept:
        fed(vs.fed), m_key(std::move(vs.m_key)), m_units(std::move(vs.m_units)),
        ids(std::move(vs.ids)), update_callback(std::move(vs.update_callback)),
        vals(std::move(vs.vals))
    {
        // need to transfer the callback to the new object
        for (auto& id : ids) {
            fed->setInputNotificationCallback(id, [this](Input& inp, Time tm) {
                handleCallback(inp, tm);
            });
        }
    };
    VectorSubscription& operator=(VectorSubscription&& vs) noexcept
    {
        fed = vs.fed;
        m_key = std::move(vs.m_key);
        m_units = std::move(vs.m_units);
        ids = std::move(vs.ids);
        update_callback = std::move(vs.update_callback);
        vals = std::move(vs.vals);
        // need to transfer the callback to the new object
        for (auto& id : ids) {
            fed->setInputNotificationCallback(id, [this](Input& inp, Time tm) {
                handleCallback(inp, tm);
            });
        }
        return *this;
    }
    const std::vector<X>& getVals() const { return vals; }
    const X& operator[](int index) const { return vals[index]; }
    void setInputNotificationCallback(std::function<void(int, Time)> callback)
    {
        update_callback = std::move(callback);
    }
 
  private:
    void handleCallback(Input& inp, Time time)
    {
        auto res = std::lower_bound(ids.begin(), ids.end(), inp);
        int index = static_cast<int>(res - ids.begin());
        vals[index] = inp.getValue<X>();
        if (update_callback) {
            update_callback(index, time);
        }
    }
};
 
template<class X>
class VectorSubscription2d {
  private:
    ValueFederate* fed = nullptr;  
    std::string m_key;  
    std::string m_units;  
    std::vector<Input> ids;  
    std::function<void(int, Time)>
        update_callback;  
    std::vector<X> vals;  
    std::array<int, 4> indices{{0, 0, 0, 0}};  
  public:
    VectorSubscription2d() noexcept {};
 
    template<class FedPtr>
    VectorSubscription2d(FedPtr valueFed,
                         std::string_view key,
                         int startIndex_x,
                         int count_x,
                         int startIndex_y,
                         int count_y,
                         const X& defValue,
                         std::string_view units = std::string_view()):
        fed(std::addressof(*valueFed)), m_key(key), m_units(units)
    {
        static_assert(
            std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
            "Second argument must be a pointer to a ValueFederate");
        std::size_t arrayCount =
            static_cast<std::size_t>(count_x) * static_cast<std::size_t>(count_y);
        ids.reserve(arrayCount);
        vals.resize(arrayCount, defValue);
 
        for (auto ind_x = startIndex_x; ind_x < startIndex_x + count_x; ++ind_x) {
            for (auto ind_y = startIndex_y; ind_y < startIndex_y + count_y; ++ind_y) {
                auto id = fed->registerIndexedSubscription(m_key, ind_x, ind_y, m_units);
                ids.push_back(id);
            }
        }
 
        indices[0] = startIndex_x;
        indices[1] = count_x;
        indices[2] = startIndex_y;
        indices[3] = count_y;
        for (auto& id : ids) {
            fed->setInputNotificationCallback(id, [this](Input& inp, Time tm) {
                handleCallback(inp, tm);
            });
        }
    }
 
    VectorSubscription2d& operator=(VectorSubscription2d&& vs) noexcept
    {
        fed = vs.fed;
        m_key = std::move(vs.m_key);
        m_units = std::move(vs.m_units);
        ids = std::move(vs.ids);
        update_callback = std::move(vs.update_callback);
        vals = std::move(vs.vals);
        // need to transfer the callback to the new object
        for (auto& id : ids) {
            fed->setInputNotificationCallback(id, [this](Input& inp, Time tm) {
                handleCallback(inp, tm);
            });
        }
        indices = vs.indices;
        return *this;
    }
    const std::vector<X>& getVals() const { return vals; }
    const X& operator[](int index) const { return vals[index]; }
 
    const X& at(int index_x, int index_y) const
    {
        return vals[(index_x - indices[0]) * indices[3] + (index_y - indices[2])];
    }
    void setInputNotificationCallback(std::function<void(int, Time)> callback)
    {
        update_callback = std::move(callback);
    }
 
  private:
    void handleCallback(const Input& inp, Time time)
    {
        auto res = std::lower_bound(ids.begin(), ids.end(), inp);
        int index = static_cast<int>(res - ids.begin());
        ids[index].getValue(vals[index]);
        if (update_callback) {
            update_callback(index, time);
        }
    }
};
 
}  // namespace helics