nrroTypeInfo.h

Go to the documentation of this file.

//------------------------------------------------------------------------
//
//   Joe Kniss
//     7-10-03
//                   ________    ____   ___ 
//                  |        \  /    | /  /
//                  +---+     \/     |/  /
//                  +--+|  |\    /|     < 
//                  |  ||  | \  / |  |\  \ 
//                  |      |  \/  |  | \  \ 
//                   \_____|      |__|  \__\
//                       Copyright  2003 
//                      Joe Michael Kniss
//                   <<< jmk@cs.utah.edu >>>
//               "All Your Base are Belong to Us"
//-------------------------------------------------------------------------

/// NrroTypeInfo.h

#ifndef __NRRO_TYPE_INFO_DOT_H
#define __NRRO_TYPE_INFO_DOT_H

#include "nrro.h"
#include <limits>

/// a NrroType interface class.
/// see below for an array of type info structs
/// that are indexable by Nrro::getType()
class _NrroType {
public:
   /// int, short, char etc...
   virtual bool   isIntegral() const = 0;// {return false;}
   /// float or double
   virtual bool   isFloat() const = 0; // {return false;}
   virtual double min() const = 0; // {return std::numeric_limits<double>::quiet_NaN();};
   virtual double max() const = 0; //{return std::numeric_limits<double>::quiet_NaN();};
};

class NrroTypeUnknown : public _NrroType
{
public:
   bool isIntegral() const { return false; }
   bool isFloat() const    { return false; }
   double min() const {return std::numeric_limits<double>::quiet_NaN();}
   double max() const {return std::numeric_limits<double>::quiet_NaN();}
};

class NrroTypeChar : public _NrroType 
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<char>::min();}
   double max() const {return (double)std::numeric_limits<char>::max();}
};

class NrroTypeUChar : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<unsigned char>::min();}
   double max() const {return (double)std::numeric_limits<unsigned char>::max();}
};

class NrroTypeShort : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<short>::min();}
   double max() const {return (double)std::numeric_limits<short>::max();}
};

class NrroTypeUShort : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<unsigned short>::min();}
   double max() const {return (double)std::numeric_limits<unsigned short>::max();}
};

class NrroTypeInt : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<int>::min();}
   double max() const {return (double)std::numeric_limits<int>::max();}
};

class NrroTypeUInt : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<unsigned int>::min();}
   double max() const {return (double)std::numeric_limits<unsigned int>::max();}
};

#ifdef _LONGLONG
typedef _LONGLONG longlong;
#else
typedef long long int longlong;
#endif

class NrroTypeLL : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<longlong>::min();}
   double max() const {return (double)std::numeric_limits<longlong>::max();}
};

#ifdef _ULONGLONG
typedef _ULONGLONG ulonglong;
#else
typedef unsigned long long int ulonglong;
#endif

class NrroTypeULL : public _NrroType
{
public:
   bool   isIntegral() const {return true;}
   bool   isFloat() const    { return false; }
   double min() const {return (double)std::numeric_limits<ulonglong>::min();}
   double max() const {return (double)std::numeric_limits<ulonglong>::max();}
};

class NrroTypeFloat : public _NrroType
{
public:
   bool   isIntegral() const {return false;}
   bool   isFloat() const    { return true; }
   double min() const {return (double)std::numeric_limits<float>::min();}
   double max() const {return (double)std::numeric_limits<float>::max();}
};

class NrroTypeDouble : public _NrroType
{
public:
   bool   isIntegral() const {return false;}
   bool   isFloat() const    { return true; }
   double min() const {return (double)std::numeric_limits<double>::min();}
   double max() const {return (double)std::numeric_limits<double>::max();}
};

///////////////////////////////////////////////////////////
/// NrroType, a vector indexable by Nrro::getType()
/// ex: NrroType[n.getType()]->max();
///  TODO: something is broken in the .NET compiler, 
///  this shouldn't be an array of pointers!!!
///////////////////////////////////////////////////////////
const _NrroType* const NrroType[] = { new NrroTypeUnknown(),
                                new NrroTypeChar(),
                                new NrroTypeUChar(),
                                new NrroTypeShort(),
                                new NrroTypeUShort(),
                                new NrroTypeInt(),
                                new NrroTypeUInt(),
                                new NrroTypeLL(),
                                new NrroTypeULL(),
                                new NrroTypeFloat(),
                                new NrroTypeDouble(),
                                new NrroTypeUnknown()
                             }; 


/// an empty template for matching ids to types
template<int T_ENUM>
struct NrroTypesID { };

/// an empty template for matching types to id
template<class T> 
struct NrroTypesT { };

/// specializations for each of the Nrro types
template<>
struct NrroTypesID<Nrro::CHAR> { typedef char  TYPE; };
template<>
struct NrroTypesT<char> 
{ enum{ID = Nrro::CHAR}; };

template<>
struct NrroTypesID<Nrro::UCHAR> { typedef unsigned char TYPE; };
template<>
struct NrroTypesT<unsigned char> 
{ enum{ID = Nrro::UCHAR}; };

template<>
struct NrroTypesID<Nrro::SHORT> { typedef short TYPE; };
template<>
struct NrroTypesT<short> 
{ enum{ID = Nrro::SHORT }; };

template<>
struct NrroTypesID<Nrro::USHORT> { typedef unsigned short TYPE; };
template<>
struct NrroTypesT<unsigned short> 
{ enum{ID = Nrro::USHORT}; };

template<>
struct NrroTypesID<Nrro::INT> { typedef int TYPE; };
template<>
struct NrroTypesT<int> 
{ enum{ID = Nrro::INT}; };

template<>
struct NrroTypesID<Nrro::UINT> { typedef unsigned int TYPE; };
template<>
struct NrroTypesT<unsigned int> 
{ enum{ID = Nrro::UINT}; };

template<>
struct NrroTypesID<Nrro::FLOAT> { typedef float TYPE; };
template<>
struct NrroTypesT<float> 
{ enum{ID = Nrro::FLOAT}; };

template<>
struct NrroTypesID<Nrro::DOUBLE> { typedef double TYPE; };
template<>
struct NrroTypesT<double> 
{ enum{ID = Nrro::DOUBLE}; };

//////////////////////////////////////////////////////
/// type info

#if 0
template<int T_ENUM>
struct _NrroTypeInfoID 
{
   typedef typename NrroTypesID<T_ENUM>::TYPE  TYPE;
   static Nrro::NrroIter<TYPE> getBegin(NrroSP n)
   {  return n->begin<NrroTypesID<T_ENUM>::TYPE>(); }
   static Nrro::NrroIter<TYPE> getEnd(NrroSP n)
   {  return n->end<NrroTypesID<T_ENUM>::TYPE>(); }
};
#endif



#endif

---

Send questions, comments, and bug reports to: