FeatureBase.hpp

Go to the documentation of this file.

#pragma once
#ifndef LVR2_IO_GFeatureBase_HPP
#define LVR2_IO_GFeatureBase_HPP

#include <memory>
#include <tuple>
#include <type_traits>

#include "lvr2/io/descriptions/FileKernel.hpp"
#include "lvr2/io/descriptions/ScanProjectSchema.hpp"

namespace lvr2 {

template<template<typename> typename Feature, typename Derived>
struct FeatureConstruct;


template<template<typename> typename ...Features>
class FeatureBase : public Features<FeatureBase<Features...> >...
{
protected:
    template <typename T, typename Tuple>
    struct has_type;

    template <typename T>
    struct has_type<T, std::tuple<>> : std::false_type {};

    template <typename T, typename U, typename... Ts>
    struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};

    template <typename T, typename... Ts>
    struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};

public:
    static constexpr std::size_t N = sizeof...(Features);
    using features = std::tuple<Features<FeatureBase<Features...> >...>;

    template<template<typename> typename F> 
    struct has_feature {
        static constexpr bool value = has_type<F<FeatureBase>, features>::type::value;
    };

    template<
        template<typename> typename F,
        template<typename> typename ...Fs
    >
    struct add_features;

    template<
        template<typename> typename F,
        template<typename> typename ...Fs
    >
    struct add_features {
        using type = typename add_features<F>::type::template add_features<Fs...>::type;
    };

    template<
        template<typename> typename F
    >
    struct add_features<F> {
        using type = typename std::conditional<
            FeatureBase<Features...>::has_feature<F>::value,
            FeatureBase<Features...>,
            FeatureBase<Features...,F>
            >::type;
    };

    template<template<typename> typename F>
    struct add_feature {
        using type = typename add_features<F>::type;
    };

    template<
        template<typename> typename F,
        template<typename> typename ...Fs
    >
    struct add_features_with_deps;

    template<
        template<typename> typename F,
        template<typename> typename ...Fs
    >
    struct add_features_with_deps {
        using type = typename add_features_with_deps<F>::type::template add_features_with_deps<Fs...>::type;
    };

    template<template<typename> typename F>
    struct add_features_with_deps<F> {
        using type = typename FeatureConstruct<F, FeatureBase<Features...> >::type;
    };



    template<template<typename> typename F>
    static constexpr bool HasFeature = has_feature<F>::value;
    
    template<template<typename> typename ...F>
    using AddFeatures = typename add_features_with_deps<F...>::type;

    template<typename OTHER>
    using Merge = typename OTHER::template add_features<Features...>::type;


    #if __cplusplus <= 201500L
        // feature of c++17
        #pragma message("using Tp::save... needs c++17 at least or a newer compiler")
    #endif

    //using Features<FeatureBase<Features...> >::save...;

    FeatureBase(
        const FileKernelPtr inKernel, 
        const ScanProjectSchemaPtr inDesc) : m_kernel(inKernel), m_description(inDesc)
    {

    }

    virtual ~FeatureBase() {}

    template<template<typename> typename F>
    bool has();

    template<template<typename> typename F>
    F<FeatureBase>* scast();

    template<template<typename> typename F>
    F<FeatureBase>* dcast();

    const FileKernelPtr             m_kernel;
    const ScanProjectSchemaPtr      m_description;

};

template<template<typename> typename Feature, typename Derived = FeatureBase<> >
struct FeatureConstruct {
    using type = typename Derived::template add_features<Feature>::type;
};

template<template<typename> typename Feature>
using FeatureBuild = typename FeatureConstruct<Feature>::type;


} // namespace lvr2

#include "FeatureBase.tcc"

#endif // LVR2_IO_GFeatureBase_HPP