adtf_iid.h

Go to the documentation of this file.

#pragma once
 
#include <a_utils/core/result.h>
 
#include <tuple>
#include <type_traits>

#define ADTF_IID(_interface, _striid)               \
    typedef _interface interface_type;              \
    template<_interface*>                           \
    struct interface_info                           \
    {                                               \
        static constexpr const char* IID() noexcept \
        {                                           \
            return _striid;                         \
        }                                           \
    }
 
 
#ifndef UCOM_RESOLVE
    #define UCOM_RESOLVE(...) typedef std::tuple<__VA_ARGS__> hierarchy_type;
#endif // UCOM_RESOLVE
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
// forward declare for usage in "has_interface_expose_type<>"
template<typename...>
class interface_expose;

namespace detail
{

template<typename...>
struct peel_off_first
{
    typedef void type;
};

template<typename T, typename... TRemaining>
struct peel_off_first<T, TRemaining...>
{
    typedef T type; 
}; // template<typename T, typename...> struct peel_off

template<typename T>
struct is_template : ::std::false_type
{
};

template<template<typename...> class C, typename... T>
struct is_template<C<T...>> : ::std::true_type
{
};

template<typename T>
class has_interface_expose_type
{
    struct yes
    {
        char x[1]; 
    };
    struct no
    {
        char x[2]; 
    };

    template<typename C>
    static yes exists(typename C::interface_expose_type*);
    template<typename C>
    static no exists(...);
 
public:
    static constexpr bool value = sizeof(exists<T>(nullptr)) == sizeof(yes);
}; // template<typename T> class has_interface_expose_type

template<typename T>
class has_hierarchy_type
{
    struct yes
    {
        char x[1]; 
    };
    struct no
    {
        char x[2]; 
    };

    template<typename C>
    static yes exists(typename C::hierarchy_type*);
    template<typename C>
    static no exists(...);
 
public:
    static constexpr bool value = sizeof(exists<T>(nullptr)) == sizeof(yes);
}; // template<typename T> class has_hierarchy_type

template<typename T, typename U = T*>
class has_interface_info_type
{
    struct yes
    {
        char x[1]; 
    };
    struct no
    {
        char x[2]; 
    };

    template<typename C>
    static yes exists(typename C::template interface_info<static_cast<C*>(nullptr)>* = nullptr);
    template<typename C>
    static no exists(...);
 
public:
    static constexpr bool value = sizeof(exists<T>(nullptr)) == sizeof(yes);
}; // template<typename T> class has_interface_info_type

template<typename QueriedInterface, typename...>
class find_intermediate : ::std::false_type
{
public:
    typedef void* first_type;
    typedef void* second_type;
    typedef QueriedInterface query_type;
    typedef typename ::std::remove_pointer_t<second_type> value_type;
};

template<typename QueriedInterface, typename... HierarchyTypes>
class find_intermediate<QueriedInterface, ::std::tuple<HierarchyTypes...>>
{
    template<typename...>
    struct extract_pair
    {
        typedef void key_type; 
        typedef void value_type; 
        typedef void tuple_type; 
    };

    template<typename KeyType, typename ValueType, typename... TRemaining>
    struct extract_pair<KeyType, ValueType, TRemaining...>
    {
        typedef KeyType key_type; 
        typedef ValueType value_type; 
        typedef ::std::tuple<TRemaining...> tuple_type; 
    };

    template<typename...>
    struct extract_wrapped_pair;

    template<template<typename, typename> class C, typename KeyType, typename ValueType, typename... TRemaining>
    struct extract_wrapped_pair<C<KeyType, ValueType>, TRemaining...> : extract_pair<KeyType, ValueType, TRemaining...>
    {
    };
 
    // check whether the first type in the tuple is a template or an ordinary type or empty
    using current_type = typename peel_off_first<HierarchyTypes...>::type;
 
    // check which extract_type pair we need to use (wrapped or unwrapped one)
    using extract_pair_type =
        typename ::std::conditional_t<is_template<current_type>::value, // check whether wrapped or ordinary
                                                                        // key-value-pair
                                      extract_wrapped_pair<HierarchyTypes...>,
                                      extract_pair<HierarchyTypes...>>;
 
    // If we found the QueriedInterface as key type of the current extracted key-value-pair,
    // we can stop here. Otherwise call this for the remaining parameters in the parameter pack
    using pair_type = typename ::std::conditional_t<
        ::std::is_same_v<typename ::std::remove_cv_t<QueriedInterface>, typename extract_pair_type::key_type>,
        // using pointers as workaround for problems with typedefing the interfaces later...
        ::std::pair<typename extract_pair_type::key_type*, typename extract_pair_type::value_type*>,
        find_intermediate<QueriedInterface, typename extract_pair_type::tuple_type>>;
 
public:
    // necessary typedefs for recursive calls
    typedef typename pair_type::first_type first_type;
    typedef typename pair_type::second_type second_type;
 
    // necessary typedefs for the user
    typedef typename ::std::remove_pointer_t<first_type> query_type;
    typedef typename ::std::remove_pointer_t<second_type> value_type;
 
    // indicate whether the interface is part of any hierarchy
    static constexpr bool value = !::std::is_void_v<query_type>;
}; // class find_intermediate<QueriedInterface, std::tuple<HierarchyTypes...>>
 
// forward declaration for @ref ucom_resolve()
template<typename InterfaceType, bool Cond>
struct ucom_resolve_helper;

template<typename InterfaceType, typename ObjectType>
static constexpr
    typename ::std::enable_if_t<
        find_intermediate<InterfaceType, typename ObjectType::hierarchy_type>::value, // condition
        typename ::std::conditional_t<::std::is_const_v<ObjectType>, const InterfaceType*, InterfaceType*> // const
                                                                                                           // correct
                                                                                                           // return
                                                                                                           // type
        >
    ucom_resolve(ObjectType* i_pObject) noexcept
{ // cast to the intermediate type and pass this intermediate type further down
    typedef
        typename find_intermediate<InterfaceType, typename ObjectType::hierarchy_type>::value_type intermediate_type;
 
    typedef typename ::std::conditional_t<::std::is_const_v<ObjectType>, const intermediate_type*, intermediate_type*>
        intermediate_pointer;
 
    intermediate_pointer pIntermediate = i_pObject;
    return ucom_resolve_helper<InterfaceType, has_hierarchy_type<intermediate_type>::value>::get(pIntermediate);
}

template<typename InterfaceType, typename ObjectType>
static constexpr
    typename ::std::enable_if_t<
        !find_intermediate<InterfaceType, typename ObjectType::hierarchy_type>::value, // condition
        typename ::std::conditional_t<::std::is_const_v<ObjectType>, const InterfaceType*, InterfaceType*> // const
                                                                                                           // correct
                                                                                                           // return
                                                                                                           // type
        >
    ucom_resolve(ObjectType* i_pObject) noexcept
{ // we cannot cast further down, so just return the pointer
    return i_pObject;
}

template<typename InterfaceType>
struct ucom_resolve_helper<InterfaceType, true>
{
    template<typename IntermediateType>
    static constexpr
        typename ::std::conditional_t<::std::is_const_v<IntermediateType>, const InterfaceType*, InterfaceType*>
        get(IntermediateType* i_pObject) noexcept
    {
        return ucom_resolve<InterfaceType, IntermediateType>(i_pObject);
    }
};

template<typename InterfaceType>
struct ucom_resolve_helper<InterfaceType, false>
{
    template<typename IntermediateType>
    static constexpr
        typename ::std::conditional_t<::std::is_const_v<IntermediateType>, const InterfaceType*, InterfaceType*>
        get(IntermediateType* i_pObject) noexcept
    {
        return i_pObject;
    }
};
 
} // namespace detail

template<typename Interface>
constexpr const char* get_iid() noexcept
{
    typedef typename ::std::remove_const_t<typename ::std::remove_pointer_t<Interface>> value_type;
    static_assert(::std::is_same<value_type, typename value_type::interface_type>::value,
                  "get_iid<> failed. Check whether your interface correctly defined ADTF_IID()");
 
    constexpr typename value_type::interface_type* pNullInstance = nullptr;
    (void) (pNullInstance);
    return value_type::template interface_info<pNullInstance>::IID();
}

template<typename Interface>
constexpr const char* get_iid(const Interface&) noexcept
{
    return get_iid<Interface>();
}

template<typename Interface>
constexpr const char* get_iid(const Interface*) noexcept
{
    return get_iid<Interface>();
}

template<typename... Interfaces>
class interface_expose
{
private:

    template<typename... InterfacesInner>
    struct iid_dispatch
    {
        template<typename Provider, typename VoidType>
        static constexpr tResult dispatch(Provider*, const char*, VoidType*& o_pInterface) noexcept
        {
            o_pInterface = nullptr;
            return ERR_NO_INTERFACE;
        }
    }; // struct iid_dispatch<InterfacesInner...>

    template<typename Interface, typename... InterfacesInner>
    struct iid_dispatch<Interface, InterfacesInner...>
    {
        template<typename ObjectType, typename VoidType>
        static constexpr typename ::std::enable_if_t<detail::has_hierarchy_type<ObjectType>::value, void>
            resolve(ObjectType* i_pObject, VoidType*& o_pInterface) noexcept
        {
            o_pInterface = detail::ucom_resolve<Interface>(i_pObject);
        }

        template<typename ObjectType, typename VoidType>
        static constexpr typename ::std::enable_if_t<!detail::has_hierarchy_type<ObjectType>::value, void>
            resolve(ObjectType* i_pObject, VoidType*& o_pInterface) noexcept
        {
            typedef typename ::std::conditional_t<::std::is_const_v<ObjectType>, const Interface*, Interface*>
                interface_pointer;
            o_pInterface = static_cast<interface_pointer>(i_pObject);
        }

        template<typename Provider, typename VoidType>
        static tResult dispatch(Provider* i_pObj, const char* i_strIID, VoidType*& o_pInterface) noexcept
        { // if Provider is const, we need a const Interface*
            if (adtf_util::cStringUtil::IsEqual(get_iid<Interface>(), i_strIID))
            { // check whether we need to resolve things
                resolve(i_pObj, o_pInterface);
            }
            else
            {
                return iid_dispatch<InterfacesInner...>::dispatch(i_pObj, i_strIID, o_pInterface);
            }
            return ERR_NOERROR;
        }
    }; // struct iid_dispatch<Interface, InterfacesInner...>
 
public:
    interface_expose() = delete;

    template<typename Provider, typename VoidType>
    static tResult Get(Provider* i_pObj, const char* i_strIID, VoidType*& o_pInterface) noexcept
    { // check whether VoidType is either of type void or const void
        static_assert(::std::is_void_v<VoidType>, "\"VoidType\" must be of type void");
        return iid_dispatch<Interfaces...>::dispatch(i_pObj, i_strIID, o_pInterface);
    }
}; // template<typename ...Interfaces> interface_expose

template<typename...>
struct inherit_from
{
};

template<typename...>
struct expose_interfaces
{
};

template<typename...>
struct default_object;

template<typename Child, typename... Interfaces, typename... Parents>
class default_object<inherit_from<Parents...>, expose_interfaces<Interfaces...>, Child> : public Parents...
{
public:
    typedef interface_expose<Interfaces...> interface_expose_type;
 
protected:
    virtual ~default_object()
    {
    }

    virtual tResult GetInterface(const char* i_strIID, void*& o_pInterface) noexcept
    { // if there are any UCOM_RESOLVE() information, these are inside the Child type
        // Use CRTP to perform the cast from this base class to the Child class!
        static_assert(::std::is_base_of_v<default_object, Child>,
                      "The given Child type must be a child type of this default_object type!");
        return interface_expose_type::Get(static_cast<Child*>(this), i_strIID, o_pInterface);
    }

    virtual tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const noexcept
    { // if there are any UCOM_RESOLVE() information, these are inside the Child type
        // Use CRTP to perform the cast from this base class to the Child class!
        static_assert(::std::is_base_of_v<default_object, Child>,
                      "The given Child type must be a child type of this default_object type!");
        return interface_expose_type::Get(static_cast<const Child*>(this), i_strIID, o_pInterface);
    }

    [[deprecated("Use of Destroy results in a mismatched deallocation. Use adtf::ucom::allocate_object_ptr "
                 "instead.")]] virtual void
        Destroy() const
    {
        delete this;
    }
}; // class default_object<inherit_from<Parents...>,expose_interfaces<Interfaces...>>

template<typename BASE_OBJECT, typename EXTEND_INTERFACE, typename Child>
class extend_object : public BASE_OBJECT, public EXTEND_INTERFACE
{
public:
    typedef BASE_OBJECT base_type; 
 
protected:
    virtual ~extend_object()
    {
    }

    virtual tResult GetInterface(const char* i_strIID, void*& o_pInterface) noexcept
    { // cast this to its child class using CRPT to get possible UCOM_RESOLVE() information
        static_assert(::std::is_base_of_v<extend_object, Child>,
                      "The given Child type must be a child type of this extend_object type!");
        if (IS_FAILED(interface_expose<EXTEND_INTERFACE>::Get(static_cast<Child*>(this), i_strIID, o_pInterface)))
        {
            return BASE_OBJECT::GetInterface(i_strIID, o_pInterface);
        }
        RETURN_NOERROR;
    }

    virtual tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const noexcept
    { // cast this to its child class using CRPT to get possible UCOM_RESOLVE() information
        static_assert(::std::is_base_of_v<extend_object, Child>,
                      "The given Child type must be a child type of this extend_object type!");
        if (IS_FAILED(interface_expose<EXTEND_INTERFACE>::Get(static_cast<const Child*>(this), i_strIID, o_pInterface)))
        {
            return BASE_OBJECT::GetInterface(i_strIID, o_pInterface);
        }
        RETURN_NOERROR;
    }

    [[deprecated("Use of Destroy results in a mismatched deallocation. Use adtf::ucom::allocate_object_ptr "
                 "instead.")]] virtual void
        Destroy() const
    {
        delete this;
    }
}; // template<typename BASE_OBJECT, typename EXTEND_INTERFACE> class extend_object
 
// template<typename BASE_OBJECT, typename EXTEND_INTERFACE>
// class extend_object<BASE_OBJECT, EXTEND_INTERFACE, void> :
//     public extend_object
//            <
//                 BASE_OBJECT,
//                 EXTEND_INTERFACE,
//                 extend_object<BASE_OBJECT, EXTEND_INTERFACE>
//            >
//{};
 
} // namespace ant

using ant::get_iid;

template<typename... Interfaces>
using interface_expose = ant::interface_expose<Interfaces...>;

template<typename... ParentTypes>
using inherit_from = ant::inherit_from<ParentTypes...>;

template<typename... InterfaceTypes>
using expose_interfaces = ant::expose_interfaces<InterfaceTypes...>;

template<typename... Types>
using default_object = ant::default_object<Types...>;

template<typename BASE_CLASS, typename EXTEND_INTERFACE, typename Child>
using extend_object = ant::extend_object<BASE_CLASS, EXTEND_INTERFACE, Child>;
 
} // namespace ucom
} // namespace adtf