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

Go to the documentation of this file.

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

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

#ifndef __MLPropertyManager_H
#define __MLPropertyManager_H

#include "mlVesselGraphSystem.h"

#include "mlIntrusivePtrBase.h"
#include "mlPropertyValue.h"

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

#include <mlBase.h>
#include <mlTrace.h>

ML_START_NAMESPACE

class PropertyContainer;
class SmartPropertyIndex;

class VESSELGRAPH_EXPORT PropertyManager : public Base, public IntrusivePtrBase<PropertyManager> {
public:
  typedef PropertyManager type;
  typedef boost::intrusive_ptr<type> Pointer;
  typedef boost::intrusive_ptr<const type> ConstPointer;
  typedef std::map<std::string, PropertyValue> PropertyMap;

  PropertyManager();
  PropertyManager(const PropertyManager& other);
  ~PropertyManager();

  template <typename T>
  static void logObjectConstructor(const T* object);

  template <typename T>
  static void logObjectDestructor(const T* object);

  static void allowDestruction(void* location);

  PropertyManager& operator=(const PropertyManager& item);

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

  void clearProperties();

  size_t createProperty(const std::string& name, const PropertyValue& defaultValue);

  const PropertyValue& getPropertyDefault(size_t propertyIndex)            const { return _defaultValues[propertyIndex]; }
  const PropertyValue& getPropertyDefault(const std::string& propertyName) const { return _defaultValues[getPropertyIndex(propertyName)]; }

  PropertyMap getPropertyDefaultMap() const;

  size_t getPropertyIndex(const std::string& propertyName) const;

  const std::string& getPropertyName(size_t index) const { return _names[index]; }

  const std::vector<std::string>& getPropertyNames() const { return _names; }

  template<typename T>
  std::vector<std::string> getPropertyNames() const;

  bool hasProperty(const std::string& name) const { return std::find(_names.begin(), _names.end(), name)!=_names.end(); }

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

  void removeProperty(const std::string& name);



  virtual void addStateToTree(TreeNode* parent) const;

  ML_SET_ADDSTATE_VERSION(1);

  virtual void readStateFromTree(TreeNode* parent);

private:
  friend class PropertyContainer;
  friend class SmartPropertyIndex;
  static std::set<const void*> destructableObjects;

  void _register(PropertyContainer* properties)   { _propertyContainers.insert(properties); }
  void _unregister(PropertyContainer* properties) { _propertyContainers.erase(properties); }

  void _register(SmartPropertyIndex* index)   { _smartIndices.insert(index); }
  void _unregister(SmartPropertyIndex* index) { _smartIndices.erase(index); }

  void _notifySmartIndices() const;

  std::vector<std::string> _names;
  
  std::vector<PropertyValue> _defaultValues;

  std::set<PropertyContainer*> _propertyContainers;
  std::set<SmartPropertyIndex*> _smartIndices;

  ML_CLASS_HEADER(PropertyManager);
};

template<typename T>
std::vector<std::string> PropertyManager::getPropertyNames() const
{
  BOOST_MPL_ASSERT(( boost::mpl::contains<PropertyValue::SupportedPropertyTypes, T> ));
  std::vector<std::string> names;

  T t;
  PropertyValue v(t);
  const size_t which = v.which();
  for(size_t i=0;i<_defaultValues.size(); ++i) {
    if (_defaultValues[i].which()==which) {
      names.push_back(_names[i]);
    }
  }

  return names;
}

#include <typeinfo>
#include <iostream>
#include <fstream>

template <typename T>
void PropertyManager::logObjectConstructor(const T* object)
{
/*  std::ofstream debugFile;
  debugFile.open("d:\\Tmp\\debug.log", std::ios::out | std::ios::app);
  debugFile << "Constructed object of type " << typeid(T).name() << " at memory location " << object << std::endl;
  debugFile.close();
*/
}

template <typename T>
void PropertyManager::logObjectDestructor(const T* object)
{
/*
  std::ofstream debugFile;
  debugFile.open("d:\\Tmp\\debug.log", std::ios::out | std::ios::app);
  const void* location = object;
  if (destructableObjects.find(location)==destructableObjects.end()) {
    debugFile << "WARNING: The following object is destructed prematurely!!!" << std::endl;
    debugFile << "MLStackTrace:" << std::endl;
    for (MLuint16 i=0; i<MLGlobalTraceBuffer.getTraceStackTop(); ++i) {
      debugFile << MLGlobalTraceBuffer.getTraceStack()[i] << std::endl;
    }
  }
  debugFile << "Destructed object of type " << typeid(T).name() << " at memory location " << object << std::endl;
  debugFile.close();
*/
}

ML_END_NAMESPACE

#endif // __MLPropertyManager_H