Small class which allows access to internal type IDs. More...

#include <GaudiKernel/DataTypeInfo.h>

Public Types
enum	Type { UNKNOWN = 0 , UCHAR , USHORT , UINT , ULONG , CHAR , SHORT , INT , LONG , BOOL , FLOAT , DOUBLE , STRING , NTCHAR , OBJECT_REF , CONTAINED_REF , POINTER , OBJECT_ADDR , LONG_STRING , LONG_NTCHAR , LONGLONG , ULONGLONG }

Static Public Member Functions
static Type	ID (const bool)
	Access to type information: bool.

static Type	ID (const char)
	Access to type information: char.

static Type	ID (const short)
	Access to type information: short.

static Type	ID (const int)
	Access to type information: int.

static Type	ID (const long)
	Access to type information: long.

static Type	ID (const long long)
	Access to type information: long long.

static Type	ID (const unsigned char)
	Access to type information: unsigned char.

static Type	ID (const unsigned short)
	Access to type information: unsigned short.

static Type	ID (const unsigned int)
	Access to type information: unsigned int.

static Type	ID (const unsigned long)
	Access to type information: unsigned long.

static Type	ID (const unsigned long long)
	Access to type information: unsigned long long.

static Type	ID (const float)
	Access to type information: float.

static Type	ID (const double)
	Access to type information: float.

static Type	ID (const std::string &)
	Access to type information: std::string.

static Type	ID (const char *)
	Access to type information: char* (NULL terminated)

static Type	ID (const IOpaqueAddress *)
	Access to type information: IOpaqueAddress.

static Type	ID (const void *)
	Access to type information: Pointers.

static Type	ID (const SmartRef< DataObject > &)
	Access to type information: DataObject.

static Type	ID (const SmartRef< ContainedObject > &)
	Access to type information: Contained object.

static Type	ID (const std::type_info &typ)
	Access to type information: the reverse way.

static const std::type_info &	type (long typ)
	Access to type information: the reverse way.

static long	size (long typ)
	Access to type information: the reverse way.

static long	size (const std::type_info &typ)
	Access to type information: the reverse way.

static int	copy (void tar, const void src, long typ, int numObj)
	Copy data.

static std::string	name (long typ)

static std::string	name (const std::type_info &typ)

static Type	idByName (const std::string &typ)
	Access to type information.

static const std::type_info &	typeByName (const std::string &typ)
	Access to type information.

Private Member Functions
	DataTypeInfo ()

Detailed Description

Small class which allows access to internal type IDs.

Definition at line 25 of file DataTypeInfo.h.

Member Enumeration Documentation

◆ Type

enum DataTypeInfo::Type

Enumerator
UNKNOWN
UCHAR
USHORT
UINT
ULONG
CHAR
SHORT
INT
LONG
BOOL
FLOAT
DOUBLE
STRING
NTCHAR
OBJECT_REF
CONTAINED_REF
POINTER
OBJECT_ADDR
LONG_STRING
LONG_NTCHAR
LONGLONG
ULONGLONG

Definition at line 32 of file DataTypeInfo.h.

            {
    UNKNOWN = 0,
    UCHAR,
    USHORT,
    UINT,
    ULONG,
    CHAR,
    SHORT,
    INT,
    LONG,
    BOOL,
    FLOAT,
    DOUBLE,
    STRING,
    NTCHAR,
    OBJECT_REF,
    CONTAINED_REF,
    POINTER,
    OBJECT_ADDR,
    LONG_STRING,
    LONG_NTCHAR,
    LONGLONG,
    ULONGLONG
  };

Constructor & Destructor Documentation

◆ DataTypeInfo()

DataTypeInfo::DataTypeInfo ( )

inlineprivate

Definition at line 28 of file DataTypeInfo.h.

28{}

Member Function Documentation

◆ copy()

static int DataTypeInfo::copy	(	void *	tar,
		const void *	src,
		long	typ,
		int	numObj )

inlinestatic

Copy data.

Definition at line 240 of file DataTypeInfo.h.

                                                                      {
    switch ( typ ) {
    case UCHAR:
      numObj *= sizeof( unsigned char );
      break;
    case USHORT:
      numObj *= sizeof( unsigned short );
      break;
    case UINT:
      numObj *= sizeof( unsigned int );
      break;
    case ULONG:
      numObj *= sizeof( unsigned long );
      break;
    case ULONGLONG:
      numObj *= sizeof( unsigned long long );
      break;
    case CHAR:
      numObj *= sizeof( char );
      break;
    case SHORT:
      numObj *= sizeof( short );
      break;
    case INT:
      numObj *= sizeof( int );
      break;
    case LONG:
      numObj *= sizeof( long );
      break;
    case LONGLONG:
      numObj *= sizeof( long long );
      break;
    case BOOL:
      numObj *= sizeof( bool );
      break;
    case FLOAT:
      numObj *= sizeof( float );
      break;
    case DOUBLE:
      numObj *= sizeof( double );
      break;
    case UNKNOWN:
    default:
      numObj *= 0;
      break;
    }
    memcpy( tar, src, numObj );
    return numObj;
  }

◆ ID() [1/20]

static Type DataTypeInfo::ID ( const bool )

inlinestatic

Access to type information: bool.

Definition at line 57 of file DataTypeInfo.h.

57{ return BOOL; }

◆ ID() [2/20]

static Type DataTypeInfo::ID ( const char * )

inlinestatic

Access to type information: char* (NULL terminated)

Definition at line 85 of file DataTypeInfo.h.

85{ return NTCHAR; }

◆ ID() [3/20]

static Type DataTypeInfo::ID ( const char )

inlinestatic

Access to type information: char.

Definition at line 59 of file DataTypeInfo.h.

59{ return CHAR; }

◆ ID() [4/20]

static Type DataTypeInfo::ID ( const double )

inlinestatic

Access to type information: float.

Definition at line 81 of file DataTypeInfo.h.

81{ return DOUBLE; }

◆ ID() [5/20]

static Type DataTypeInfo::ID ( const float )

inlinestatic

Access to type information: float.

Definition at line 79 of file DataTypeInfo.h.

79{ return FLOAT; }

◆ ID() [6/20]

static Type DataTypeInfo::ID ( const int )

inlinestatic

Access to type information: int.

Definition at line 63 of file DataTypeInfo.h.

63{ return INT; }

◆ ID() [7/20]

static Type DataTypeInfo::ID ( const IOpaqueAddress * )

inlinestatic

Access to type information: IOpaqueAddress.

Definition at line 87 of file DataTypeInfo.h.

87{ return OBJECT_ADDR; }

◆ ID() [8/20]

static Type DataTypeInfo::ID ( const long long )

inlinestatic

Access to type information: long long.

Definition at line 67 of file DataTypeInfo.h.

67{ return LONGLONG; }

◆ ID() [9/20]

static Type DataTypeInfo::ID ( const long )

inlinestatic

Access to type information: long.

Definition at line 65 of file DataTypeInfo.h.

65{ return LONG; }

◆ ID() [10/20]

static Type DataTypeInfo::ID ( const short )

inlinestatic

Access to type information: short.

Definition at line 61 of file DataTypeInfo.h.

61{ return SHORT; }

◆ ID() [11/20]

static Type DataTypeInfo::ID ( const SmartRef< ContainedObject > & )

inlinestatic

Access to type information: Contained object.

Definition at line 93 of file DataTypeInfo.h.

93{ return CONTAINED_REF; }

◆ ID() [12/20]

static Type DataTypeInfo::ID ( const SmartRef< DataObject > & )

inlinestatic

Access to type information: DataObject.

Definition at line 91 of file DataTypeInfo.h.

91{ return OBJECT_REF; }

◆ ID() [13/20]

static Type DataTypeInfo::ID ( const std::string & )

inlinestatic

Access to type information: std::string.

Definition at line 83 of file DataTypeInfo.h.

83{ return STRING; }

◆ ID() [14/20]

static Type DataTypeInfo::ID ( const std::type_info & typ )

inlinestatic

Access to type information: the reverse way.

Definition at line 96 of file DataTypeInfo.h.

                                            {
    if ( typ == typeid( unsigned char ) )
      return UCHAR;
    else if ( typ == typeid( unsigned short ) )
      return USHORT;
    else if ( typ == typeid( unsigned int ) )
      return UINT;
    else if ( typ == typeid( unsigned long ) )
      return ULONG;
    else if ( typ == typeid( unsigned long long ) )
      return ULONGLONG;
    else if ( typ == typeid( char ) )
      return CHAR;
    else if ( typ == typeid( short ) )
      return SHORT;
    else if ( typ == typeid( int ) )
      return INT;
    else if ( typ == typeid( long ) )
      return LONG;
    else if ( typ == typeid( long long ) )
      return LONGLONG;
    else if ( typ == typeid( bool ) )
      return BOOL;
    else if ( typ == typeid( float ) )
      return FLOAT;
    else if ( typ == typeid( double ) )
      return DOUBLE;
    else if ( typ == typeid( std::string ) )
      return STRING;
    else if ( typ == typeid( char* ) )
      return NTCHAR;
    else if ( typ == typeid( SmartRef<DataObject> ) )
      return OBJECT_REF;
    else if ( typ == typeid( SmartRef<ContainedObject> ) )
      return CONTAINED_REF;
    else if ( typ == typeid( IOpaqueAddress* ) )
      return OBJECT_ADDR;
    else if ( typ == typeid( void* ) )
      return POINTER;
    else
      return UNKNOWN;
  }

◆ ID() [15/20]

static Type DataTypeInfo::ID ( const unsigned char )

inlinestatic

Access to type information: unsigned char.

Definition at line 69 of file DataTypeInfo.h.

69{ return UCHAR; }

◆ ID() [16/20]

static Type DataTypeInfo::ID ( const unsigned int )

inlinestatic

Access to type information: unsigned int.

Definition at line 73 of file DataTypeInfo.h.

73{ return UINT; }

◆ ID() [17/20]

static Type DataTypeInfo::ID ( const unsigned long long )

inlinestatic

Access to type information: unsigned long long.

Definition at line 77 of file DataTypeInfo.h.

77{ return ULONGLONG; }

◆ ID() [18/20]

static Type DataTypeInfo::ID ( const unsigned long )

inlinestatic

Access to type information: unsigned long.

Definition at line 75 of file DataTypeInfo.h.

75{ return ULONG; }

◆ ID() [19/20]

static Type DataTypeInfo::ID ( const unsigned short )

inlinestatic

Access to type information: unsigned short.

Definition at line 71 of file DataTypeInfo.h.

71{ return USHORT; }

◆ ID() [20/20]

static Type DataTypeInfo::ID ( const void * )

inlinestatic

Access to type information: Pointers.

Definition at line 89 of file DataTypeInfo.h.

89{ return POINTER; }

◆ idByName()

DataTypeInfo::Type DataTypeInfo::idByName ( const std::string & typ )

static

Access to type information.

Definition at line 16 of file DataTypeInfo.cpp.

                                                              {
  if ( typ == "unsigned char" || typ == "const unsigned char" )
    return UCHAR;
  else if ( typ == "unsigned short" || typ == "const unsigned short" )
    return USHORT;
  else if ( typ == "unsigned int" || typ == "const unsigned int" )
    return UINT;
  else if ( typ == "unsigned long" || typ == "const unsigned long" )
    return ULONG;
  else if ( typ == "char" || typ == "const char" )
    return CHAR;
  else if ( typ == "short" || typ == "const short" )
    return SHORT;
  else if ( typ == "int" || typ == "const int" )
    return INT;
  else if ( typ == "long" || typ == "const long" )
    return LONG;
  else if ( typ == "bool" || typ == "const bool" )
    return BOOL;
  else if ( typ == "float" || typ == "const float" )
    return FLOAT;
  else if ( typ == "double" || typ == "const double" )
    return DOUBLE;
  else if ( typ == "std::string" || typ == "const std::string" )
    return STRING;
  else if ( typ == "char*" || typ == "const char*" )
    return NTCHAR;
  else if ( typ == "IOpaqueAddress*" || typ == "const IOpaqueAddress*" )
    return OBJECT_ADDR;
  else if ( typ == "SmartRef<DataObject>" || typ == "const SmartRef<DataObject>" )
    return OBJECT_REF;
  else if ( typ == "SmartRef<ContainedObject>" || typ == "const SmartRef<ContainedObject>" )
    return CONTAINED_REF;
  else if ( typ == "void*" || typ == "const void*" )
    return POINTER;
  else
    return UNKNOWN;
}

◆ name() [1/2]

std::string DataTypeInfo::name ( const std::type_info & typ )

static

Definition at line 141 of file DataTypeInfo.cpp.

                                                      {
  if ( typ == typeid( unsigned char ) )
    return DataTypeInfo::name( UCHAR );
  else if ( typ == typeid( unsigned short ) )
    return DataTypeInfo::name( USHORT );
  else if ( typ == typeid( unsigned int ) )
    return DataTypeInfo::name( UINT );
  else if ( typ == typeid( unsigned long ) )
    return DataTypeInfo::name( ULONG );
  else if ( typ == typeid( char ) )
    return DataTypeInfo::name( CHAR );
  else if ( typ == typeid( short ) )
    return DataTypeInfo::name( SHORT );
  else if ( typ == typeid( int ) )
    return DataTypeInfo::name( INT );
  else if ( typ == typeid( long ) )
    return DataTypeInfo::name( LONG );
  else if ( typ == typeid( bool ) )
    return DataTypeInfo::name( BOOL );
  else if ( typ == typeid( float ) )
    return DataTypeInfo::name( FLOAT );
  else if ( typ == typeid( double ) )
    return DataTypeInfo::name( DOUBLE );
  else if ( typ == typeid( std::string ) )
    return DataTypeInfo::name( STRING );
  else if ( typ == typeid( char* ) )
    return DataTypeInfo::name( NTCHAR );
  else if ( typ == typeid( IOpaqueAddress* ) )
    return DataTypeInfo::name( OBJECT_ADDR );
  else if ( typ == typeid( SmartRef<DataObject> ) )
    return DataTypeInfo::name( OBJECT_REF );
  else if ( typ == typeid( SmartRef<ContainedObject> ) )
    return DataTypeInfo::name( CONTAINED_REF );
  else if ( typ == typeid( void* ) )
    return DataTypeInfo::name( POINTER );
  else
    return DataTypeInfo::name( UNKNOWN );
}

◆ name() [2/2]

std::string DataTypeInfo::name ( long typ )

static

Definition at line 94 of file DataTypeInfo.cpp.

                                       {
  switch ( typ ) {
  case UCHAR:
    return System::typeinfoName( typeid( unsigned char ) );
  case USHORT:
    return System::typeinfoName( typeid( unsigned short ) );
  case UINT:
    return System::typeinfoName( typeid( unsigned int ) );
  case ULONG:
    return System::typeinfoName( typeid( unsigned long ) );
  case CHAR:
    return System::typeinfoName( typeid( char ) );
  case SHORT:
    return System::typeinfoName( typeid( short ) );
  case INT:
    return System::typeinfoName( typeid( int ) );
  case LONG:
    return System::typeinfoName( typeid( long ) );
  case BOOL:
    return System::typeinfoName( typeid( bool ) );
  case FLOAT:
    return System::typeinfoName( typeid( float ) );
  case DOUBLE:
    return System::typeinfoName( typeid( double ) );
  case STRING:
    return System::typeinfoName( typeid( std::string ) );
  case LONG_STRING:
    return System::typeinfoName( typeid( std::string ) );
  case NTCHAR:
    return System::typeinfoName( typeid( char* ) );
  case LONG_NTCHAR:
    return System::typeinfoName( typeid( char* ) );
  case OBJECT_ADDR:
    return System::typeinfoName( typeid( IOpaqueAddress* ) );
  case OBJECT_REF:
    return System::typeinfoName( typeid( SmartRef<DataObject> ) );
  case CONTAINED_REF:
    return System::typeinfoName( typeid( SmartRef<ContainedObject> ) );
  case POINTER:
    return System::typeinfoName( typeid( void* ) );
  case UNKNOWN:
  default:
    return "";
  }
}

◆ size() [1/2]

static long DataTypeInfo::size ( const std::type_info & typ )

inlinestatic

Access to type information: the reverse way.

Definition at line 237 of file DataTypeInfo.h.

237{ return size( ID( typ ) ); }

DataTypeInfo::ID

static Type ID(const bool)

Access to type information: bool.

Definition DataTypeInfo.h:57

DataTypeInfo::size

static long size(long typ)

Access to type information: the reverse way.

Definition DataTypeInfo.h:190

◆ size() [2/2]

static long DataTypeInfo::size ( long typ )

inlinestatic

Access to type information: the reverse way.

Definition at line 190 of file DataTypeInfo.h.

                               {
    switch ( typ ) {
    case UCHAR:
      return sizeof( unsigned char );
    case USHORT:
      return sizeof( unsigned short );
    case UINT:
      return sizeof( unsigned int );
    case ULONG:
      return sizeof( unsigned long );
    case ULONGLONG:
      return sizeof( unsigned long long );
    case CHAR:
      return sizeof( char );
    case SHORT:
      return sizeof( short );
    case INT:
      return sizeof( int );
    case LONG:
      return sizeof( long );
    case LONGLONG:
      return sizeof( long long );
    case BOOL:
      return sizeof( bool );
    case FLOAT:
      return sizeof( float );
    case DOUBLE:
      return sizeof( double );
    case STRING:
      return sizeof( std::string );
    case LONG_STRING:
      return sizeof( std::string );
    case NTCHAR:
      return sizeof( char* );
    case LONG_NTCHAR:
      return sizeof( char* );
    case OBJECT_ADDR:
    case POINTER:
    case OBJECT_REF:
    case CONTAINED_REF:
    case UNKNOWN:
    default:
      return 0;
    }
  }

◆ type()

static const std::type_info & DataTypeInfo::type ( long typ )

inlinestatic

Access to type information: the reverse way.

Definition at line 140 of file DataTypeInfo.h.

                                              {
    switch ( typ ) {
    case UCHAR:
      return typeid( unsigned char );
    case USHORT:
      return typeid( unsigned short );
    case UINT:
      return typeid( unsigned int );
    case ULONG:
      return typeid( unsigned long );
    case ULONGLONG:
      return typeid( unsigned long long );
    case CHAR:
      return typeid( char );
    case SHORT:
      return typeid( short );
    case INT:
      return typeid( int );
    case LONG:
      return typeid( long );
    case LONGLONG:
      return typeid( long long );
    case BOOL:
      return typeid( bool );
    case FLOAT:
      return typeid( float );
    case DOUBLE:
      return typeid( double );
    case LONG_STRING:
      return typeid( std::string );
    case STRING:
      return typeid( std::string );
    case NTCHAR:
      return typeid( char* );
    case LONG_NTCHAR:
      return typeid( char* );
    case OBJECT_REF:
      return typeid( SmartRef<DataObject> );
    case CONTAINED_REF:
      return typeid( SmartRef<ContainedObject> );
    case OBJECT_ADDR:
      return typeid( IOpaqueAddress* );
    case POINTER:
    case UNKNOWN:
    default:
      return typeid( void* );
    }
  }

◆ typeByName()

const std::type_info & DataTypeInfo::typeByName ( const std::string & typ )

static

Access to type information.

Definition at line 56 of file DataTypeInfo.cpp.

                                                                   {
  if ( typ == "unsigned char" || typ == "const unsigned char" )
    return typeid( unsigned char );
  else if ( typ == "unsigned short" || typ == "const unsigned short" )
    return typeid( unsigned short );
  else if ( typ == "unsigned int" || typ == "const unsigned int" )
    return typeid( unsigned int );
  else if ( typ == "unsigned long" || typ == "const unsigned long" )
    return typeid( unsigned long );
  else if ( typ == "char" || typ == "const char" )
    return typeid( char );
  else if ( typ == "short" || typ == "const short" )
    return typeid( short );
  else if ( typ == "int" || typ == "const int" )
    return typeid( int );
  else if ( typ == "long" || typ == "const long" )
    return typeid( long );
  else if ( typ == "bool" || typ == "const bool" )
    return typeid( bool );
  else if ( typ == "float" || typ == "const float" )
    return typeid( float );
  else if ( typ == "double" || typ == "const double" )
    return typeid( double );
  else if ( typ == "std::string" || typ == "const std::string" )
    return typeid( std::string );
  else if ( typ == "char*" || typ == "const char*" )
    return typeid( char* );
  else if ( typ == "IOpaqueAddress*" || typ == "const IOpaqueAddress*" )
    return typeid( IOpaqueAddress );
  else if ( typ == "SmartRef<DataObject>" || typ == "const SmartRef<DataObject>" )
    return typeid( DataObject* );
  else if ( typ == "SmartRef<ContainedObject>" || typ == "const SmartRef<ContainedObject>" )
    return typeid( SmartRef<ContainedObject> );
  else
    return typeid( void* );
}

The documentation for this class was generated from the following files:

GaudiKernel/include/GaudiKernel/DataTypeInfo.h
GaudiKernel/src/Lib/DataTypeInfo.cpp

Public Types

Static Public Member Functions

Private Member Functions

Detailed Description

Member Enumeration Documentation

◆ Type

Constructor & Destructor Documentation

◆ DataTypeInfo()

Member Function Documentation

◆ copy()

◆ ID() [1/20]

◆ ID() [2/20]

◆ ID() [3/20]

◆ ID() [4/20]

◆ ID() [5/20]

◆ ID() [6/20]

◆ ID() [7/20]

◆ ID() [8/20]

◆ ID() [9/20]

◆ ID() [10/20]

◆ ID() [11/20]

◆ ID() [12/20]

◆ ID() [13/20]

◆ ID() [14/20]

◆ ID() [15/20]

◆ ID() [16/20]

◆ ID() [17/20]

◆ ID() [18/20]

◆ ID() [19/20]

◆ ID() [20/20]

◆ idByName()

◆ name() [1/2]

◆ name() [2/2]

◆ size() [1/2]

◆ size() [2/2]

◆ type()

◆ typeByName()