oldbAdapter.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP
#define RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP
 
#include <functional>
#include <typeindex>
 
#include <ciiOldb.hpp>
#include <ciiOldbSubscription.hpp>
#include <ciiOldbTypedDataBase.hpp>
 
#include <rtctk/componentFramework/oldbIf.hpp>
 
namespace rtctk::componentFramework {
 
class OldbAdapter : public OldbIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "cii.oldb";
 
    OldbAdapter() = delete;
 
    OldbAdapter(const OldbAdapter&) = delete;
 
    OldbAdapter& operator=(const OldbAdapter&) = delete;
 
    OldbAdapter(OldbAdapter&&) = default;
 
    OldbAdapter& operator=(OldbAdapter&&) = default;
 
    explicit OldbAdapter(const elt::mal::Uri& baseuri);
 
    explicit OldbAdapter(const elt::mal::Uri& baseuri,
                         const std::shared_ptr<elt::oldb::CiiOldb>& oldb);
 
    virtual ~OldbAdapter();
 
    elt::mal::Uri GetBaseUri() const {
        return m_baseuri;
    }
 
    using RepositoryIf::CreateDataPoint;
 
    void CreateDataPoint(const DataPointPath& path, const std::type_info& type) override;
 
    void DeleteDataPoint(const DataPointPath& path) override;
 
    const std::type_info& GetDataPointType(const DataPointPath& path) const override;
 
    std::size_t GetDataPointSize(const DataPointPath& path) const override;
 
    bool DataPointExists(const DataPointPath& path) const override;
    std::pair<PathList, PathList> GetChildren(const DataPointPath& path) const override;
    Response SendReadRequest(const ReadRequest& request) const override;
    Response SendWriteRequest(const WriteRequest& request) override;
    Response SendSubscribeRequest(const SubscribeRequest& request) const override;
    Response SendUnsubscribeRequest(const UnsubscribeRequest& request) const override;
 
    static void InitMetadata();
 
protected:
    void SetMetadataInstanceMap(const std::map<std::type_index, std::string>& map);
 
    void SetTypeInfoMap(const std::map<std::string, const std::type_info&>& map);
 
    elt::oldb::CiiOldbDpCreateContext GetDataPointCreateContext() const;
 
    void SetDataPointCreateContext(elt::oldb::CiiOldbDpCreateContext& context);
 
private:
    template <typename R, typename F>
    Response ProcessRequest(const R& request, F selector) const;
 
    template <typename T>
    void ReadData(const DataPointPath& path, T& buffer) const;
 
    template <typename T>
    void WriteData(const DataPointPath& path, const T& buffer) const;
 
    template <typename T>
    void RegisterSubscription(const SubscribeRequest::Parameters& params) const;
 
    struct IoFunctionMapEntry {
        using ReadFunction = std::function<void(const OldbAdapter*, const DataPointPath&, void*)>;
        using WriteFunction =
            std::function<void(const OldbAdapter*, const DataPointPath&, const void*)>;
        using RegisterFunction =
            std::function<void(const OldbAdapter*, const SubscribeRequest::Parameters&)>;
 
        ReadFunction m_read_function;
        WriteFunction m_write_function;
        RegisterFunction m_register_function;
    };
 
    using IoFunctionMap = std::map<std::type_index, IoFunctionMapEntry>;
 
    template <typename T>
    static auto MakeMapEntry();
 
    struct SubscriptionEntry {
        std::shared_ptr<elt::oldb::CiiOldbTypedDataBase> m_datapoint;
        std::shared_ptr<elt::oldb::CiiOldbDpSubscriptionBase> m_subscription;
 
        std::function<bool(const SubscriptionEntry&, const UnsubscribeRequest::Parameters&)>
            m_unregister_callback;
    };
 
    using SubsciptionMap = std::list<SubscriptionEntry>;
 
    template <typename T, typename U, typename V>
    void CastAndRegisterSubscription(
        const SubscribeRequest::Parameters& params,
        const std::shared_ptr<elt::oldb::CiiOldbTypedDataBase>& datapoint,
        std::function<void(T*, const std::shared_ptr<elt::oldb::CiiOldbDpValue<U>>&)>
            write_function) const;
 
    mutable std::shared_ptr<elt::oldb::CiiOldb> m_client;
 
    const elt::mal::Uri m_baseuri;
 
    mutable std::list<SubscriptionEntry> m_subscriptions;
 
    mutable std::mutex m_mutex;
 
    const std::map<std::type_index, std::string>* m_metadata_instance_map = nullptr;
 
    static const std::map<std::type_index, std::string> S_METADATA_INSTANCE_MAP;
 
    const std::map<std::string, const std::type_info&>* m_type_info_map = nullptr;
 
    static const std::map<std::string, const std::type_info&> S_TYPE_INFO_MAP;
 
    static const IoFunctionMap S_IO_FUNCTIONS;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_OLDBADAPTER_HPP