object.h

Go to the documentation of this file.

#pragma once
 
namespace adtf
{
namespace ucom
{
namespace catwo
{
namespace detail
{

template<typename T>
class has_interface_type : private T
{
    typedef char one;
    typedef long two;
 
    template<typename C> static one test(typename C::interface_type*);
    template<typename C> static two test(...);
 
public:
    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) };
};
class has_interface_type : private T {…};
 
template <typename T>
using is_interface_helper = std::is_same<T, typename T::interface_type>; // see get_iid

template<typename T, typename Enable = void>
struct is_interface;
 
template<typename T>
struct is_interface<T, typename std::enable_if<!has_interface_type<T>::value>::type> : std::false_type
{
};
struct is_interface<T, typename std::enable_if<!has_interface_type<T>::value>::type> : std::false_type {…};
 
template<typename T>
struct is_interface<T, typename std::enable_if<has_interface_type<T>::value && !is_interface_helper<T>::value>::type> : std::false_type
{
};
struct is_interface<T, typename std::enable_if<has_interface_type<T>::value && !is_interface_helper<T>::value>::type> : std::false_type {…};
 
template<typename T>
struct is_interface<T, typename std::enable_if<has_interface_type<T>::value && is_interface_helper<T>::value>::type> : std::true_type
{
};
struct is_interface<T, typename std::enable_if<has_interface_type<T>::value && is_interface_helper<T>::value>::type> : std::true_type {…};

template <typename T>
class has_get_interface: private T
{
    typedef char one;
    typedef long two;
 
    template <typename C> static one test(decltype(static_cast<tResult(T::*)(const char*, void*&)>(&has_get_interface<C>::GetInterface)));
    template <typename C> static two test(...);
 
public:
    enum { value = sizeof(test<T>(static_cast<tResult(T::*)(const char*, void*&)>(nullptr))) == sizeof(char) };
};
class has_get_interface: private T {…};
 
// template that dispatches type resolution to static error, dynamic GetInterface or inline type comparison
template<typename BaseClass, typename Enable = void>
struct base_dispatcher;
 
template<>
struct base_dispatcher<void, void>
{
protected:
    virtual ~base_dispatcher() = default;
 
    inline tResult GetInterfaceStatic(const char* /* i_strIID */, void*& /* o_pInterface */)
    {
        RETURN_ERROR(ERR_NO_INTERFACE);
    }
 
    inline tResult GetInterfaceStatic(const char* /* i_strIID */, const void*& /* o_pInterface */) const
    {
        RETURN_ERROR(ERR_NO_INTERFACE);
    }
 
public:
    enum { dispatch = false };
};
struct base_dispatcher<void, void> {…};
 

template<typename BaseClass>
struct base_dispatcher<BaseClass, typename std::enable_if<!is_interface<BaseClass>::value && !has_get_interface<BaseClass>::value>::type> :
    public BaseClass
{
    protected:
        using BaseClass::BaseClass;
 
        virtual ~base_dispatcher() = default;
 
        inline tResult GetInterfaceStatic(const char* /* i_strIID */, void*& /* o_pInterface */)
        {
            RETURN_ERROR(ERR_NO_INTERFACE);
        }
 
        inline tResult GetInterfaceStatic(const char* /* i_strIID */, const void*& /* o_pInterface */) const
        {
            RETURN_ERROR(ERR_NO_INTERFACE);
        }
};
struct base_dispatcher<BaseClass, typename std::enable_if<!is_interface<BaseClass>::value && !has_get_interface<BaseClass>::value>::type> : {…};
 

template <typename BaseClass>
struct base_dispatcher<BaseClass, typename std::enable_if<!is_interface<BaseClass>::value && has_get_interface<BaseClass>::value>::type> :
    public BaseClass
{
    protected:
        using BaseClass::BaseClass;
 
        virtual ~base_dispatcher() = default;
 
        inline tResult GetInterfaceStatic(const char* i_strIID, void*& o_pInterface)
        {
            return BaseClass::GetInterface(i_strIID, o_pInterface);
        }
 
        inline tResult GetInterfaceStatic(const char* i_strIID, const void*& o_pInterface) const
        {
            return BaseClass::GetInterface(i_strIID, o_pInterface);
        }
};
struct base_dispatcher<BaseClass, typename std::enable_if<!is_interface<BaseClass>::value && has_get_interface<BaseClass>::value>::type> : {…};

template <typename Interface>
struct base_dispatcher<Interface, typename std::enable_if<is_interface<Interface>::value>::type>:
    Interface
{
    protected:
        using Interface::Interface;
 
        virtual ~base_dispatcher() = default;
 
        inline tResult GetInterfaceStatic(const char* i_strIID, void*& o_pInterface)
        {
            if (util::cStringUtil::IsEqual(ucom::get_iid<Interface>(), i_strIID))
            {
                o_pInterface = static_cast<Interface*>(this);
                RETURN_NOERROR;
            }
 
            RETURN_ERROR(ERR_NO_INTERFACE);
        }
 
        inline tResult GetInterfaceStatic(const char* i_strIID, const void*& o_pInterface) const
        {
            if (util::cStringUtil::IsEqual(ucom::get_iid<Interface>(), i_strIID))
            {
                o_pInterface = static_cast<const Interface*>(this);
                RETURN_NOERROR;
            }
 
            RETURN_ERROR(ERR_NO_INTERFACE);
        }
};
struct base_dispatcher<Interface, typename std::enable_if<is_interface<Interface>::value>::type>: {…};

template <typename Base, typename NextBase>
class derive_from_without_hierarchy:
    public base_dispatcher<Base>,
    public base_dispatcher<NextBase>
{
    protected:
        using base_dispatcher<Base>::base_dispatcher;
 
        tResult GetInterface(const char* i_strIID, void*& o_pInterface)
        {
            if (IS_OK(base_dispatcher<Base>::GetInterfaceStatic(i_strIID, o_pInterface)))
            {
                RETURN_NOERROR;
            }
 
            return base_dispatcher<NextBase>::GetInterfaceStatic(i_strIID, o_pInterface);
        }
 
        tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const
        {
            if (IS_OK(base_dispatcher<Base>::GetInterfaceStatic(i_strIID, o_pInterface)))
            {
                RETURN_NOERROR;
            }
 
            return base_dispatcher<NextBase>::GetInterfaceStatic(i_strIID, o_pInterface);
        }
 
        // Base interface is deprecated, but still needs to be overloaded to be able to correctly call the destructor.
#if defined(__GNUC__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        void Destroy() const
        {
            delete this;
        }
        void Destroy() const {…}
#if defined(__GNUC__)
    #pragma GCC diagnostic pop
#endif
};
class derive_from_without_hierarchy: {…};

template <typename Base, typename NextBase>
class derive_from_with_hierarchy:
    public derive_from_without_hierarchy<Base, NextBase>
{
    public:
        UCOM_RESOLVE(ucom::ant::IObject, Base)
 
    protected:
        using derive_from_without_hierarchy<Base, NextBase>::derive_from_without_hierarchy;
};
class derive_from_with_hierarchy: {…};
 
template<typename Base, typename ...Interfaces>
class expose_additional_interfaces: public detail::base_dispatcher<Base>
{
    protected:
        using detail::base_dispatcher<Base>::base_dispatcher;
 
        tResult GetInterface(const char* i_strIID, void*& o_pInterface)
        {
            if (IS_OK(detail::base_dispatcher<Base>::GetInterfaceStatic(i_strIID, o_pInterface)))
            {
                RETURN_NOERROR;
            }
            return ucom::ant::interface_expose<Interfaces...>::Get(this, i_strIID, o_pInterface);
        }
 
        tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const
        {
            if (IS_OK(detail::base_dispatcher<Base>::GetInterfaceStatic(i_strIID, o_pInterface)))
            {
                RETURN_NOERROR;
            }
            return ucom::ant::interface_expose<Interfaces...>::Get(this, i_strIID, o_pInterface);
        }
 
        // Base interface is deprecated, but still needs to be overloaded to be able to correctly call the destructor.
#if defined(__GNUC__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        void Destroy() const
        {
            delete this;
        }
        void Destroy() const {…}
#if defined(__GNUC__)
    #pragma GCC diagnostic pop
#endif
};
class expose_additional_interfaces: public detail::base_dispatcher<Base> {…};

template <typename ...Bases>
class object_without_iobject
{
};
class object_without_iobject {…};

template <typename Base, typename NextBase>
using derive_from_type = typename std::conditional<std::is_same<NextBase, object_without_iobject<>>::value,
                                                   expose_additional_interfaces<Base>,
                                                   typename std::conditional<std::is_base_of<Base, NextBase>::value,
                                                                            expose_additional_interfaces<NextBase, Base>,
                                                                            typename std::conditional<std::is_base_of<ucom::ant::IObject, Base>::value,
                                                                                                      derive_from_with_hierarchy<Base, NextBase>,
                                                                                                      derive_from_without_hierarchy<Base, NextBase>>::type>::type>::type;

template <typename Base, typename NextBase>
class derive_from: public derive_from_type<Base, NextBase>
{
    public:
        using derive_from_type<Base, NextBase>::derive_from_type;
};
class derive_from: public derive_from_type<Base, NextBase> {…};

template <typename ...Bases>
struct parent_follows_child: std::false_type
{
};
struct parent_follows_child: std::false_type {…};

template <typename Base, typename NextBase, typename ...Bases>
struct parent_follows_child<Base, NextBase, Bases...>:
        std::conditional<!std::is_same<NextBase, Base>::value &&
                         std::is_base_of<NextBase, Base>::value,
                         std::true_type,
                         parent_follows_child<Base, Bases...>>::type
{
};
struct parent_follows_child<Base, NextBase, Bases...>: {…};

template <typename Base, typename ...Bases>
class object_without_iobject<Base, Bases...>:
    public derive_from<Base, object_without_iobject<Bases...>>
{
    public:
        object_without_iobject()
        {
            static_assert(!detail::parent_follows_child<Base, Bases...>::value,
                          "One or more of the template parameters are in the wrong order. "
                          "Make sure that derived classes are specified after their parents.");
        }
 
    protected:
        using derive_from<Base, object_without_iobject<Bases...>>::derive_from;
};
class object_without_iobject<Base, Bases...>: {…};
 
}//detail

template <typename ...Bases>
class object:
    public ucom::ant::IObject
{
    public:
        virtual ~object() = default;
 
        tResult GetInterface(const char* i_strIID, void*& o_pInterface) override
        {
            return ucom::ant::interface_expose<ucom::ant::IObject>::Get(this, i_strIID, o_pInterface);
        }
        tResult GetInterface(const char* i_strIID, void*& o_pInterface) override {…}
 
        tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const override
        {
            return ucom::ant::interface_expose<ucom::ant::IObject>::Get(this, i_strIID, o_pInterface);
        }
        tResult GetInterface(const char* i_strIID, const void*& o_pInterface) const override {…}
 
        // Base interface is deprecated, but still needs to be overloaded to be able to correctly call the destructor.
#if defined(__GNUC__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
        void Destroy() const override
        {
            delete this;
        }
        void Destroy() const override {…}
#if defined(__GNUC__)
    #pragma GCC diagnostic pop
#endif
};
class object: {…};
 
// Workaround for MSVC bug where writing this template inline twice would not be recognized as being the same base class
template<typename Base, typename... Bases>
using object_base_type_helper =
    typename std::conditional<std::is_base_of<object<>, Base>::value,
                              detail::derive_from<Base, detail::object_without_iobject<Bases...>>,
                              detail::derive_from<Base, object<Bases...>>>::type;

template<typename Base, typename... Bases>
class object<Base, Bases...> : public object_base_type_helper<Base, Bases...>
{
public:
    using object_base_type_helper<Base, Bases...>::object_base_type_helper;
 
    object()
    {
        static_assert(!detail::parent_follows_child<Base, Bases...>::value,
                      "One or more of the template parameters are in the wrong order. "
                      "Make sure that derived classes are specified after their parents.");
    }
};
class object<Base, Bases...> : public object_base_type_helper<Base, Bases...> {…};
 
}//namespace catwo
 
using catwo::object;
 
}//namespace ucom
}//namespace adtf