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_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
class IObject;  //forward declaration for ucom_cast_convert template
 
namespace detail
{
template<typename QueriedInterfaceType, bool>
struct ucom_cast_to_implicit_cast
{
    template<typename ObjectType>
    static QueriedInterfaceType* perform_cast(ObjectType* i_pObject)
    {
        //provided for const correctness
        typedef typename std::conditional<std::is_const<QueriedInterfaceType>::value,
                                          const IObject,
                                          IObject>::type                       interface_type;
        typedef typename std::conditional<std::is_const<QueriedInterfaceType>::value,
                                          const IObject*,
                                          IObject*>::type                      base_pointer;
        typedef typename std::conditional<std::is_const<QueriedInterfaceType>::value,
                                          const void*,
                                          void*>::type                        void_pointer;
 
        //perform the actual cast
        if (nullptr != i_pObject)
        {   //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*>();
            base_pointer const pBase = ucom_cast_to_implicit_cast<interface_type, true>::perform_cast(i_pObject);
            if ( pBase->GetInterface(strIID, reinterpret_cast<void_pointer&>(nRet)).IsOk() )
            {
                return nRet;
            }
        }
 
        return nullptr;
    }
};//template<> struct<false> ucom_cast_to_implicit_cast
 
template<typename QueriedInterfaceType>
struct ucom_cast_to_implicit_cast<QueriedInterfaceType, true>
{
public:    //private methods
    template<typename ObjectType>
    static typename std::enable_if<detail::has_hierarchy_type<ObjectType>::value,
                                   QueriedInterfaceType>::type*
        perform_cast(ObjectType* i_pObject)
    {
        //resolve possible ambiguous calls (multiple inheritance)
        return ucom_resolve<QueriedInterfaceType>(i_pObject);
    }
 
    template<typename ObjectType>
    static typename std::enable_if<!detail::has_hierarchy_type<ObjectType>::value,
                                   QueriedInterfaceType>::type*
        perform_cast(ObjectType* i_pObject)
    {
        return i_pObject;
    }
};//template<> struct<true> ucom_cast_to_implicit_cast
 
}//ns detail
 
template<typename InterfacePointerType, typename ObjectPointerType>
InterfacePointerType ucom_cast(ObjectPointerType i_pObject)
{
    typedef typename std::remove_pointer<ObjectPointerType>::type          object_type;
    typedef typename std::remove_pointer<InterfacePointerType>::type       interface_type;
    //make sure the cast is performed const correct
 
    static_assert(std::is_pointer<ObjectPointerType>::value,
                 "ucom_cast<> failed. \"i_pObject\" is not a pointer");
    static_assert(
        std::is_base_of<IObject, typename std::remove_const<object_type>::type>::value,
        "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
                <
                    std::is_const<object_type>::value,
                    const interface_type,
                    interface_type
                >::type,
                std::is_base_of<interface_type, object_type>::value
           >::perform_cast(i_pObject);
}//fn ucom_cast<>
 
}//ns ant
 
using ant::ucom_cast;
 
}//ns ucom
}//ns adtf
 
#endif //_ADTF_UCOM_ANT_UCOM_CAST_INCLUDES_HEADER_