Property.hpp

Go to the documentation of this file.

/*==========================================================================
 *
 *  Original source copyright (c) 2003, Carnegie Mellon University.
 *  See copyright.cmu for details.
 *  Modifications copyright (c) 2003, University of Massachusetts.
 *  See copyright.umass for details.
 *
 *==========================================================================
 */

#ifndef _PROPERTY_HPP
#define _PROPERTY_HPP

#define INITBUFFSIZE 128
#define INITNAMESIZE 32
#include "common_headers.hpp"
#include <cstring>
namespace lemur
{
  namespace parse 
  {
    
    class Property {
    public:
      enum DataType {EMPTY = 0, INT = 1, STRING = 2, DOUBLE = 3, UNKNOWN = 4, STDSTRING = 5};

      Property();
      Property(const string initName);
      ~Property();

      void setName(const string newName);
      void copyValue(const Property * property);
      const string getName() const;
      const void * getValue() const;
      DataType getType() const;
      int getSize() const;
      int getLength() const;

      template<typename T>
      void setObjectValue( const T& value ) {
        dataSize = sizeof(T);
        void* memory = allocate( dataSize );
        setDestructor( &Property::destruct<T> );
        new(memory) T(value);
        setType( Property::UNKNOWN );
      }

      template<typename T>
      void setFundamentalValue( T value, DataType t ) {
        dataSize = sizeof(T);
        void* memory = allocate( sizeof(T) );
        setDestructor( 0 );
        std::memcpy( memory, &value, sizeof(T) );
        setType( t );
      }

      template<typename T>
      void setArrayValue( T* value, DataType t, int length ) {
        dataSize = sizeof(T) * length;
        void* memory = allocate( dataSize );
        setDestructor( 0 );
        std::memcpy( memory, value, length );
        setType( t );
      }

      template<typename T>
      void setValue( T value ) {
        setObjectValue( value );
      }

      void setValue( const char* value ) {
        setArrayValue( value, STRING, strlen(value)+1 );
      }

      void setValue( const string value) {
        setObjectValue(value);
        setType(STDSTRING);
      }

      void setValue( char* value ) {
        setArrayValue( value, STRING, strlen(value)+1 );
      }

      void setValue( int value ) {
        setFundamentalValue( value, INT );
      }

      void setValue( double value ) {
        setFundamentalValue( value, DOUBLE );
      }

      template<class T>
      void destruct( void* value ) {
        ( (T*) value )->~T();
      }

    protected:
      void (Property::*destructor)( void* object );
      void* allocate( int size );
      void setDestructor( void (Property::*destructor)(void* object) );
      void setType( DataType type );

      DataType type;
      int bufferSize;
      int dataSize;
      char * buffer;

      string name;
      bool nullName;
    };
  }
}


#endif //_PROPERTY_HPP

---