property.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: property.h,v 1.40 2005/12/23 17:01:41 amoll Exp $
//

#ifndef BALL_CONCEPT_PROPERTY_H
#define BALL_CONCEPT_PROPERTY_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_DATATYPE_BITVECTOR_H
# include <BALL/DATATYPE/bitVector.h>
#endif

#ifndef BALL_CONCEPT_PERSISTENTOBJECT_H
# include <BALL/CONCEPT/persistentObject.h>
#endif

#include <iostream>

#include <boost/shared_ptr.hpp>
#include <boost/any.hpp>

namespace BALL 
{

  
  class BALL_EXPORT NamedProperty
    : public PersistentObject
  {
    public:

    BALL_CREATE(NamedProperty)

    
    enum Type
    {
      BOOL,

      INT,

      UNSIGNED_INT,

      FLOAT,

      DOUBLE,

      STRING,

      OBJECT,

      NONE,

      SMART_OBJECT
    };
    


    /*  The default constructor
    */
    NamedProperty();

    NamedProperty(const string& name);

    NamedProperty(const string& name, bool value);

    NamedProperty(const string& name, int value);

    NamedProperty(const string& name, unsigned int value);

    NamedProperty(const string& name, float value);

    NamedProperty(const string& name, double value);

    NamedProperty(const string& name, const string& str);

    NamedProperty(const string& name, PersistentObject& po);

    NamedProperty(const string& name, boost::shared_ptr<PersistentObject>& po);

    NamedProperty(const NamedProperty&);

    ~NamedProperty();

    virtual void clear();
    

      
    virtual void persistentWrite(PersistenceManager& pm, const char* name = "") const
      throw(Exception::GeneralException);

    virtual void persistentRead(PersistenceManager& pm)
      throw(Exception::GeneralException);
    


    Type getType() const;
    
    string getName() const;

    bool getBool() const;

    int getInt() const;
      
    float getFloat() const;
      
    double getDouble() const;
      
    unsigned int getUnsignedInt() const;

    PersistentObject* getObject() const;

    boost::shared_ptr<PersistentObject> getSmartObject() const;

    string getString() const;



    bool operator == (const NamedProperty& np) const;

    bool operator != (const NamedProperty& np) const;


    private:

    /*_ The kind of information contained in the NamedProperty
    */
    Type type_;

    /*_ The name of the property object 
    */
    string name_;
    
    /*_ The data
    */
    boost::any data_;

  };

  class BALL_EXPORT PropertyManager
  {
    public:
    
    BALL_CREATE(PropertyManager)

    

    BALL_INLINE 

    PropertyManager();

    BALL_INLINE
    PropertyManager(const PropertyManager& property_manager);

    virtual ~PropertyManager();

    virtual void clear();

    virtual void destroy();



    void set(const PropertyManager& property_manager);

    const PropertyManager& operator = (const PropertyManager& property_manager);

    void get(PropertyManager& property_manager) const;

    void swap(PropertyManager& property_manager);


       
    BitVector& getBitVector();

    const BitVector& getBitVector() const;
      


    operator BitVector& ();



    void setProperty(Property property);

    void clearProperty(Property property);

    void toggleProperty(Property property);

    Size countProperties() const;
  


    const NamedProperty& getNamedProperty(Position index) const
      throw(Exception::IndexOverflow);

    NamedProperty& getNamedProperty(Position index)
      throw(Exception::IndexOverflow);

    void setProperty(const NamedProperty& property);

    void setProperty(const string& name);

    void setProperty(const string& name, bool value);

    void setProperty(const string& name, int value);

    void setProperty(const string& name, unsigned int value);

    void setProperty(const string& name, float value);

    void setProperty(const string& name, double value);

    void setProperty(const string& name, const string& value);

    void setProperty(const string& name, const PersistentObject& value);

    const NamedProperty& getProperty(const string& name) const;

    void clearProperty(const string& name);

    Size countNamedProperties() const;


    bool hasProperty(Property property) const;

    bool hasProperty(const string& name) const;

    bool operator == (const PropertyManager& pm) const;

    bool operator != (const PropertyManager& pm) const;




    void write(PersistenceManager& pm) const;

    bool read(PersistenceManager& pm);


    bool isValid() const;
  
    void dump(std::ostream& s = std::cout, Size depth = 0) const;
    

    private:

    BitVector bitvector_;
    std::vector<NamedProperty> named_properties_;
  };


# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/CONCEPT/property.iC>
# endif

} // namespace BALL

#endif // BALL_CONCEPT_PROPERTY_H

---