oldbAdapterLegacy.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_OLDBADAPTERLEGACY_HPP
#define RTCTK_COMPONENTFRAMEWORK_OLDBADAPTERLEGACY_HPP
 
#include <rtctk/componentFramework/oldbIf.hpp>
#include <rtctk/componentFramework/requestDispatcher.hpp>
 
#include <ciiOldb.hpp>
#include <ciiOldbSubscription.hpp>
#include <ciiOldbTypedDataBase.hpp>
 
#include <functional>
#include <typeindex>
 
namespace rtctk::componentFramework {
 
class OldbAdapterLegacy : public OldbIf {
public:
    inline static const std::string SUPPORTED_URI_SCHEME = "cii.oldb.legacy";
 
    OldbAdapterLegacy() = delete;
 
    OldbAdapterLegacy(const OldbAdapterLegacy&) = delete;
 
    OldbAdapterLegacy& operator=(const OldbAdapterLegacy&) = delete;
 
    OldbAdapterLegacy(OldbAdapterLegacy&&) = default;
 
    OldbAdapterLegacy& operator=(OldbAdapterLegacy&&) = default;
 
    explicit OldbAdapterLegacy(const elt::mal::Uri& baseuri);
 
    explicit OldbAdapterLegacy(const elt::mal::Uri& baseuri,
                               const std::shared_ptr<elt::oldb::CiiOldb>& oldb);
 
    virtual ~OldbAdapterLegacy();
 
    elt::mal::Uri GetBaseUri() const {
        return m_baseuri;
    }
 
    using RepositoryIf::CreateDataPoint;
 
    void CreateDataPoint(const DataPointPath& path, const std::type_info& type) override;
 
protected:
    void DeleteDataPointLegacy(const DataPointPath& path) override;
 
    const std::type_info& GetDataPointTypeLegacy(const DataPointPath& path) const override;
 
    std::size_t GetDataPointSizeLegacy(const DataPointPath& path) const override;
 
    bool DataPointExistsLegacy(const DataPointPath& path) const override;
    std::pair<PathList, PathList> GetChildrenLegacy(const DataPointPath& path) const override;
 
public:
    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 OldbAdapterLegacy*, const DataPointPath&, void*)>;
        using WriteFunction =
            std::function<void(const OldbAdapterLegacy*, const DataPointPath&, const void*)>;
        using RegisterFunction =
            std::function<void(const OldbAdapterLegacy*, 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>
    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;
 
    // The following helper methods and mappings redirect calls from the new API to the legacy
    // implementation methods.
    template <typename T>
    void CreateImpl(detail::CreateRequest<T>& req);
 
    template <typename T>
    void ReadImpl(detail::ReadRequest<T>& req);
 
    template <typename T>
    void WriteImpl(detail::WriteRequest<T>& req);
 
    template <typename T>
    void PartialReadImpl(detail::PartialReadRequest<T>& req);
 
    template <typename T>
    void PartialWriteImpl(detail::PartialWriteRequest<T>& req);
 
    void ReadMetaDataImpl(detail::ReadMetaDataRequest& req);
    void WriteMetaDataImpl(detail::WriteMetaDataRequest& req);
    void DeleteImpl(detail::DeleteRequest& req);
    void ExistsImpl(detail::ExistsRequest& req);
    void GetChildrenImpl(detail::GetChildrenRequest& req);
    void CreateLinkImpl(detail::CreateSymlinkRequest& req);
    void UpdateLinkImpl(detail::UpdateSymlinkRequest& req);
    void SubscribeImpl(detail::ValueSubscribeRequest& req);
    void CreateDeleteSubscribeImpl(detail::CreateDeleteSubscribeRequest& req);
    void UnsubscribeImpl(detail::UnsubscribeRequest& req);
 
    BatchResponse ProcessRequests(const RequestList& requests) override;
 
    template <typename T>
    static RequestDispatcher<OldbAdapterLegacy>::TableEntries BindTypeHandlers();
 
    static const RequestDispatcher<OldbAdapterLegacy> S_REQUEST_DISPATCHER;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_OLDBADAPTERLEGACY_HPP