MeVisLab/Standard/Sources/ML/MLVesselGraph/Properties/mlPropertyContainer.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __MLPropertyContainer_H
#define __MLPropertyContainer_H

#include "mlVesselGraphSystem.h"

#include "mlPropertyValue.h"
#include "mlPropertyManager.h"

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

#include <mlBase.h>

class MLPropertyContainerWrapper;

ML_START_NAMESPACE

class VESSELGRAPH_EXPORT PropertyContainer : public Base {
  friend class PropertyManager;
  friend class ::MLPropertyContainerWrapper;
public:
  typedef PropertyManager::Pointer ManagerPointer;
  typedef PropertyManager::ConstPointer ConstManagerPointer;
  typedef PropertyManager::PropertyMap PropertyMap;

  PropertyContainer(const ManagerPointer& manager);
  PropertyContainer(const PropertyContainer& other);
  virtual ~PropertyContainer();

  virtual bool operator==(const PropertyContainer& other) const;
  virtual bool operator!=(const PropertyContainer& other) const { return !(*this==other); }

  virtual void copyProperties(const PropertyContainer& other);

  const PropertyManager* getPropertyManager() const { return _manager.get(); }
  PropertyManager* getPropertyManager() { return _manager.get(); }
  PropertyMap getPropertyMap() const;

  size_t numberOfProperties() const { return _values.size(); }

  //PropertyValue& property(size_t index) { return _values[index]; }
  const PropertyValue& property(size_t index) const { return _values[index]; }
  template<typename T>
  T& property(size_t index) { return _values[index].get<T>(); }
  template<typename T>
  const T& property(size_t index) const { return _values[index].get<T>(); }

  // PropertyValue& property(const std::string& name)             { return _values[_manager->getPropertyIndex(name)]; }
  const PropertyValue& property(const std::string& name) const { return _values[_manager->getPropertyIndex(name)]; }
  template<typename T>
  T& property(const std::string& name) { return _values[_manager->getPropertyIndex(name)].get<T>(); }
  template<typename T>
  const T& property(const std::string& name) const { return _values[_manager->getPropertyIndex(name)].get<T>(); }

  virtual void reset();



  virtual void addStateToTree(TreeNode* parent) const;

  ML_SET_ADDSTATE_VERSION(1);

  virtual void readStateFromTree(TreeNode* parent);

protected:
  std::vector<PropertyValue> _values;

  ManagerPointer _manager;

private:
  PropertyContainer& operator=(const PropertyContainer& other); // not implemented

  ML_ABSTRACT_CLASS_HEADER(PropertyContainer);
};

ML_END_NAMESPACE

#endif // __MLPropertyContainer_H