oldbAdapter.hpp

Go to the documentation of this file.

 
#ifndef RAD_MAL_OLDB_ADAPTER_HPP
#define RAD_MAL_OLDB_ADAPTER_HPP
 
#include <rad/logger.hpp>
#include <rad/exceptions.hpp>
#include <rad/assert.hpp>
 
#include <ciiOldbFactory.hpp>
#include <ciiOldbDpValue.hpp>
#include <ciiOldbExceptions.hpp>
#include <ciiOldbUtil.hpp>
 
#include <string>
#include <map>
#include <typeinfo>
#include <chrono>
 
namespace rad {
namespace cii {
 
 
class OldbAdapter {
public:
    OldbAdapter();
 
    explicit OldbAdapter(const std::chrono::seconds conn_timeout);
 
    OldbAdapter(const OldbAdapter&) = default;
 
    virtual ~OldbAdapter();
 
    OldbAdapter& operator=(const OldbAdapter&) = default;
 
    std::shared_ptr<elt::oldb::CiiOldb> GetOldbInstance();
 
    void SetOldbInstance(std::shared_ptr<elt::oldb::CiiOldb> oldb);
 
    void ConfigureConnTimeout(const std::chrono::seconds conn_timeout);
 
    virtual void Connect();
 
    void ClearDataPoints();
 
    std::shared_ptr<elt::oldb::CiiOldbTypedDataBase> GetDataPoint(const std::string& key);
 
    template<typename T>
    void Get(const std::string& key, T& value);
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> Get(const std::string& key);
 
    template<typename T>
    bool TryGet(const std::string& key, T& value) noexcept;
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> TryGet(const std::string& key) noexcept;
 
    template<typename T>
    void Get(const std::string& key, std::vector<T>& value);
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> GetVector(const std::string& key);
 
 
    template<typename T>
    bool TryGet(const std::string& key, std::vector<T>& value) noexcept;
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> TryGetVector(const std::string& key) noexcept;
 
 
    template<typename T>
    void Set(const std::string& key,
            const T& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    template<typename T>
    bool TrySet(const std::string& key,
            const T& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now()) noexcept;
 
    template<typename T>
    void Set(const std::string& key,
            const std::vector<T>& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    template<typename T>
    bool TrySet(const std::string& key,
            const std::vector<T>& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now()) noexcept;
 
    template<typename T>
    void Set(const std::string& key,
            elt::mal::shared_vector<const T>& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    template<typename T>
    bool TrySet(const std::string& key,
            elt::mal::shared_vector<const T>& value,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now()) noexcept;
 
    template<typename T>
    [[deprecated("Should be used only internally, but then use new method GetInternal instead.")]]
    void Get(const std::string& key,
            T& value,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp);
 
    template<typename T>
    [[deprecated("Should be used only internally, but then use new method GetInternal instead.")]]
    void Get(const std::string& key,
            std::vector<T>& values,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp);
 
    template<typename T>
    void Set(const std::string& key,
            const T& value,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    template<typename T>
    void Set(const std::string& key,
            const std::vector<T>& values,
            const bool is_matrix,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    template<typename T>
    void Set(const std::string& key,
            elt::mal::shared_vector<const T>& values,
            const bool is_matrix,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp,
            const std::int64_t timestamp = elt::oldb::CiiOldbUtil::Now());
 
    void Del(const std::string& key);
 
private:
    std::shared_ptr<elt::oldb::CiiOldb> m_oldb;
    std::map<std::string, std::shared_ptr<elt::oldb::CiiOldbTypedDataBase>> m_data_points;
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> GetInternal(const std::string& key,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp);
 
    template<typename T>
    std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> GetInternal(const std::string& key,
            std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp);
};
 
 
template<typename T>
void OldbAdapter::Get(const std::string& key, T& value) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<T>>(it->second);
    }
 
    auto triplet = OldbAdapter::GetInternal(key, dp);
    if (triplet) {
        value = triplet->GetValue();
    }
 
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
}
 
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> OldbAdapter::Get(const std::string& key) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<T>>(it->second);
    }
 
    auto triplet = OldbAdapter::GetInternal(key, dp);
 
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
 
    return triplet;
}
 
 
template<typename T>
bool OldbAdapter::TryGet(const std::string& key, T& value) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        Get<T>(key, value);
        return true;
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of unknown exception.");
        return false;
    }
}
 
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> OldbAdapter::TryGet(const std::string& key) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        return Get<T>(key);
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of " << e.what());
        return nullptr;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of unknown exception.");
        return nullptr;
    }
}
 
 
template<typename T>
void OldbAdapter::Get(const std::string& key, std::vector<T>& value) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<std::vector<T>>>(it->second);
    }
    auto triplet = OldbAdapter::GetInternal(key, dp);
    if (triplet) {
        value = triplet->GetValue();
    }
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
}
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> OldbAdapter::GetVector(const std::string& key) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<std::vector<T>>>(it->second);
    }
 
    auto triplet = OldbAdapter::GetInternal(key, dp);
 
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
 
    return triplet;
}
 
 
template<typename T>
bool OldbAdapter::TryGet(const std::string& key, std::vector<T>& value) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        Get<T>(key, value);
        return true;
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of unknown exception.");
        return false;
    }
}
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> OldbAdapter::TryGetVector(const std::string& key) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        return GetVector<T>(key);
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed reading key " << key << " because of unknown exception.");
        return false;
    }
}
 
 
template<typename T>
void OldbAdapter::Set(const std::string& key, const T& value, const std::int64_t timestamp) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<T>>(it->second);
    }
    Set<T>(key, value, dp, timestamp);
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
}
 
template<typename T>
bool OldbAdapter::TrySet(const std::string& key, const T& value,
        const std::int64_t timestamp) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        Set<T>(key, value, timestamp);
        return true;
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of unknown exception.");
        return false;
    }
}
 
template<typename T>
void OldbAdapter::Set(const std::string& key,
        const std::vector<T>& value,
        const std::int64_t timestamp) {
    RAD_TRACE(GetLogger());
 
    std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>> dp = nullptr;
    auto it = m_data_points.find(key);
    if (it != m_data_points.end()) {
        dp = std::dynamic_pointer_cast<elt::oldb::CiiOldbDataPoint<std::vector<T>>>(it->second);
    }
    Set<T>(key, value, false, dp, timestamp);
    if (it == m_data_points.end() && dp) {
        m_data_points[key] = dp;
    }
}
 
template<typename T>
bool OldbAdapter::TrySet(const std::string& key,
        const std::vector<T>& value,
        const std::int64_t timestamp) noexcept {
    RAD_TRACE(GetLogger());
 
    try {
        Set<T>(key, value, timestamp);
        return true;
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of unknown exception.");
        return false;
    }
}
 
template<typename T>
void OldbAdapter::Set(const std::string& key,
        elt::mal::shared_vector<const T>& value,
        const std::int64_t timestamp) {
    std::vector<T> vec(value.begin(), value.end());
    Set<T>(key, vec, timestamp);
}
 
template<typename T>
bool OldbAdapter::TrySet(const std::string& key,
        elt::mal::shared_vector<const T>& value,
        const std::int64_t timestamp) noexcept {
 
    try {
        std::vector<T> vec(value.begin(), value.end());
        Set<T>(key, vec, timestamp);
        return true;
    } catch (const std::exception& e) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of " << e.what());
        return false;
    } catch (...) {
        LOG4CPLUS_DEBUG(GetLogger(), "Failed writing key " << key << " because of unknown exception.");
        return false;
    }
}
 
template<typename T>
void OldbAdapter::Get(const std::string& key,
        T& value,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp) {
 
    auto triplet = OldbAdapter::GetInternal(key, dp);
    if (triplet) {
        value = triplet->GetValue();
    }
}
 
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<T>> OldbAdapter::GetInternal(const std::string& key,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp) {
 
    RAD_TRACE(GetLogger());
 
    if (m_oldb == nullptr) {
        this->Connect();
        if (m_oldb == nullptr) {
            return nullptr;
        }
    }
 
    try {
        if (dp == nullptr) {
            elt::mal::Uri key_uri(key);
 
            if (m_oldb->DataPointExists(key_uri) == false) {
                LOG4CPLUS_DEBUG(GetLogger(), "Data point not existing " << key_uri);
                return nullptr;
            }
 
            dp = m_oldb->GetDataPoint<T>(key_uri);
            if (dp == nullptr) {
                LOG4CPLUS_DEBUG(GetLogger(), "Data point not existing " << key_uri);
                return nullptr;
            }
        } 
        
        return dp->ReadValue();
    } catch (const std::exception& e) {
        RAD_RETHROW(rad::Exception, e, e.what());
    }
}
 
template<typename T>
void OldbAdapter::Get(const std::string& key,
        std::vector<T>& values,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp) {
    auto triplet = OldbAdapter::GetInternal(key, dp);
    if (triplet) {
        values = triplet->GetValue();
    }
}
 
template<typename T>
std::shared_ptr<elt::oldb::CiiOldbDpValue<std::vector<T>>> OldbAdapter::GetInternal(const std::string& key,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp) {
 
    RAD_TRACE(GetLogger());
 
    if (m_oldb == nullptr) {
        this->Connect();
        if (m_oldb == nullptr) {
            return nullptr;
        }
    }
 
    try {
        if (dp == nullptr) {
            elt::mal::Uri key_uri(key);
 
            if (m_oldb->DataPointExists(key_uri) == false) {
                LOG4CPLUS_DEBUG(GetLogger(), "Data point not existing " << key_uri);
                return nullptr;
            }
 
            dp = m_oldb->GetDataPoint<std::vector<T>>(key_uri);
            if (dp == nullptr) {
                LOG4CPLUS_DEBUG(GetLogger(), "Data point not existing " << key_uri);
                return nullptr;
            }
        }
 
        return dp->ReadValue();
    } catch (const std::exception& e) {
        RAD_RETHROW(rad::Exception, e, e.what());
    }
}
 
 
template<typename T>
void OldbAdapter::Set(const std::string& key,
        const T& value,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<T>>& dp,
        const std::int64_t timestamp) {
    RAD_TRACE(GetLogger());
 
    if (m_oldb == nullptr) {
        this->Connect();
        if (m_oldb == nullptr) return;
    }
 
    try {
        if (dp == nullptr) {
            // Try to create the attribute.
            elt::mal::Uri key_uri(key);
            if (m_oldb->DataPointExists(key_uri) == false) {
                // TODO how to we pass timestamp?
                dp = m_oldb->CreateDataPointByValue<T>(key_uri, value);
            } else {
                dp = m_oldb->GetDataPoint<T>(key_uri);
                if (dp) {
                    dp->WriteValue(value, timestamp);
                } else {
                    // do we log a warning or not?
                    LOG4CPLUS_DEBUG(GetLogger(), "Cannot get data point for key: " << key_uri);
                }
            }
        } else {
            // Try to write
            dp->WriteValue(value, timestamp);
        }
    } catch (const std::exception& e) {
        RAD_RETHROW(rad::Exception, e, e.what());
    }
}
 
template<typename T>
void OldbAdapter::Set(const std::string& key,
        const std::vector<T>& values,
        const bool is_matrix,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp,
        const std::int64_t timestamp) {
    RAD_TRACE(GetLogger());
 
    if (m_oldb == nullptr) {
        Connect();
        if (m_oldb == nullptr) return;
    }
 
    try {
        if (dp == nullptr) {
            // Try to create the vector.
            elt::mal::Uri key_uri(key);
 
            if (m_oldb->DataPointExists(key_uri) == false) {
                dp = m_oldb->CreateDataPointByValue<T>(key_uri, values, is_matrix);
            } else {
                // point already exists
                dp = m_oldb->GetDataPoint<std::vector<T>>(key_uri);
                if (dp) {
                    dp->WriteValue(values, timestamp);
                } else {
                    LOG4CPLUS_DEBUG(GetLogger(), "Cannot get data point for key: " << key_uri);
                }
            }
        } else {
            // Try to write
            dp->WriteValue(values, timestamp);
        }
    } catch (const std::exception& e) {
        RAD_RETHROW(rad::Exception, e, e.what());
    }
}
 
template<typename T>
void OldbAdapter::Set(const std::string& key,
        elt::mal::shared_vector<const T>& values,
        const bool is_matrix,
        std::shared_ptr<elt::oldb::CiiOldbDataPoint<std::vector<T>>>& dp,
        const std::int64_t timestamp) {
    std::vector<T> vec(values.begin(), values.end());
    Set(key, vec, is_matrix, dp, timestamp);
}
 
}  // namespace cii
}  // namespace rad
 
#endif  // RAD_MAL_OLDB_ADAPTER_HPP