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 const char* IID()       \
        {                              \
            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 const 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 const 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 const 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<second_type>::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
    typedef typename peel_off_first<HierarchyTypes...>::type                    current_type;
 
    //check which extract_type pair we need to use (wrapped or unwrapped one)
    typedef typename
        std::conditional
        <
            is_template<current_type>::value,    //check whether wrapped or ordinary key-value-pair
            extract_wrapped_pair<HierarchyTypes...>,
            extract_pair<HierarchyTypes...>
        >::type                                                                 extract_pair_type;
 
    //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
    typedef typename
        std::conditional
        <
            std::is_same
            <
                typename std::remove_cv<QueriedInterface>::type,
                typename extract_pair_type::key_type
            >::value,
            //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>
        >::type                                                                 pair_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<first_type>::type                      query_type;
    typedef typename std::remove_pointer<second_type>::type                     value_type;
 
    //indicate whether the interface is part of any hierarchy
    static const bool value = !std::is_void<query_type>::value;
};//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 typename
    std::enable_if
    <
        find_intermediate< InterfaceType, typename ObjectType::hierarchy_type >::value, //condition
        typename std::conditional   //const correct return type
        <
            std::is_const<ObjectType>::value,
            const InterfaceType*,
            InterfaceType*
        >::type
    >::type
ucom_resolve(ObjectType* i_pObject)
{   //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
        <
            std::is_const<ObjectType>::value,
            const intermediate_type*,
            intermediate_type*
        >::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 typename
    std::enable_if
    <
        !find_intermediate< InterfaceType, typename ObjectType::hierarchy_type >::value,//condition
        typename std::conditional   //const correct return type
        <
            std::is_const<ObjectType>::value,
            const InterfaceType*,
            InterfaceType*
        >::type
    >::type
ucom_resolve(ObjectType* i_pObject)
{   //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 typename std::conditional
                 <
                    std::is_const<IntermediateType>::value,
                    const InterfaceType*,
                    InterfaceType*
                 >::type
    get(IntermediateType* i_pObject)
    {
        return ucom_resolve<InterfaceType, IntermediateType>(i_pObject);
    }
};
 
template<typename InterfaceType>
struct ucom_resolve_helper<InterfaceType, false>
{
    template<typename IntermediateType>
        static typename std::conditional
                 <
                    std::is_const<IntermediateType>::value,
                    const InterfaceType*,
                    InterfaceType*
                 >::type
    get(IntermediateType* i_pObject)
    {
        return i_pObject;
    }
};
 
}//ns detail
 
template<typename Interface>
const char* get_iid()
{
    using namespace std;    //remove_const, remove_pointer, is_same
    typedef typename remove_const<typename remove_pointer<Interface>::type>::type value_type;
    static_assert(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> const char* get_iid(const Interface&) 
{ 
    return get_iid<Interface>(); 
}
 
template<typename Interface> const char* get_iid(const Interface*)
{
    return get_iid<Interface>();
}
 
template<typename ...Interfaces>
class interface_expose
{
private:
 
    template<typename ...InterfacesInner>
    struct iid_dispatch
    {
        template<typename Provider, typename VoidType>
        static tResult dispatch(Provider*, const char*, VoidType*& o_pInterface)
        {
            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 typename std::enable_if<detail::has_hierarchy_type<ObjectType>::value, void>::type
            resolve(ObjectType* i_pObject, VoidType*& o_pInterface)
        {
            o_pInterface = detail::ucom_resolve<Interface>(i_pObject);
        }
 
        template<typename ObjectType, typename VoidType>
        static typename std::enable_if<!detail::has_hierarchy_type<ObjectType>::value, void>::type
            resolve(ObjectType* i_pObject, VoidType*& o_pInterface)
        {
            typedef typename std::conditional
                             <
                                std::is_const<ObjectType>::value,
                                const Interface*,
                                Interface*
                             >::type                                            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)
        {   //if Provider is const, we need a const Interface*
            using namespace std;    //std::conditional, std::is_const
            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)
    {   //check whether VoidType is either of type void or const void
        static_assert(std::is_void<VoidType>::value, "\"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)
    {   //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<default_object, Child>::value,
                      "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
    {   //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<default_object, Child>::value,
                      "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)
    {   //cast this to its child class using CRPT to get possible UCOM_RESOLVE() information
        static_assert(std::is_base_of<extend_object, Child>::value,
                      "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
    {   //cast this to its child class using CRPT to get possible UCOM_RESOLVE() information
        static_assert(std::is_base_of<extend_object, Child>::value,
                      "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>
//           >
//{};
 
}//ns 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>;
 
}//ns ucom
}//ns adtf