extension.h

Go to the documentation of this file.

// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2017 Intel Corporation. All Rights Reserved.

#pragma once
#include "../../include/librealsense2/h/rs_types.h"
#include <memory>
#include <functional>

#define MAP_EXTENSION(E, T)                                      \
    template<> struct ExtensionToType<E> {                       \
        using type = T;                                          \
        static constexpr const char* to_string() { return #T; }; \
    };                                                           \
    template<> struct TypeToExtension<T> {                       \
        static constexpr rs2_extension value = E;                \
        static constexpr const char* to_string() { return #T; }; \
    }                                                            \

namespace librealsense
{
    class extendable_interface
    {
    public:
        virtual bool extend_to(rs2_extension extension_type, void** ptr) = 0;
        virtual ~extendable_interface() = default;
    };

    class extension_snapshot
    {
    public:
        virtual void update(std::shared_ptr<extension_snapshot> ext) = 0;
        virtual ~extension_snapshot() = default;
    };

    template <typename T>
    class recordable
    {
    public:
        virtual void create_snapshot(std::shared_ptr<T>& snapshot) const = 0;

        virtual void enable_recording(std::function<void(const T&)> recording_function) = 0;

        virtual ~recordable() = default;

    };

    /*
     * Helper functions
     *
     */

    template <typename To>
    inline bool try_extend(std::shared_ptr<extension_snapshot> from, void** ext)
    {
        if (from == nullptr)
        {
            return false;
        }

        auto casted = std::dynamic_pointer_cast<To>(from);
        if (casted == nullptr)
        {
            return false;
        }
        *ext = casted.get();
        return true;
    }

    template<typename T, typename P>
    inline std::shared_ptr<T> As(std::shared_ptr<P> ptr)
    {
        return std::dynamic_pointer_cast<T>(ptr);
    }

    template<typename T, typename P>
    inline T* As(P* ptr)
    {
        return dynamic_cast<T*>(ptr);
    }

    template<typename T, typename P>
    inline bool Is(std::shared_ptr<P> ptr)
    {
        return As<T>(ptr) != nullptr;
    }

    template<typename T, typename P>
    inline bool Is(P* ptr)
    {
        return As<T>(ptr) != nullptr;
    }
    //Creating Helper functions to map rs2_extension enums to actual interface
    template<rs2_extension> struct ExtensionToType;
    template<typename T> struct TypeToExtension;
}