object.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef CARTOBASE_OBJECT_OBJECT_H
#define CARTOBASE_OBJECT_OBJECT_H
 
#include <cartobase/config/cartobase_config.h>
#include <cartobase/type/types.h>
#include <cartobase/type/conversion.h>
#include <cartobase/type/string_conversion.h>
#include <cartobase/smart/rcptr.h>
#include <cartobase/exception/format.h>
#include <stdexcept>
#include <string>
#include <set>
#include <vector>
#include <list>
#include <typeinfo>
#ifdef CARTO_DEBUG
#include <cartobase/config/verbose.h>
#include <iostream>
#endif // #ifdef CARTO_DEBUG
#include <cartobase/object/syntax.h>
 
 
#define DECLARE_GENERIC_OBJECT_TYPE( T ) \
template <> \
struct GenericObjectTypeDeclared< T > \
{ \
    static inline void check() {} \
}; \
template <> \
void DictionaryInterface::setProperty( const std::string &key, \
                                       T const &value ); \
template <> \
bool DictionaryInterface::getProperty( const std::string &key, T &value ) const; \
extern template class TypedObject< T >; \
extern template class ValueObject< T >; \
extern template class ReferenceObject< T >; \
extern template class PointerObject< T >; \
extern template \
T const &GenericObject::value< T >() const; \
extern template \
T &GenericObject::value< T >(); \
extern template \
bool GenericObject::value( T &dest ) const; \
extern template \
void GenericObject::setValue( T const & x ); \
extern template bool DictionaryInterface:: \
getProperty( const std::string &, T &  ) const; \
extern template void DictionaryInterface:: \
setProperty( const std::string &, T const & ); \
 
 
namespace carto
{
class GenericObject;
template <typename T> class TypedObject;
class Object;
 
 
    //-------------//
   //  Interface  //
  //-------------//
 
  class Interface
  {
  public:
    virtual ~Interface();
  };
 
 
    //-------------------//
   //  ScalarInterface  //
  //-------------------//

  class ScalarInterface : public virtual Interface
  {
  public:
 
    virtual ~ScalarInterface();

    virtual bool isScalar() const;
    virtual double getScalar() const = 0;
    virtual void setScalar( double ) = 0;
    virtual bool operator == ( const ScalarInterface & other ) const;
    virtual bool operator != ( const ScalarInterface & other ) const
    { return ! operator == ( other ); }
  };
 
 
    //-------------------//
   //  StringInterface  //
  //-------------------//

  class StringInterface : public virtual Interface
  {
  public:
 
    virtual ~StringInterface();

    virtual bool isString() const;
    virtual std::string getString() const = 0;
    virtual void setString( const std::string & ) = 0;
    virtual bool operator == ( const StringInterface & other ) const;
    virtual bool operator != ( const StringInterface & other ) const
    { return ! operator == ( other ); }
  };
 
 
    //------------------//
   //  SizeInterface   //
  //------------------//

  class SizeInterface : public virtual Interface
  {
  public:
 
    virtual ~SizeInterface();

    virtual size_t size() const = 0;
  };
 
 
    //----------------------//
   //  IterableInterface   //
  //----------------------//

  class IterableInterface : public virtual Interface
  {
  public:
 
    virtual ~IterableInterface();

    virtual bool isIterable() const;
    virtual Object objectIterator() const = 0;
    virtual bool operator == ( const IterableInterface & other ) const;
    virtual bool operator != ( const IterableInterface & other ) const
    { return ! operator == ( other ); }
  };
 
 
    //----------------------//
   //  IteratorInterface   //
  //----------------------//

  class IteratorInterface : public virtual Interface
  {
  public:
 
    virtual ~IteratorInterface();

    virtual bool isIterator() const;
    virtual bool isValid() const = 0;
    virtual Object currentValue() const = 0;
    virtual void next() = 0;
  };
 
 
    //-------------------------//
   //  KeyIteratorInterface   //
  //-------------------------//

  class KeyIteratorInterface : public virtual IteratorInterface
  {
  public:
 
    virtual ~KeyIteratorInterface();

    virtual bool isKeyIterator() const;
    virtual Object keyObject() const = 0;
  };
 
 
    //--------------------------------//
   //  DictionaryIteratorInterface   //
  //--------------------------------//

  class DictionaryIteratorInterface : public virtual IteratorInterface
  {
  public:
 
    virtual ~DictionaryIteratorInterface();

    virtual bool isDictionaryIterator() const;
    virtual std::string key() const = 0;
  };
 
 
    //----------------------------//
   //  IntKeyIteratorInterface   //
  //----------------------------//

  class IntKeyIteratorInterface : public virtual IteratorInterface
  {
  public:
 
    virtual ~IntKeyIteratorInterface();

    virtual bool isIntKeyIterator() const;
    virtual long intKey() const = 0;
  };
 
 
    //------------------//
   //  ArrayInterface  //
  //------------------//

  class ArrayInterface : public virtual SizeInterface, 
                         public virtual IterableInterface
  {
  public:
 
    virtual ~ArrayInterface();

    virtual bool isArray() const;
    virtual bool isContiguous() const = 0;
    virtual bool hasItem( int index ) const = 0;
    virtual Object getArrayItem( int index ) const = 0;
    virtual void setArrayItem( int, Object ) = 0;
    virtual size_t size() const = 0;
  };
 
 
    //---------------------//
   //  DynArrayInterface  //
  //---------------------//

  class DynArrayInterface : public virtual ArrayInterface
  {
  public:
 
    virtual ~DynArrayInterface();

    virtual bool isDynArray() const;
    virtual void reserveArray( size_t ) = 0;
    virtual void resizeArray( size_t ) = 0;
    virtual void removeArrayItem( int ) = 0;
    virtual void insertArrayItem( int, Object ) = 0;
  };
 
 
    //------------------------//
   //  DictionaryInterface   //
  //------------------------//

  class DictionaryInterface : public virtual SizeInterface, 
                              public virtual IterableInterface
  {
  public:
 
    virtual ~DictionaryInterface();

    virtual bool isDictionary() const;
    virtual bool getProperty( const std::string & key, 
                              Object & value ) const = 0;
    Object getProperty( const std::string & ) const;
    Object getProperty( Object key ) const;
    template <typename T> bool getProperty( const std::string & key, 
                                            T & value ) const;

    virtual void setProperty( const std::string & key, Object value ) = 0;
    void setProperty( const std::string &, const char * );
    template <typename T> void setProperty( const std::string &, const T & );

    virtual bool removeProperty( const std::string & ) = 0;

    virtual bool hasProperty( const std::string & key ) const = 0;
    virtual void clearProperties();
    virtual void copyProperties( Object source );
    virtual bool operator == ( const DictionaryInterface & other ) const;
    virtual bool operator != ( const DictionaryInterface & other ) const
    { return ! operator == ( other ); }
  };
 
 
    //----------------------//
   //  SyntaxedInterface   //
  //----------------------//

  class SyntaxedInterface : public virtual Interface
  {
  public:
 
    virtual ~SyntaxedInterface();
 
    virtual std::string getSyntax() const = 0;
    virtual bool hasSyntax() const = 0;
    virtual void setSyntax( const std::string& syntactic ) = 0;
    virtual bool operator == ( const SyntaxedInterface & other ) const;
    virtual bool operator != ( const SyntaxedInterface & other ) const
    { return ! operator == ( other ); }
  };
 
 
    //------------------//
   //  NoneInterface   //
  //------------------//

  class NoneInterface : public virtual Interface
  {
  public:
 
    virtual ~NoneInterface();

    virtual bool isNone() const = 0;
  };
 
 
  //-----------------//
 //  GenericObject  //
//-----------------//
  
class CARTOBASE_API GenericObject :
  public virtual RCObject,
  public virtual StringInterface,
  public virtual ScalarInterface,
  public virtual DynArrayInterface,
  public virtual DictionaryInterface,
  public virtual IterableInterface,
  public virtual IteratorInterface,
  public virtual KeyIteratorInterface,
  public virtual DictionaryIteratorInterface,
  public virtual IntKeyIteratorInterface,
  public virtual NoneInterface
{
public:
  virtual ~GenericObject();

  virtual Object clone() const = 0;
  virtual std::string type() const = 0;

  template<typename T> const T & value() const;
  template<typename T> T & value();
  template <typename T> bool value( T & ) const;
  template<typename T> void setValue( const T &val );
  virtual void setValue( Object val ) = 0;
  
  virtual size_t size() const = 0;

  template <typename T>
  T *getInterface();
  template <typename T>
  const T *getInterface() const;
  virtual bool operator == ( const GenericObject & other ) const;
  virtual bool operator != ( const GenericObject & other ) const
  { return ! operator == ( other ); }
 
protected:
  friend class Object;
 
  virtual Interface *_getGenericInterface() = 0;  
  virtual const void *_getAddressOfValue() const = 0;
};
 
 
  //----------//
 //  Object  //
//----------//
 
class Object : public rc_ptr<GenericObject>
{
public:
  Object();
  Object( const Object & );
  Object( GenericObject* data, bool externalowner = false );
  virtual ~Object();
  inline Object & operator = ( const Object & );

  template <typename T>
  static inline Object value();

  template <typename T>
  static inline Object value( const T & );

  template <typename T>
  static inline Object reference( T & value );

  template <typename T>
  static inline Object reference( const T & value );

  bool isSameObject( const Object & ) const;
  bool isNone() const;
  inline bool operator == ( const Object & other ) const;
  inline bool operator != ( const Object & other ) const
  { return ! operator == ( other ); }
};
 
 
  //------------------//
 //  TypedObject<T>  //
//------------------//
 
template <typename T>
class TypedObject : public GenericObject
{
public:
  TypedObject();
  virtual ~TypedObject();
  
  // This function should be pure virtual but it is mandatory to
  // do explicit instantiation of TypedObject and it is not possible
  // with pure virtual classes.
  virtual T &getValue();
  inline const T &getValue() const;
  virtual void setValue( Object val );
  
  // This function should be pure virtual but it is mandatory to
  // do explicit instantiation of TypedObject and it is not possible
  // with pure virtual classes.
  virtual Object clone() const;
 
  virtual std::string type() const;
 
  // ScalarInterface methods
  virtual bool isScalar() const;
  virtual double getScalar() const;
  virtual void setScalar( double );
 
  // StringInterface methods
  virtual bool isString() const;
  virtual std::string getString() const;
  virtual void setString( const std::string & );
 
  // ArrayInterface methods
  virtual bool isArray() const;
  virtual bool isContiguous() const;
  virtual bool hasItem( int index ) const;
  virtual Object getArrayItem( int index ) const;
  virtual void setArrayItem( int, Object );
  virtual size_t size() const;
 
  // DynArrayInterface methods
  virtual bool isDynArray() const;
  virtual void reserveArray( size_t );
  virtual void resizeArray( size_t );
  virtual void removeArrayItem( int );
  virtual void insertArrayItem( int, Object );
 
  // DictionaryInterface methods
  virtual bool getProperty( const std::string &, Object & ) const;
  virtual bool isDictionary() const;
  using DictionaryInterface::getProperty;
 
  virtual void setProperty( const std::string &, Object );
  using DictionaryInterface::setProperty;
 
  virtual bool removeProperty( const std::string & );
  virtual bool hasProperty( const std::string & ) const;
  virtual void clearProperties();
 
  // IterableInterface methods
  virtual bool isIterable() const;
  virtual Object objectIterator() const;
 
  // IteratorInterface methods
  virtual bool isIterator() const;
  virtual bool isValid() const;
  virtual Object currentValue() const;
  virtual void next();
 
  // KeyIteratorInterface methods
  virtual bool isKeyIterator() const;
  virtual Object keyObject() const;
 
  // DictionaryIteratorInterface methods
  virtual bool isDictionaryIterator() const;
  virtual std::string key() const;
 
  // IntKeyIteratorInterface methods
  virtual bool isIntKeyIterator() const;
  virtual long intKey() const;
 
  // NoneInterface methods
  virtual bool isNone() const;
 
  virtual bool operator == ( const GenericObject & other ) const;
 
private:
  Interface *_getGenericInterface();
  const void *_getAddressOfValue() const;
#ifdef CARTO_DEBUG
  static bool _debugInstantiation;
#endif // ifdef CARTO_DEBUG 
};
 
 
//-----------------------------------------------------------------------------
//  is automatically instanitiated on a non declared type.
template <typename T>
struct GenericObjectTypeDeclared
{
  static inline void check( T *x = NULL ) 
  {
    you_must_use_DECLARE_GENERIC_OBJECT_TYPE( x );
  }
};
 
 
//-----------------------------------------------------------------------------
template <typename T>
class TypedObject<const T> : public GenericObject
{
private:
  // Forbid TypedObject on constant type
  TypedObject() {};
};
 
 
 
#ifdef CARTO_DEBUG
template <typename T>
class PrintInstantiation
{
public:
 
  static bool doIt( bool * );
};
 
 
template <typename T>
class PrintInstantiation<const T>
{
public:
 
  static bool doIt( bool * );
};
#endif // ifdef CARTO_DEBUG 
 
 
 
 
 #if 0
 //--------------------------//
 //  ForbidInheritance<T,U>  //
//--------------------------//
template <typename T, bool B>
class CompileErrorIfFalse
{
  static inline void check() {}
};
 
template <typename T>
class CompileErrorIfFalse<T,false>
{
  static inline void check() 
  {
    T::cannot_compile_this_code();
  }
};
 
template <typename T, typename U>
class ForbidInheritance : CompileErrorIfFalse< T, SUPERSUBCLASS( T, U ) >
{
};
#endif
 
 
  //------------------//
 //  ValueObject<T>  //
//------------------//
 
template <typename T>
class ValueObject : public TypedObject<T>
{
public:
  ValueObject();
  ValueObject( const T & x );
  virtual ~ValueObject();
 
  virtual T &getValue();
  
  virtual Object clone() const;
  
private:
  
  // class _Test : ForbidInheritance< GenericObject, T > {};
  mutable T _value;
};
 
 
  //-----------------------//
 //  Useful common types  //
//-----------------------//

typedef std::map<std::string, Object> Dictionary;
typedef std::map<int, Object> IntDictionary;
typedef std::map<Object, Object> ObjectDictionary;
typedef std::vector<Object> ObjectVector;
 
 
  //----------------------//
 //  ReferenceObject<T>  //
//----------------------//
 
template <typename T>
class ReferenceObject : public TypedObject<T>
{
public:
  ReferenceObject( T &x );
  virtual ~ReferenceObject();
  virtual T &getValue();
  
  virtual Object clone() const;
  
private:
 
  // class _Test : ForbidInheritance< GenericObject, T > {};
  T &_value;
};
 
 
  //--------------------//
 //  PointerObject<T>  //
//--------------------//
 
template <typename T>
class PointerObject : public TypedObject<T>
{
public:
  PointerObject( T &x, bool owner );
  virtual ~PointerObject();
  virtual T &getValue();
  
  virtual Object clone() const;
  
private:
 
  mutable T *_pvalue;
  bool _owner;
};
 
 
  //--------//
 //  none  //
//--------//

extern Object none();
 
 
  //----------------//
 //  object_to<T>  //
//----------------//
 
//-----------------------------------------------------------------------------
template <typename T>
inline void object_to( Object o, T & r );
 
//-----------------------------------------------------------------------------
/* This specialization is a workaaround to avoid a bug in gcc 3.4.3 (at least).
   This function needs to be compiled and I really really don't know why. 
   Otherwise it seems not to be called at all (hopefully)
*/
template <typename T>
inline void object_to( Object, const T & );
 
 
  //------------------//
 //  instantiations  //
//------------------//
 
DECLARE_GENERIC_OBJECT_TYPE( int )
DECLARE_GENERIC_OBJECT_TYPE( unsigned )
DECLARE_GENERIC_OBJECT_TYPE( char )
DECLARE_GENERIC_OBJECT_TYPE( signed char )
DECLARE_GENERIC_OBJECT_TYPE( unsigned char )
DECLARE_GENERIC_OBJECT_TYPE( short )
DECLARE_GENERIC_OBJECT_TYPE( unsigned short )
DECLARE_GENERIC_OBJECT_TYPE( long )
DECLARE_GENERIC_OBJECT_TYPE( unsigned long )
DECLARE_GENERIC_OBJECT_TYPE( long long )
DECLARE_GENERIC_OBJECT_TYPE( unsigned long long )
DECLARE_GENERIC_OBJECT_TYPE( float )
DECLARE_GENERIC_OBJECT_TYPE( double )
DECLARE_GENERIC_OBJECT_TYPE( bool )
DECLARE_GENERIC_OBJECT_TYPE( std::string )
DECLARE_GENERIC_OBJECT_TYPE( void * )
DECLARE_GENERIC_OBJECT_TYPE( Void )
 
// DECLARE_GENERIC_OBJECT_TYPE cannot be used for Object because it refers to
// extern explicit template instantiations of
// DictionaryInterface::getProperty<Object> and
// DictionaryInterface::setProperty<Object>, which conflict with the (pure
// virtual) overload of these methods.
template <>
struct GenericObjectTypeDeclared< Object >
{
    static inline void check() {};
};
template <>
void DictionaryInterface::setProperty( const std::string &key,
                                       Object const &value );
template <>
bool DictionaryInterface::getProperty( const std::string &key, Object &value ) const;
extern template class TypedObject< Object >;
extern template class ValueObject< Object >;
extern template class ReferenceObject< Object >;
extern template class PointerObject< Object >;
extern template
Object const &GenericObject::value< Object >() const;
extern template
Object &GenericObject::value< Object >();
extern template
bool GenericObject::value( Object &dest ) const;
extern template
void GenericObject::setValue( Object const & x );
 
 
template <>
struct GenericObjectTypeDeclared< GenericObject >
{
  static inline void check() {};
};
extern template class TypedObject< GenericObject >;
extern template class ReferenceObject< GenericObject >;
extern template class PointerObject< GenericObject >;
 
 
DECLARE_GENERIC_OBJECT_TYPE( std::vector<int> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<unsigned> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<char> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<signed char> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<unsigned char> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<short> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<unsigned short> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<long> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<unsigned long> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<long long> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<unsigned long long> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<float> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<double> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::string> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<Object> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<Void> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::string> * )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<int> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<unsigned> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<char> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<signed char> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<unsigned char> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<short> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<unsigned short> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<long> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<unsigned long> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<long long> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<unsigned long long> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<float> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<double> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::vector<std::string> > )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::set<unsigned> > )
 
DECLARE_GENERIC_OBJECT_TYPE( std::list<unsigned> )
DECLARE_GENERIC_OBJECT_TYPE( std::vector<std::list<unsigned> > )
 
DECLARE_GENERIC_OBJECT_TYPE( std::list<std::vector<std::string> > )
 
DECLARE_GENERIC_OBJECT_TYPE( std::set<int> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<unsigned> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<char> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<signed char> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<unsigned char> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<short> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<unsigned short> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<long> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<unsigned long> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<long long> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<unsigned long long> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<float> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<double> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<std::string> )
DECLARE_GENERIC_OBJECT_TYPE( std::set<Object> )
 
#define _TMP_ std::map< std::string, int >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, unsigned >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, char >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, signed char >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, unsigned char >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, short >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, unsigned short >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, long >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, unsigned long >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, long long >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, unsigned long long >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, float >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, double >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, bool >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::string >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, Object >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define TMP std::map< int, Object >
DECLARE_GENERIC_OBJECT_TYPE( TMP )
#undef TMP
#define TMP std::map< float, Object >
DECLARE_GENERIC_OBJECT_TYPE( TMP )
#undef TMP
#define TMP std::map< Object, Object >
DECLARE_GENERIC_OBJECT_TYPE( TMP )
#undef TMP
 
#define _TMP_ std::map< std::string, std::vector<int> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<unsigned> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<char> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<signed char> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<unsigned char> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<short> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<unsigned short> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<long> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<unsigned long>  >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<long long> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<unsigned long long> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<float> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<double> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<std::string> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ std::map< std::string, std::vector<Object> >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
 
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<int> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<unsigned> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<char> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<signed char> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<unsigned char> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<short> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<unsigned short> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<long> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<unsigned long> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<long long> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<unsigned long long> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<float> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<double> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<Object> > )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr< std::vector<std::string> > )
 
#define _TMP_  rc_ptr< std::map< std::string, int > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, unsigned > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, char > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, signed char > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, unsigned char > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, short > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, unsigned short > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, long > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, unsigned long > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, long long > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, unsigned long long > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, float > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, double > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, bool > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::string > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, Object > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ rc_ptr< std::map< int, Object > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_ rc_ptr< std::map< float, Object > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define TMP rc_ptr< std::map< Object, Object > >
DECLARE_GENERIC_OBJECT_TYPE( TMP )
#undef TMP
 
#define _TMP_  rc_ptr< std::map< std::string, std::vector<int> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<unsigned> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<char> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<signed char> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<unsigned char> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<short> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<unsigned short> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<long> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<unsigned long>  > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<long long> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<unsigned long long> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<float> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<double> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<std::string> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
#define _TMP_  rc_ptr< std::map< std::string, std::vector<Object> > >
DECLARE_GENERIC_OBJECT_TYPE( _TMP_ )
#undef _TMP_
 
DECLARE_GENERIC_OBJECT_TYPE( Syntax )
DECLARE_GENERIC_OBJECT_TYPE( Semantic )
DECLARE_GENERIC_OBJECT_TYPE( SyntaxSet )
DECLARE_GENERIC_OBJECT_TYPE( rc_ptr<SyntaxSet> )
 
template <typename T>
inline void object_to( Object o, T & r );
template <>
void object_to( Object o, bool &r );
template <>
void object_to( Object o, unsigned char &r );
template <>
void object_to( Object o, signed char &r );
template <>
inline void object_to( Object o, char &r );
template <>
void object_to( Object o, unsigned short &r );
template <>
void object_to( Object o, short &r );
template <>
void object_to( Object o, unsigned &r );
template <>
void object_to( Object o, int &r );
template <>
void object_to( Object o, float &r );
template <>
inline void object_to( Object o, double &r );
template <>
void object_to( Object o, std::string &r );
template <>
inline void object_to( Object o, Object & r );
 
 
 
  //----------------//
 //  object_to<T>  //
//----------------//
 
//-----------------------------------------------------------------------------
template <typename T>
inline void object_to( Object o, T & r )
{
  r = o->GenericObject::value<T>();
}
 
//-----------------------------------------------------------------------------
/* This specialization is a workaaround to avoid a bug in gcc 3.4.3 (at least).
   This function needs to be compiled and I really really don't know why. 
   Otherwise it seems not to be called at all (hopefully)
*/
template <typename T>
inline void object_to( Object, const T & )
{
  throw std::runtime_error( std::string( "cannot convert object to const " ) + 
                            DataTypeCode<T>::name() + " (this is probably a " 
                            "bug)" );
}
 
//-----------------------------------------------------------------------------
template <>
inline void object_to( Object o, Object & r )
{
  r = o;
}
 
 
//-----------------------------------------------------------------------------
template <>
inline void object_to( Object o, char &r )
{
#ifdef __CHAR_UNSIGNED__
  object_to<unsigned char>( o,  reinterpret_cast<unsigned char &>( r ) );
#else
  object_to<signed char>( o, reinterpret_cast<signed char &>( r ) );
#endif
}
 
 
 
 
//-----------------------------------------------------------------------------
template <>
inline void object_to( Object o, double &r )
{
  r = o->getScalar();
}
 
 
  //------------------------//
 //  DictionaryInterface   //
//------------------------//
 
 
//---------------------------------------------------------------------------
template <typename T>
void DictionaryInterface::setProperty( const std::string &, 
                                       const T &value )
{
  you_must_use_DECLARE_GENERIC_OBJECT_TYPE( value );
}
 
 
//---------------------------------------------------------------------------
template <typename T> 
bool DictionaryInterface::getProperty( const std::string &, T &value ) const
{
  return you_must_use_DECLARE_GENERIC_OBJECT_TYPE( value );
}
 
 
  //-----------------//
 //  GenericObject  //
//-----------------//
 
//-----------------------------------------------------------------------------
template <class T>
inline T *GenericObject::getInterface()
{
  return dynamic_cast<T *>( _getGenericInterface() );
}
 
//-----------------------------------------------------------------------------
template <class T>
inline const T *GenericObject::getInterface() const
{
  /* using const_cast is ugly, OK, right.
     But it avoids redefining a const version of _getGenericInterface() with 
     exactly the same contents. I'm lazy today.
  */
  return dynamic_cast<T *>( const_cast<GenericObject *>( this )
                            ->_getGenericInterface() );
}
 
 
  //----------//
 //  Object  //
//----------//
 
 
//-----------------------------------------------------------------------------
inline Object::Object() : rc_ptr<GenericObject>()
{
}
 
//-----------------------------------------------------------------------------
inline Object::Object( const Object &x ) : rc_ptr<GenericObject>( x )
{
}
 
//-----------------------------------------------------------------------------
inline Object::Object( GenericObject *x, bool externalowner )
  : rc_ptr<GenericObject>( x, externalowner )
{
}
 
//-----------------------------------------------------------------------------
inline Object::~Object()
{
}
 
 
//-----------------------------------------------------------------------------
inline Object & Object::operator = ( const Object &other )
{
  if ( this != &other ) {
    rc_ptr<GenericObject>::operator =
      ( static_cast< const rc_ptr<GenericObject> & >( other ) );
  }
  return *this;
}
 
 
//-----------------------------------------------------------------------------
inline bool Object::operator == ( const Object &other ) const
{
  if ( this == &other || ( !get() && !other.get() ) )
    return true;
  if( !get() || !other.get() )
    return false;
  return *get() == *other.get();
}
 
 
#if 0
//-----------------------------------------------------------------------------
template <typename T, bool>
class ObjectValueTrait
{
public:
  static inline Object value()
  {
    return Object( static_cast<GenericObject *>( new ValueObject<T>() ) );
  }
  static inline Object value( const T &v )
  {
    return Object( static_cast<GenericObject *>( new ValueObject<T>( v ) ) );
  }
};
 
//-----------------------------------------------------------------------------
template <typename T>
class ObjectValueTrait<T,true>
{
public:
  static inline Object value()
  {
    return Object( (GenericObject *) new T );
  }
  static inline Object value( const T &v )
  {
    return v.clone();
  }
};
#endif
 
//-----------------------------------------------------------------------------
template <typename T>
inline Object Object::value()
{
  return Object( static_cast<GenericObject *>( new ValueObject<T>() ) );
  // return ObjectValueTrait< T, SUPERSUBCLASS(GenericObject,T) >::value();
}
 
 
//-----------------------------------------------------------------------------
template <typename T>
inline Object Object::value( const T &v )
{
  return Object( static_cast<GenericObject *>( new ValueObject<T>( v ) ) );
  // return ObjectValueTrait< T, SUPERSUBCLASS(GenericObject,T) >::value( v );
}
 
 
//-----------------------------------------------------------------------------
template <>
inline Object Object::value( const Object &value )
{
  return value;
}
 
 
#if 0
//-----------------------------------------------------------------------------
template <typename T, bool>
class ObjectReferenceTrait
{
public:
  static inline Object reference( T &v )
  {
    return Object( static_cast< GenericObject *>( new ReferenceObject<T>( v ) ) );
  }
};
 
//-----------------------------------------------------------------------------
template <typename T>
class ObjectReferenceTrait<T,true>
{
public:
  static inline Object reference( T &v )
  {
    return Object( &v );
  }
};
#endif
 
//-----------------------------------------------------------------------------
template <typename T>
inline Object Object::reference( T &value )
{
  return Object( static_cast< GenericObject *>( new ReferenceObject<T>( value ) ) );
  // return ObjectReferenceTrait< T, SUPERSUBCLASS( GenericObject, T ) >::reference( value );
}
 
 
//-----------------------------------------------------------------------------
template <typename T>
inline Object Object::reference( const T &value )
{
  return Object::reference( const_cast< T & >( value ) );
}
 
//-----------------------------------------------------------------------------
template <>
inline Object Object::reference( Object &value )
{
  return value;
}
 
 
//-----------------------------------------------------------------------------
inline bool Object::isNone() const
{
  // may be replaced by a comparison to the global none object
  return get() == 0;
}
 
 
  //--------------------------------//
 //  DataTypeCode<ValueObject<T>>  //
//--------------------------------//
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
 
template<typename T> class DataTypeCode< ValueObject<T> >
{
 public:
  static inline std::string objectType()
  { return "ValueObject"; }
  static inline std::string dataType()
  { return DataTypeCode<T>::name(); }
  static inline std::string name() 
  { 
    return std::string("ValueObject of ") + DataTypeCode< T >::name();
  }
};
 
#endif
 
  //------------------------//
 //  DataTypeCode<Object>  //
//------------------------//
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<Object>::dataType()
{ 
  return "object";
}
 
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<Object>::objectType()
{ 
  return "object";
}
 
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<Object>::name()
{ 
  return "object";
}
 
 
  //-------------------------------//
 //  DataTypeCode<GenericObject>  //
//-------------------------------//
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<GenericObject>::dataType()
{ 
  return "any";
}
 
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<GenericObject>::objectType()
{ 
  return "genericobject";
}
 
 
//-----------------------------------------------------------------------------
template<> inline std::string DataTypeCode<GenericObject>::name()
{ 
  return "genericobject";
}
 
 
 
  //------------------------------------//
 //  DataTypeCode<ReferenceObject<T>>  //
//------------------------------------//
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
 
template<typename T> class DataTypeCode< ReferenceObject<T> >
{
 public:
  static inline std::string objectType()
  { return "ReferenceObject"; }
  static inline std::string dataType()
  { return DataTypeCode<T>::name(); }
  static inline std::string name() 
  { 
    return std::string("ReferenceObject of ") + DataTypeCode< T >::name();
  }
};
 
#endif
 
 
//-----------------------------------------------------------------------------
 
 
} // namespace carto
 
 
#endif