HPC Template Library, A Supplement to the STL

/*
**	This file is part of the Hpc Template Library (Htl or HTL).
**  It is based on a merger of QT, STL, and SigSlots along with development of new classes.
**  License information is in the HtlLicense.h file
**	This software was merged and developed by:
**	
**  Anthony Daniels
**	QT, STL, SigSlots
**
**  HTL is free software: you can redistribute it and/or modify
**  it under the terms of the GNU Lesser General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  The United States of America Department of Defense has unlimited 
**	usage, redistribution, and modification rights to HtlStar.
**
**  HTL is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU Lesser General Public License for more details.
**
**  You should have received a copy of the GNU Lesser General Public License
**  along with HTL.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#ifndef HTL_TYPEINFO_H
#define HTL_TYPEINFO_H
#include "..\modHtlLibRefs.h"

namespace HTL{
	//REMOVE POINTER TYPE CASTING
	template <class T>
	struct RemovePointer
	{
		typedef T type;
	};

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

	template <class T>
	struct RemoveAllPointers
	{
	public:
		typedef T type;
	};

	template <class T>
	struct RemoveAllPointers<T*>
	{
	public:
		typedef typename RemoveAllPointers<T>::type type;
	};
	//IS POINTER TYPE CHECK
	template <typename T>
	struct IsPointerType
	{     
		enum { value = false };
	};
	template <typename T>
	struct IsPointerType<T*>
	{
		enum { value = true };

	};
	template <typename T>
	bool IsPointer(void)
	{
		return IsPointerType<T>::value;
	};

	//Create Oject Type CHECK

	//IS VOID TYPE CHECK
	template <typename T>
	struct IsVoidType
	{     
		enum { value = false };
	};
	template <>
	struct IsVoidType<void>
	{
		enum { value = true };
	};
	template <typename T>
	bool IsVoid(void)
	{
		return IsVoidType<T>::value;
	};

	//IS TYPE CHECK
	//is
	template <typename B,typename D>
	bool DoesObjectInheritFrom( D & ptrObj)
	{     
		try{
			B objCheck;
			if(typeid(objCheck) == typeid((B)ptrObj))
			{
				return true;
			}else{
				return false;
			};
		}catch(...){
			return false;
		}
	};
	template <typename T,typename X>
	bool IsObjectType( X & ptrObj)
	{     
		try{
			T objCheck;
			if(typeid(objCheck) == typeid(ptrObj))
			{
				return true;
			}else{
				return false;
			};
		}catch(...){
			return false;
		}
	};
//!NullObjReturnType///////////////////////////////////////////////////////////
#pragma warning( push )
#pragma warning( disable : 4700) 
	//Default Null Object Returner
	template <typename T>
	struct NullObjReturnType
	{     
		static T DefReturn(void)
		{
			T objVal;
			return objVal;
		};
	};
#pragma warning( pop )

	template <typename T>
	struct NullObjReturnType<T*>
	{
		static T* DefReturn(void)
		{
			return NULL;
		};
	};

	template <typename T>
	struct NullObjReturnType<T&>
	{
		static T& DefReturn(void)
		{
			return NULL;
		};
	};

	template <>
	struct NullObjReturnType<void>
	{
		//sepecialization for void object
		static void DefReturn(void)
		{
			return;
		};
	};
	//shorts signed and unsigned
	template <>
	struct NullObjReturnType<short>
	{
		//sepecialization for short object
		static short DefReturn(void)
		{
			return 0;
		};
	};
	template <>
	struct NullObjReturnType<unsigned short>
	{
		//sepecialization for short object
		static unsigned short DefReturn(void)
		{
			return 0;
		};
	};
	//ints signed and unsigned
	template <>
	struct NullObjReturnType<int>
	{
		//sepecialization for short object
		static int DefReturn(void)
		{
			return 0;
		};
	};
	template <>
	struct NullObjReturnType<unsigned int>
	{
		//sepecialization for short object
		static unsigned int DefReturn(void)
		{
			return 0;
		};
	};
	//longs signed and unsigned
	template <>
	struct NullObjReturnType<long>
	{
		//sepecialization for short object
		static long DefReturn(void)
		{
			return 0;
		};
	};
	template <>
	struct NullObjReturnType<unsigned long>
	{
		//sepecialization for short object
		static unsigned long DefReturn(void)
		{
			return 0;
		};
	};
	//floats and doubles
	template <>
	struct NullObjReturnType<float>
	{
		//sepecialization for short object
		static float DefReturn(void)
		{
			return 0.0f;
		};
	};
	template <>
	struct NullObjReturnType<double>
	{
		//sepecialization for short object
		static double DefReturn(void)
		{
			return 0.0f;
		};
	};
	//chars signed and unsigned
	template <>
	struct NullObjReturnType<char>
	{
		//sepecialization for short object
		static char DefReturn(void)
		{
			return 0;
		};
	};
	template <>
	struct NullObjReturnType<unsigned char>
	{
		//sepecialization for short object
		static unsigned char DefReturn(void)
		{
			return 0;
		};
	};

//OBJECT TYPE INFORMATION

template <typename T>
class TypeInfo
{
public:
    enum {
        isPointer = false,
        isComplex = true,
        isStatic = true,
        isLarge = (sizeof(T)>sizeof(void*)),
        isDummy = false
    };
};

template <typename T>
class TypeInfo<T*>
{
public:
    enum {
        isPointer = true,
        isComplex = false,
        isStatic = false,
        isLarge = false,
        isDummy = false
    };
};

template <>
class TypeInfo<bool>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<char>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<unsigned char>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<short>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<unsigned short>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<int>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<unsigned int>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<long>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<unsigned long>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<float>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};
template <>
class TypeInfo<double>
{
public:
    enum {isPointer = false, isComplex = false, isStatic = false, isLarge = false, isDummy = false };
};



};//end HTL namespace
#endif