/* C++ Reflection & Serice Library * Copyright (C) 2003  Marcus Perlick * mailto: riffraff@users.sf.net *  * This library 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 2.1 of the License, or (at your option) any later version. *  * This library 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 this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA * * This file is part of the "C++ Reflection & Serice Library" */#include "FundamentalType.hh"#include <cassert>#include <new>#include "align.hh"#include "StdMethods.hh"#include "Exception.hh"namespace rfl {  const Type&  FundamentalType::getElmType( std::size_t idx ) const  {    Exception x( X_NOELM,		 _("cannot get element type for class \'%s\'."),		 getName().c_str() );    throw x;  }  void*  FundamentalType::getElmAddr( void* obj, std::size_t idx ) const  {    Exception x( X_NOELM,		 _("cannot get element address for class \'%s\'."),		 getName().c_str() );    throw x;  }    template<typename T>  class FunTypeTmpl : public FundamentalType {  public:        FunTypeTmpl( const char* name, Id id ) :      FundamentalType( id, name, sizeof(T), AlignmentOf<T>::is(), 0,		       &Create<T>::fn,		       &CCreate<T>::fn,		       &Destroy<T>::fn,		       &Assign<T>::fn,		       &NewObj<T>::fn,		       &NewCopy<T>::fn,		       &DelObj<T>::fn )    {}    virtual void avStartCall( av_alist& avList, 			      void* fnPtr,			      void *retVal ) const;    virtual void avPutArg( av_alist& avList, void* arg ) const;    virtual unsigned long hash( void ) const { return getId(); }    virtual bool operator==( const Type& type ) const    { return getId() == type.getId(); }  };  /** \todo Choose a better way to call the av_start_??? macro for the   *  boolean return type. */  void  FunTypeTmpl<bool>::avStartCall( av_alist& avList,				  void* fnPtr,				  void *retVal ) const  {    // _MP_ what macro shall we use in C++? I thing sizeof(bool) is 1 with    // my g++. So, for now we take char!    av_start_char( avList, fnPtr, retVal );  }  void  FunTypeTmpl<char>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_char( avList, fnPtr, retVal );  }  void  FunTypeTmpl<unsigned char>::avStartCall( av_alist& avList,					   void* fnPtr,					   void* retVal ) const  {    av_start_uchar( avList, fnPtr, retVal );  }    void  FunTypeTmpl<short>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_short( avList, fnPtr, retVal );  }  void  FunTypeTmpl<unsigned short>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_ushort( avList, fnPtr, retVal );  }  void  FunTypeTmpl<int>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_int( avList, fnPtr, retVal );  }  void  FunTypeTmpl<unsigned int>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_uint( avList, fnPtr, retVal );  }  void  FunTypeTmpl<long>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_long( avList, fnPtr, retVal );  }  void  FunTypeTmpl<unsigned long>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_ulong( avList, fnPtr, retVal );  }  void  FunTypeTmpl<float>::avStartCall( av_alist& avList,				   void* fnPtr,				   void* retVal ) const  {    av_start_float( avList, fnPtr, retVal );  }  void  FunTypeTmpl<double>::avStartCall( av_alist& avList,				    void* fnPtr,				    void* retVal ) const  {    av_start_double( avList, fnPtr, retVal );  }  void  FunTypeTmpl<bool>::avPutArg( av_alist& avList, void* arg ) const  {    av_char( avList, *(char*)arg );  }  void  FunTypeTmpl<char>::avPutArg( av_alist& avList, void* arg ) const  {    av_char( avList, *(char*)arg );  }  void  FunTypeTmpl<unsigned char>::avPutArg( av_alist& avList, void* arg ) const  {    av_uchar( avList, *(unsigned char*)arg );  }  void  FunTypeTmpl<short>::avPutArg( av_alist& avList, void* arg ) const  {    av_short( avList, *(short*)arg );  }  void  FunTypeTmpl<unsigned short>::avPutArg( av_alist& avList, void* arg ) const  {    av_ushort( avList, *(unsigned short*)arg );  }  void  FunTypeTmpl<int>::avPutArg( av_alist& avList, void* arg ) const  {    av_int( avList, *(int*)arg );  }  void  FunTypeTmpl<unsigned int>::avPutArg( av_alist& avList, void* arg ) const  {    av_uint( avList, *(unsigned int*)arg );  }  void  FunTypeTmpl<long>::avPutArg( av_alist& avList, void* arg ) const  {    av_long( avList, *(long*)arg );  }  void  FunTypeTmpl<unsigned long>::avPutArg( av_alist& avList, void* arg ) const  {    av_ulong( avList, *(unsigned long*)arg );  }  void  FunTypeTmpl<float>::avPutArg( av_alist& avList, void* arg ) const  {    av_float( avList, *(float*)arg );  }  void  FunTypeTmpl<double>::avPutArg( av_alist& avList, void* arg ) const  {    av_double( avList, *(double*)arg );  }#define DEFFUNTYPE(ty,id,tid) \static FunTypeTmpl<ty> the##id##_t( #ty, tid ); \const FundamentalType& Type##id = the##id##_t  DEFFUNTYPE( bool, Bool, Type::ID_BOOL );  DEFFUNTYPE( char, Char, Type::ID_CHAR );  DEFFUNTYPE( unsigned char, UChar, Type::ID_UCHAR );  DEFFUNTYPE( short, Short, Type::ID_SHORT );  DEFFUNTYPE( unsigned short, UShort, Type::ID_USHORT );  DEFFUNTYPE( int, Int, Type::ID_INT );  DEFFUNTYPE( unsigned int, UInt, Type::ID_UINT );  DEFFUNTYPE( long, Long, Type::ID_LONG );  DEFFUNTYPE( unsigned long, ULong, Type::ID_ULONG );  DEFFUNTYPE( float, Float, Type::ID_FLOAT );  DEFFUNTYPE( double, Double, Type::ID_DOUBLE );} // namespace rfl