ucom_cast.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_UCOM_CAST_INCLUDES_HEADER_
#define _ADTF_UCOM_ANT_UCOM_CAST_INCLUDES_HEADER_
 
#include <cstddef>
#include <typeinfo>
#include <limits>
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
class IObject; // forward declaration for ucom_cast_convert template

namespace detail
{
struct ucom_cast_cache final
{
    static constexpr auto cache_miss = (::std::numeric_limits<::std::ptrdiff_t>::lowest)();
    static constexpr auto interface_not_found = (::std::numeric_limits<::std::ptrdiff_t>::max)();
    static ::std::ptrdiff_t& open_cache_line(const IObject* pBase, const ::std::type_info* pTargetType) noexcept;
};

template<typename QueriedInterfaceType, bool>
struct ucom_cast_to_implicit_cast final
{
    template<typename ObjectType>
    static QueriedInterfaceType* perform_cast(ObjectType* i_pObject) noexcept
    {
        // provided for const correctness
        using interface_type =
            typename ::std::conditional_t<::std::is_const_v<QueriedInterfaceType>, const IObject, IObject>;
        using base_pointer =
            typename ::std::conditional_t<::std::is_const_v<QueriedInterfaceType>, const IObject*, IObject*>;
        using void_pointer = typename ::std::conditional_t<::std::is_const_v<QueriedInterfaceType>, const void*, void*>;
        using memory_type = typename ::std::conditional_t<::std::is_const_v<QueriedInterfaceType>, const char*, char*>;
 
        // perform the actual cast
        if (nullptr != i_pObject)
        {
            base_pointer const pBase = ucom_cast_to_implicit_cast<interface_type, true>::perform_cast(i_pObject);
            auto& nCachedOffset = ucom_cast_cache::open_cache_line(pBase, &typeid(::std::remove_cv_t<QueriedInterfaceType>));
            if (ucom_cast_cache::cache_miss == nCachedOffset)
            {
                // the cast from the interface to void must be performed inside the GetInterface()
                // method, because only there we have all necessary cast information!
                QueriedInterfaceType* nRet = nullptr;
                const char* const strIID = get_iid<QueriedInterfaceType*>();
                if (pBase->GetInterface(strIID, reinterpret_cast<void_pointer&>(nRet)).IsOk())
                {
                    nCachedOffset = reinterpret_cast<memory_type>(nRet) - reinterpret_cast<memory_type>(pBase);
                    return nRet;
                }
                else
                {
                    nCachedOffset = ucom_cast_cache::interface_not_found;
                }
            }
            else if (ucom_cast_cache::interface_not_found != nCachedOffset)
            {
                return reinterpret_cast<QueriedInterfaceType*>(reinterpret_cast<memory_type>(pBase) + nCachedOffset);
            }
        }
 
        return nullptr;
    }
}; // template<> struct<false> ucom_cast_to_implicit_cast

template<typename QueriedInterfaceType>
struct ucom_cast_to_implicit_cast<QueriedInterfaceType, true> final
{
public: // private methods
    template<typename ObjectType>
    static constexpr typename ::std::enable_if_t<detail::has_hierarchy_type<ObjectType>::value, QueriedInterfaceType>*
        perform_cast(ObjectType* i_pObject) noexcept
    {
        // resolve possible ambiguous calls (multiple inheritance)
        return ucom_resolve<QueriedInterfaceType>(i_pObject);
    }

    template<typename ObjectType>
    static constexpr typename ::std::enable_if_t<!detail::has_hierarchy_type<ObjectType>::value, QueriedInterfaceType>*
        perform_cast(ObjectType* i_pObject) noexcept
    {
        return i_pObject;
    }
}; // template<> struct<true> ucom_cast_to_implicit_cast
 
} // namespace detail

template<typename InterfacePointerType, typename ObjectPointerType>
InterfacePointerType ucom_cast(ObjectPointerType i_pObject) noexcept
{
    using object_type = typename ::std::remove_pointer_t<ObjectPointerType>;
    using interface_type = typename ::std::remove_pointer_t<InterfacePointerType>;
    // make sure the cast is performed const correct
 
    static_assert(::std::is_pointer_v<ObjectPointerType>, "ucom_cast<> failed. \"i_pObject\" is not a pointer");
    static_assert(::std::is_base_of_v<IObject, typename ::std::remove_const_t<object_type>>,
                  "ucom_cast<> failed. \"i_pObject\" does not point to a type derived from IObject");
 
    // if the interface_type is base of the object type, we can use an implicit cast
    return detail::ucom_cast_to_implicit_cast<
        typename ::std::conditional_t<::std::is_const_v<object_type>, const interface_type, interface_type>,
        ::std::is_base_of_v<interface_type, object_type>>::perform_cast(i_pObject);
} // fn ucom_cast<>
 
} // namespace ant

using ant::ucom_cast;
 
} // namespace ucom
} // namespace adtf
 
#endif //_ADTF_UCOM_ANT_UCOM_CAST_INCLUDES_HEADER_