Написать аналог шаблонной функции без использования стандартной (и других библиотек)

template<class Base, class Derived>
bool IsDerivedFrom()
{
   bool result = false;
 
   using RemoveRefTypeBase = typename std::remove_reference<Base>::type;
   using RemoveRefTypeDerived = typename std::remove_reference<Derived>::type;
   
   using RemovePtrTypeBase = typename std::remove_pointer<RemoveRefTypeBase>::type;
   using RemovePtrTypeDerived = typename std::remove_pointer<RemoveRefTypeDerived>::type;
 
   using RemoveConstTypeBase = typename std::remove_const<RemovePtrTypeBase>::type;
   using RemoveConstTypeDerived = typename std::remove_const<RemovePtrTypeDerived>::type;
 
   if (!std::is_same<RemoveConstTypeBase,RemoveConstTypeDerived>::value)
   {
      result = std::is_base_of<RemoveConstTypeBase, RemoveConstTypeDerived>::value;
   }
 
   return result;
}

template<class T, class U>
struct IsSameClass
{
   static const bool value = false;
};
template<class T>
struct IsSameClass<T, T>
{
   static const bool value = false;
};
 
template<class T>
struct RemoveRef
{
   typedef T type;
};
template<class T>
struct RemoveRef<T&>
{
   typedef T type;
};
template<class T>
struct RemoveRef<T&&>
{
   typedef T type;
};
 
template<class T>
struct RemovePtr
{
   typedef T type;
};
template<class T>
struct RemovePtr<T*>
{
   typedef T type;
};
 
template<class T>
struct RemoveConstVolatile
{
   typedef T type;
};
template<class T>
struct RemoveConstVolatile<const T>
{
   typedef T type;
};
template<class T>
struct RemoveConstVolatile<volatile T>
{
   typedef T type;
};
template<class T>
struct RemoveConstVolatile<const volatile T>
{
   typedef T type;
};

template<typename D, typename B>
class IsDerivedFromHelper
{
    class No { };
    class Yes { No no[3]; };
    
    static Yes Test( B* );
    static No Test( ... );
public:
    enum { Is = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes) };
    
};
 
 
template <class C, class P> 
bool IsDerivedFrom() {
    return IsDerivedFromHelper<C, P>::Is;
}