classTraits.h

Go to the documentation of this file.

#ifndef classTraits_header_included_p
#define classTraits_header_included_p
//
// Copyright 2008, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.
//
// Warning:  not all files in this directory structure are covered by the
// same copyright.  Some of them are part of the GNU source distribution
// and you must obey the GPL copyright for those files.  Specifically the
// "guts" of the is_polymorphic<T> mechanism comes from boost -- although
// I do feel like an idiot for not having thought of it myself.  Ok, after
// careful consideration of exactly how the algorithm works, including the
// _selector mechanism, which is a work of genius (appearing in the STL)
// I no longer feel like an idiot.  Whether I am or not, is an exercise left
// to the observer...



#include <memory>  // to get size_t

namespace cxxtls
{

// And now to the class type traits helpers...

//
// the true and false types exist only to aid in template function selection.
//
//  Basically you can include a nested typedef like this in your own class:
//
//   typedef true_value_type  flagType;
//
//  Then when templates are instantiated using your class, they can look at the flag type
//  and make decisions as to whether flagType is typedef'd to true_value_type or false_value_type.
//

struct true_value_type 
{
  typedef true_value_type type;

  enum constants { value = 1 };              // compile time constant usable in EvalTypeIf
                                             // or regular code.
};

struct false_value_type 
{
  typedef false_value_type type;

  enum constants { value = 0 };              // compile time constant usable in EvalTypeIf
                                             // or regular code.
};

struct not_a_type{};  // a type that represents "not a type"

template<bool, class ZeroClass, class OneClass> 
struct  EvalTypeIf
{
  // the default implementation is unusable.
};

template<class ZeroClass, class OneClass> 
struct  EvalTypeIf<0, ZeroClass, OneClass>
{
  typedef ZeroClass type;  // the false case:
};

template<class ZeroClass, class OneClass> 
struct  EvalTypeIf<1, ZeroClass, OneClass>
{
  typedef OneClass type;  // the true case
};

template<class T, class U>
struct isSameType
{
  // neither of these functions is ever called or instantiated

  template<class V> static char is_same_type_func(V&,V&);  // this one only takes a pair of ptrs
                                                           // which are equal
  static int is_same_type_func(...);                       // this one takes any number of any type

  static T t;
  static U u;

  // if the two types of template parms are the same, the first func will be called  in the
  // following constant expression -- except that it won't ACTUALLY be called

  enum { value =    (sizeof( is_same_type_func(t,u) ) == sizeof(char))
                 && (sizeof( is_same_type_func(u,t) ) == sizeof(char))
       };

};


template<class T>
struct isConstType
{
  typedef T type;

  typedef false_value_type valueType; 

  enum constants { value = 0 };

};

template<class T>
struct isConstType<const T>
{
  typedef T type; // for const, remove the const

  enum constants { value = 1 };

  typedef true_value_type valueType; 

};

template<class T>
struct removeConst
{
  typedef typename isConstType<T>::type type;
};



template<class T>
struct removeVolatile
{
  typedef T type; // for non-volatle, just use the class 
};


template<class T>
struct removeVolatile<volatile T>
{
  typedef T type; // for volatile, remove it
};

template<class T>
struct removeCV
{
  typedef typename removeConst< typename removeVolatile<T>::type >::type type;
};

//
//  removeReference<T>  has a member, type, which is T without the &, if any
//

template<class U> struct removeReference_impl { typedef U type; };
template<class V> struct removeReference_impl <V&> { typedef V type; };

template<class T>
struct removeReference
{

  typedef typename removeReference_impl<T>::type type; 

};



//
// template isConvertibleType<FromType, ToType> tells you whether or not
// FromType is assignment compatible with ToType, that is, can you construct a
// ToType object from a FromType object.
//


template<class From, class To>
struct isConvertibleType
{
   // these functions and variables are never instantiated

   static char f(...);  // this function will take anything as a parm
   static int  f(To); // this function will only take a ToType object as a parm

   // note that the f(...) and f(To&) forms return different data types.  

   static From fromp;  
   static To   top;

   // The following code defines a constant named "value" whose value is defined
   // by the size of the data that would be returned by one of the two 'f' overloads
   // above.  No actual call is made, but the compiler can tell which of the two
   // overloaded forms WOULD be called with the given arguments and thus it can tell
   // the return type -- and thus you can take the size thereof and compare the size of
   // the returned value of the two different function calls.
   //
   // 
   // If the from and two classes are assignment compatible then the f(To&) form will
   // be called.  If they are not, then different functions will be called -- and thus
   // the size of the return value will be different.  Of course, they are not REALLY called
   // only evaluated for call...

   enum constants
   {
     value = sizeof( f(fromp) ) ==  sizeof( f(top) )
   };


};

template<class To>
struct isConvertibleType<void, To>
{
  enum { value = false };
};
template<class To>
struct isConvertibleType<const void, To>
{
  enum { value = false };
};

template<>
struct isConvertibleType<float, int>
{
  enum { value = true };
};
template<>
struct isConvertibleType<const float, int>
{
  enum { value = true };
};
template<>
struct isConvertibleType<double, int>
{
  enum { value = true };
};
template<>
struct isConvertibleType<const double, int>
{
  enum { value = true };
};
template<>
struct isConvertibleType<long double, int>
{
  enum { value = true };
};
template<>
struct isConvertibleType<const long double, int>
{
  enum { value = true };
};



template<class Type>
struct isClassType
{
  
  template <typename ClassType>
  static short fun(void (ClassType::*)());
  
  template <typename NonClassType>   // this has to be a template
  static char fun(...);

  enum { value = sizeof(fun<Type>(0)) == sizeof(short) };
};


template<class T>
struct isFunctionType
{
  // works on functions up to 9 parameters -- feel free to add more

  template<class RV> static char f(RV (*func0)());
  template<class RV, class A> static char f(RV (*func1)(A));
  template<class RV, class A, class B> static char f(RV (*func2)(A, B));
  template<class RV, class A, class B, class C> static char f(RV (*func3)(A, B, C));
  template<class RV, class A, class B, class C, class D> static char f(RV (*func4)(A, B, C, D));
  template<class RV, class A, class B, class C, class D, class E> static char f(RV (*func5)(A, B, C, D, E));
  template<class RV, class A, class B, class C, class D, class E, class F> static char f(RV (*func6)(A, B, C, D, E, F));
  template<class RV, class A, class B, class C, class D, class E, class F, class G> static char f(RV (*func7)(A, B, C, D, E, F, G));
  template<class RV, class A, class B, class C, class D, class E, class F, class G, class H> static char f(RV (*func8)(A, B, C, D, E, F, G, H));
  template<class RV, class A, class B, class C, class D, class E, class F, class G, class H, class I> static char f(RV (*func9)(A, B, C, D, E, F, G, H, I));

  static int f(...);

  static T t;

  enum { value = sizeof(char) == sizeof( f(t) ) };

};

template<>
struct isFunctionType<void>
{
  enum { value = false };
};

template<>
struct isFunctionType<const void>
{
  enum { value = false };
};



template<class T>
struct isPointerType
{
  enum constants { value = 0 };
};

template<class T>
struct isPointerType<T*>
{
  enum constants { value = 1 };
};

template<class T>
struct isPointerType<T const*>
{
  enum constants { value = 1 };
};

template<class T>
struct isPointerType<T* const>
{
  enum constants { value = 1 };
};

template<class T>
struct isPointerType<T const* const>
{
  enum constants { value = 1 };
};

template<class T, size_t N>
struct isPointerType<T [N]>
{
  enum constants { value = 1 };
};

template<class T, size_t N>
struct isPointerType<T const [N]>
{
  enum constants { value = 1 };
};

template<class T>
struct isArrayType
{
   enum constants { value = 0 }; 
};


template<class T, size_t N>
struct isArrayType<T [N]>
{
  enum constants { value = 1 };
};

template<class T, size_t N>
struct isArrayType<T const [N]>
{
  enum constants { value = 1 };
};



//
//  typename pointerReferent<T>::type is a type gives you the base type from a pointer type.
//
//  non-pointers are their own pointee type


template<class T>
struct pointerReferent
{
  typedef T type; // non-pointers should not cause compile errors since you can use isPointer
                  // at run time to tell if it really is a pointer or not
};

template<class T>
struct pointerReferent<T*>
{
  typedef T type;
};

template<class T>
struct pointerReferent<T const*>
{
  typedef T const type;
};

template<class T, size_t N>
struct pointerReferent<T [N]>
{
  typedef T type;
};

template<class T, size_t N>
struct pointerReferent<T const [N]>
{
  typedef T const type;
};


template<class T>struct ispodtype_impl: public false_value_type {};  


// only the following are pod:

template<class T> struct ispodtype_impl<T*>          : public true_value_type {}; 
template<class T> struct ispodtype_impl<T* const>    : public true_value_type {}; 
template<> struct ispodtype_impl<char>               : public true_value_type {}; 
template<> struct ispodtype_impl<short>              : public true_value_type {}; 
template<> struct ispodtype_impl<int>                : public true_value_type {}; 
template<> struct ispodtype_impl<long>               : public true_value_type {}; 
template<> struct ispodtype_impl<long long>          : public true_value_type {}; 
template<> struct ispodtype_impl<unsigned char>      : public true_value_type {}; 
template<> struct ispodtype_impl<unsigned short>     : public true_value_type {}; 
template<> struct ispodtype_impl<unsigned int>       : public true_value_type {}; 
template<> struct ispodtype_impl<unsigned long long> : public true_value_type {}; 
template<> struct ispodtype_impl<float>              : public true_value_type {}; 
template<> struct ispodtype_impl<double>             : public true_value_type {}; 

// arrays are pod


template<class T>
struct isPodType
{
  enum { value = ispodtype_impl<T>::value || isConvertibleType<T,int>::value || isFunctionType<T>::value };
};

template<class T, size_t N> struct ispodtype_impl<T [N]> : public isPodType<T> {};  


//
//  The isPolymorphicType<T> template lets you find out if a class has virtual methods.
//  Note that its purpose is to define nested class members which give you information
//  about T -- is it polymorphic or not.
//



template <class plainT>
struct isPolymorphicType_impl
  //
  //  This definition handles non-POD types
  //
{
  // to tell if a data type is polymorphic, you check to see if it has a virtual
  // function table.  The way you tell that is to derive new classes from it.  You
  // derive a new class with a new virtual method and a different class without any
  // new virtual methods.  If if sizeof the new types is equal then you know that the
  // base class has virtual methods to start with, but if the sizes are not the same
  // then the it was not originally polymorphic.


   struct d1 : public plainT
   {
      d1();
      ~d1()throw();
      char padding[256];
   };

   struct d2 : public plainT
   {
      d2();
      virtual ~d2() throw();
      char padding[256];
   };

   enum constants { value = sizeof(d1) == sizeof(d2) };

   typedef typename EvalTypeIf<value, false_value_type, true_value_type>::type type;

   operator bool() const { return value; }

};


template <bool is_class>
struct isPolymorphicType_selector
{
  // non-class case

   template <class T>
   struct rebind
   {
      typedef false_value_type type;
   };
};

template<>
struct isPolymorphicType_selector<true>
{
  // isClassType case

   template <class T>
   struct rebind
   {
      typedef isPolymorphicType_impl<T> type;
   };
};

template <class T>
struct isPolymorphicType
{
   // Normally, we would just use isPolymorphicType_impl<T>::value, but
   // the isPolymorphicType_impl<T> class would produce a compile error if
   // T is an enumeration, pointer, or arithmetic data type name.
   //
   // The following syntax to select a guaranteed false data type for non-class 
   // values of T, but for true classes, select isPolymorphicType_impl<T> -- 
   // which will compile successfully.

   typedef isPolymorphicType_selector< isClassType<T>::value> selector;

   // since isPolymorphicType_selector<false> has a rebind template that defines
   // a guaranteed false_value_type, we are assured that selector will compile
   // no matter what data type is used for T -- and for class types, which gives
   // defines a selector with a rebind method that refers to isPolymorphicType_impl,
   // we get proper operation for that case too.
   // 

   // the following code invokes a template on the selector type.
   // I'm not sure why you need the template keyword, but you do.


   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type imp_type;
   enum { value = imp_type::value };
};




//
//  this template tells you if a class represents an signed number
//

template<class T>
struct isSignedType
{
  typedef typename removeCV<T>::type mutableType;

  static char f(char &);
  static char f(int &);
  static char f(short &);
  static char f(long &);
  static char f(long long &);
  static char f(float &);
  static char f(double &);
  static char f(long double &);

  static int  f(...);

  static mutableType t;

  enum { value = (sizeof(f(t)) == sizeof(char) ) };


};

template<>
struct isSignedType<void>
{
  enum { value = 0 };
};
template<>
struct isSignedType<const void>
{
  enum { value = 0 };
};

template<class T>
struct isUnsignedType
{
  typedef typename removeCV<T>::type mutableType;
  typedef typename removeReference<mutableType>::type UnrefType;

  static char f(unsigned char &);
  static char f(unsigned int &);
  static char f(unsigned short &);
  static char f(unsigned long &);
  static char f(unsigned long long&);

  static int  f(...);

  static UnrefType t;

  enum { value =sizeof(f(t)) == sizeof(char) };

};

template<>
struct isUnsignedType<void>
{
  enum { value = 0 };
};
template<>
struct isUnsignedType<const void>
{
  enum { value = 0 };
};



template<class T>
struct isFloatType
{
  typedef typename removeCV<T>::type mutableType;
  typedef typename removeReference<T>::type unrefType;

  static char f(float &);
  static char f(double &);
  static char f(long double &);
  static int  f(...);

  static unrefType *t;

  enum { value = sizeof(f(*t)) == sizeof(char) };
};

template<>
struct isFloatType<void>
{
  enum { value = 0 };
};

template<>
struct isFloatType<const void>
{
  enum { value = 0 };
};






template<class T>
struct isEnumType
{
  typedef typename removeCV<T>::type mutableType;
  typedef typename removeReference<mutableType>::type UnrefType;

  static char f(unsigned char &);
  static char f(unsigned int &);
  static char f(unsigned short &);
  static char f(unsigned long &);
  static char f(unsigned long long&);
  static char f(char &);
  static char f(int &);
  static char f(short &);
  static char f(long &);
  static char f(long long&);
  static char f(float &);
  static char f(double &);
  static char f(long double &);


  static int  f(...);

  static UnrefType t;

  enum { value =    !isClassType<UnrefType>::value 
                 && isConvertibleType<UnrefType, int>::value 
                 && sizeof( f(t) ) != sizeof(char)
       };
};

template<>
struct isEnumType<void>
{
  enum { value = 0 };
};
template<>
struct isEnumType<const void>
{
  enum { value = 0 };
};



template<class T>
struct isIntegralType
{
  typedef typename removeCV<T>::type MutableType;
  typedef typename removeReference<MutableType>::type U;


  enum { value = (   isSignedType<U>::value 
                  || isUnsignedType<U>::value 
                 )
                 && !isEnumType<U>::value
                 && !isFloatType<U>::value
       } ;
};

template<class T>
struct isArithmeticType
{
  typedef typename removeCV<T>::type MutableType;
  typedef typename removeReference<MutableType>::type U;


  enum { value = isIntegralType<U>::value || isFloatType<U>::value };
};

template<>
struct isArithmeticType<void>
: public false_value_type
{
};

template<>
struct isIntegralType<void>
: public false_value_type
{
};

template<>
struct isArithmeticType<const void>
: public false_value_type
{
};

template<>
struct isIntegralType<const void>
: public false_value_type
{
};


template<class T>
struct isTemplate // supports up to 9 template parameters (all class)
                  // DOESN'T COMPILE EVERYWHERE!
{
  static typename removeCV<T>::type *t;

  static int f(...);  // all types but templates

  template<class A, 
           template<class A1> class Template
          > 
          static char f( Template<A> *);

  template<class A, class B,
           template<class A1, class B1> class Template
          > 
          static char f( Template<A,B> *);

  template<class A, class B, class C,
           template<class A1, class B1, class C1> class Template
          > 
          static char f( Template<A,B,C> *);

  template<class A, class B, class C, class D,
           template<class A1, class B1, class C1, class D1> class Template
          > 
          static char f( Template<A,B,C,D> *);

  template<class A, class B, class C, class D, class E,
           template<class A1, class B1, class C1, class D1, class E1> 
           class Template
          > 
          static char f( Template<A,B,C,D,E> *);

  template<class A, class B, class C, class D, class E, class F,
           template<class A1, class B1, class C1, class D1, class E1, class F1> 
           class Template
          > 
          static char f( Template<A,B,C,D,E,F> *);

  template<class A, class B, class C, class D, class E, class F, class G,
           template<class A1, class B1, class C1, class D1, class E1, class F1, class G1> 
           class Template
          > 
          static char f( Template<A,B,C,D,E,F,G> *);

  template<class A, class B, class C, class D, class E, class F, class G, class H,
           template<class A1, class B1, class C1, class D1, class E1, class F1, class G1, class H1> 
           class Template
          > 
          static char f( Template<A,B,C,D,E,F,G,H> *);

  template<class A, class B, class C, class D, class E, class F, class G, class H, class I,
           template<class A1, class B1, class C1, class D1, class E1, class F1, class G1, class H1, class I1> 
           class Template
          > 
          static char f( Template<A,B,C,D,E,F,G,H,I> *);


  enum { value = sizeof( f(t) ) == 1 };
};


enum basicClassTypes
{
    bctUnknownType  =0,
    bctVoidType     =1,
    bctIntegralType =2,  // int, long, char
    bctEnumType     =3,
    bctPointerType  =4,
    bctArrayType    =5,
    bctFloatType    =6,
    bctFunctionType =7,
    bctClassType    =8,
};

template<class T> struct basicClassType; 

template<> 
struct basicClassType<void> 
{ 
    enum { value = bctVoidType    }; 
};

template<class T> 
struct basicClassType
{
    typedef typename removeCV<T>::type MutableType;
    typedef typename removeReference<MutableType>::type RawType;

    enum {
            value = ( isIntegralType<RawType>::value
                      ? bctIntegralType
                      : ( isEnumType<RawType>::value
                          ? bctEnumType
                          : ( isArrayType<RawType>::value
                              ? bctArrayType
                              : ( isFunctionType<RawType>::value
                                  ? bctFunctionType
                                  : ( isFloatType<RawType>::value
                                     ? bctFloatType
                                     : ( isPointerType<RawType>::value
                                        ? bctPointerType
                                        : ( isClassType<RawType>::value
                                           ? bctClassType
                                           : bctUnknownType  // should not happen.
                                          )
                                       )
                                    )
                                )
                            )
                        )
                    )
         };
};

template<class Base, class Derived>
void derivedFromBase(Base *bptr, Derived *&dref)
{
    static Derived *d= (Derived *)(0x100);  // can't use 0 here.
    static Base    *b=d;  // if Derived is not derived from Base this will cause a compile error.

    static size_t  const  bOffset = ((char *)b) - ((char *)d);

    dref =  (Derived*)( ((char*)bptr) - bOffset);

}

template<class T, class U, class W=false_value_type, class X=false_value_type>
struct EvalOr
{
   enum { value = T::value || U::value || W::value || X::value };
};


template<class T, class U, class W=true_value_type, class X=true_value_type>
struct EvalAnd
{
   enum { value = T::value && U::value && W::value && X::value};
};



template<class T>
struct  removeAllExtents
{

   typedef typename removeReference<T>::type                 ReferenceStripped;
   typedef typename pointerReferent<ReferenceStripped>::type PointerStripped;
   typedef typename removeCV<T>::type                        CVStripped;

   typedef CVStripped type;
    
};

template<class T, unsigned long long N>
struct  removeAllExtents<T [N]>
{

  typedef typename removeAllExtents<T>::type type;
    
};



} // namespace cxxtls

#endif