ciiOldbDataPointMux.hpp

Go to the documentation of this file.

/*
 * ciiOldbDataPointMux.hpp
 *
 *  Created on: Feb 08, 2022
 *  Author: M.Schilling
 */
 
// msc Notes:
// 1) I started this as a subclass of CiiOldbDataPoint, intending to override
// the WriteValue methods in the superclass, for which I needed to make these methods
// virtual in the super class first (polymorphism won't work otherwise) but couldn't
// get it to work. It would have meant a change in CII, which is anyway undesirable now.
 
#ifndef HLCC_OLDBMUX_CIIOLDBDATAPOINTMUX_HPP_
#define HLCC_OLDBMUX_CIIOLDBDATAPOINTMUX_HPP_
 
#include "ciiOldbDataPoint.hpp"
#include "ciiOldbDpValue.hpp"
#include "ciiOldbDpQuality.hpp"
#include <string>
#include <cstddef>
#include <vector>
#include <mal/utility/Uri.hpp>
 
#include <ciiLogManager.hpp>
 
namespace hlcc::oldbmux {
 
template<typename T>
class CiiOldbDataPointMux {
 
public:
 
    // Additional API
    // -----------------------------------------
 
    explicit CiiOldbDataPointMux (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> mainDp);
 
    void AddSecondary (::elt::mal::Uri& uri);
 
    // Reproduce the Public API of CiiOldbDataPoint
    // -----------------------------------------
 
    std::shared_ptr<::elt::oldb::CiiOldbDpValue<T>> ReadValue(bool check_bad_quality = true);
 
    void WriteValue(
            const T& value,
            int64_t timestamp = ::elt::oldb::CiiOldbUtil::Now(),
            bool is_disable_publishing = false);
 
    void WriteValue(
            const T& value,
            int64_t timestamp,
            ::elt::oldb::CiiOldbDpQuality quality,
            const bool is_disable_publish = false,
            const std::string *overridden_server_alias = nullptr,
            const std::size_t *overriden_value_size_limit_remotefs = nullptr);
 
    void WriteValue(
            std::istream& value,
            std::uint64_t size,
            int64_t timestamp = ::elt::oldb::CiiOldbUtil::Now());
 
    void WriteValue(
            std::istream& value,
            std::uint64_t size,
            int64_t timestamp,
            ::elt::oldb::CiiOldbDpQuality quality);
 
    void Subscribe(
            const std::shared_ptr<::elt::oldb::CiiOldbDpSubscription<T>>& listener,
            bool answer_immediately = false);
 
    void Unsubscribe(const std::shared_ptr<::elt::oldb::CiiOldbDpSubscription<T>>& listener);
 
    std::shared_ptr<::elt::config::classes::meta::MdOldb<T>> GetMetadata() const;
 
    void SetMetadata(const std::string& meta_data_instance_name);
 
    void SetQuality(::elt::oldb::CiiOldbDpQuality quality);
 
    ::elt::common::CiiBasicDataType GetType() const;
 
protected:
 
    std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> m_mainDp;
 
    std::vector<std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>>> m_secondaries;
 
    const std::string LOGGER_NAME = "hlcc.OldbMux";
    log4cplus::Logger logger = elt::log::CiiLogManager::GetLogger(LOGGER_NAME);
 
};
 
// Additional API
// ----------------------
 
template<typename T>
CiiOldbDataPointMux<T>::CiiOldbDataPointMux (
        std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> mainDp)
: m_mainDp {mainDp} {
}
 
template<typename T>
void CiiOldbDataPointMux<T>::AddSecondary (
        ::elt::mal::Uri& uri) {
 
    auto oldb = ::elt::oldb::CiiOldbFactory::GetInstance();
    auto dp = oldb->GetDataPoint<T>(uri);
    m_secondaries.push_back(dp);
}
 
// Original API, delegating
// --------------------------
// This delegates mostly to main-DP.
// On selected methods (modifiers) delegates also to the mirror DPs.
 
template<typename T>
std::shared_ptr<::elt::oldb::CiiOldbDpValue<T>>
CiiOldbDataPointMux<T>::ReadValue(bool check_bad_quality) {
    return m_mainDp->ReadValue (check_bad_quality);
}
 
template<typename T>
void CiiOldbDataPointMux<T>::WriteValue (
        const T& value, int64_t timestamp, bool is_disable_publishing) {
 
    m_mainDp->WriteValue(value, timestamp, is_disable_publishing);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->WriteValue(value, timestamp, is_disable_publishing);
    }
}
 
template<typename T>
void CiiOldbDataPointMux<T>::WriteValue (
        const T& value,
        int64_t timestamp,
        ::elt::oldb::CiiOldbDpQuality quality,
        const bool is_disable_publish,
        const std::string *overridden_server_alias,
        const std::size_t *overriden_value_size_limit_remotefs) {
 
    m_mainDp->WriteValue(value, timestamp, quality, is_disable_publish,
            overridden_server_alias, overriden_value_size_limit_remotefs);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->WriteValue(value, timestamp, quality, is_disable_publish,
                overridden_server_alias, overriden_value_size_limit_remotefs);
    }
}
 
template<typename T>
void CiiOldbDataPointMux<T>::WriteValue (
        std::istream& value,
        std::uint64_t size,
        int64_t timestamp) {
 
    m_mainDp->WriteValue(value, size, timestamp);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->WriteValue(value, size, timestamp);
    }
}
 
template<typename T>
void CiiOldbDataPointMux<T>::WriteValue(
        std::istream& value,
        std::uint64_t size,
        int64_t timestamp,
        ::elt::oldb::CiiOldbDpQuality quality) {
 
    m_mainDp->WriteValue(value, size, timestamp, quality);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->WriteValue(value, size, timestamp, quality);
    }
}
 
template<typename T>
void CiiOldbDataPointMux<T>::Subscribe(
        const std::shared_ptr<::elt::oldb::CiiOldbDpSubscription<T>>& listener,
        bool answer_immediately) {
 
    m_mainDp->Subscribe(listener, answer_immediately);
}
 
template<typename T>
void CiiOldbDataPointMux<T>::Unsubscribe(
        const std::shared_ptr<::elt::oldb::CiiOldbDpSubscription<T> >& listener) {
 
    m_mainDp->Unscribe(listener);
}
 
template<typename T>
std::shared_ptr<::elt::config::classes::meta::MdOldb<T>>
CiiOldbDataPointMux<T>::GetMetadata() const {
 
    return m_mainDp->GetMetadata();
}
 
template<typename T>
void CiiOldbDataPointMux<T>::SetMetadata(
        const std::string& meta_data_instance_name) {
 
    m_mainDp->SetMetadata(meta_data_instance_name);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->SetMetadata(meta_data_instance_name);
    }
 
}
 
template<typename T>
void CiiOldbDataPointMux<T>::SetQuality(
        ::elt::oldb::CiiOldbDpQuality quality) {
 
    m_mainDp->SetQuality(quality);
 
    for (std::shared_ptr<::elt::oldb::CiiOldbDataPoint<T>> dp : m_secondaries) {
        dp->SetQuality(quality);
    }
}
 
template<typename T>
::elt::common::CiiBasicDataType CiiOldbDataPointMux<T>::GetType() const {
 
    return m_mainDp->getType();
}
 
}
// namespace
 
#endif