Typeof.H

Go to the documentation of this file.

#ifndef Typeof_H
#define Typeof_H

// $Id: Typeof.H 6832 2008-03-04 23:26:18Z furtak $

// This is an ORTS file (c) Bill Gibbons, licensed under the GPL

// Portable "typeof" operator and test program.
//
// Written by Bill Gibbons 2/18/2000
//
// This example uses function overloading and template specialization
// to implement a restricted form of the "typeof" operator.
//
// Each type for which "typeof" must work must be registered with
// the REGISTER_TYPEOF macro, which generates the required template
// specialization and overloaded function declaration.
//
// An ordinal 1..n is assigned to each type and used to pass type
// information by encoding the type as a number (in an array size)
// and using "sizeof" to extract the value as a constant.

#if !HAS_TYPEOF

#include "Global.H"

//==================== The "typeof" machinery ====================

template<int N> struct typeof_class; // no def'n, only specializations
template<class T> struct WrapType { typedef T U; };

#define REGISTER_TYPEOF(N,T) \
    template<> struct typeof_class<N> { typedef WrapType< T >::U V; }; \
    char (*typeof_fct(const WrapType< T >::U &))[N];

#define REGISTER_TYPEOF2(N,T1,T2)                                         \
    template<> struct typeof_class<N> { typedef WrapType< T1,T2 >::U V; };  \
    char (*typeof_fct(const WrapType< T1,T2 >::U &))[N];

#define typeof(x) typeof_class<sizeof(*typeof_fct(x))>::V

//======== Registration of types to be used with "typeof" ========

REGISTER_TYPEOF(1, char );
REGISTER_TYPEOF(2, signed char );
REGISTER_TYPEOF(3, unsigned char );
REGISTER_TYPEOF(4, short );
REGISTER_TYPEOF(5, unsigned short );
REGISTER_TYPEOF(6, int );
REGISTER_TYPEOF(7, unsigned int );
REGISTER_TYPEOF(8, long );
REGISTER_TYPEOF(9, unsigned long );
REGISTER_TYPEOF(10, long long ) // may be unknown type
REGISTER_TYPEOF(11, unsigned long long ) // may be unknown type
REGISTER_TYPEOF(12, float );
REGISTER_TYPEOF(13, double );
//REGISTER_TYPEOF(14, wchar_t ) // may be unknown type
REGISTER_TYPEOF(15, std::string);
REGISTER_TYPEOF(16, std::string::iterator);
REGISTER_TYPEOF(17, std::string::const_iterator);

REGISTER_TYPEOF(30, Vector<sint4>::iterator );
REGISTER_TYPEOF(31, Vector<sint4>::const_iterator );
REGISTER_TYPEOF(32, Vector<uint4>::iterator );
REGISTER_TYPEOF(33, Vector<uint4>::const_iterator );
REGISTER_TYPEOF(34, Vector<uint4*>::iterator );
REGISTER_TYPEOF(35, Vector<uint4*>::const_iterator );
REGISTER_TYPEOF(36, Vector<std::string>::iterator );
REGISTER_TYPEOF(37, Vector<std::string>::const_iterator );

REGISTER_TYPEOF2(500, std::map<std::string, sint4>::iterator );
REGISTER_TYPEOF2(501, std::map<std::string, sint4>::const_iterator );
REGISTER_TYPEOF2(502, std::map<std::string, uint4>::iterator );
REGISTER_TYPEOF2(503, std::map<std::string, uint4>::const_iterator );
REGISTER_TYPEOF2(504, std::map<const std::string, sint4>::iterator );
REGISTER_TYPEOF2(505, std::map<const std::string, sint4>::const_iterator );
REGISTER_TYPEOF2(506, std::map<const std::string, uint4>::iterator );
REGISTER_TYPEOF2(507, std::map<const std::string, uint4>::const_iterator );
REGISTER_TYPEOF2(508, std::map<std::string, std::string>::iterator );
REGISTER_TYPEOF2(509, std::map<std::string, std::string>::const_iterator );


REGISTER_TYPEOF(510, Vector< Vector<sint4> >::iterator );
REGISTER_TYPEOF(511, Vector< Vector<sint4> >::const_iterator );
REGISTER_TYPEOF(512, Vector< Vector<uint4> >::iterator );
REGISTER_TYPEOF(513, Vector< Vector<uint4> >::const_iterator );

REGISTER_TYPEOF(100, std::set<sint4>::iterator );
REGISTER_TYPEOF(102, std::set<std::string>::iterator );
REGISTER_TYPEOF(103, std::set<std::string>::const_iterator );
//REGISTER_TYPEOF(101, std::set<sint4>::const_iterator );

#else

#define REGISTER_TYPEOF(N,T)
#define REGISTER_TYPEOF2(N,T1,T2)

#endif

#endif