mlPropertyManager.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2010, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_PROPERTY_MANAGER_H
#define ML_PROPERTY_MANAGER_H
 
 
 
#include "mlVesselGraphSystem.h"
 
#include "mlIntrusivePtrBase.h"
#include "mlPropertyValue.h"
 
#include <set>
#include <vector>
#include <boost/intrusive_ptr.hpp>
 
VESSELGRAPH_BEGIN_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() override;
 
  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);
 
private:
  friend class PropertyContainer;
  friend class SmartPropertyIndex;
 
  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;
 
public:
  void addStateToTree(TreeNode* parent) const override;
 
  ML_SET_ADDSTATE_VERSION(1);
 
  void readStateFromTree(TreeNode* parent) override;
 
  ML_CLASS_HEADER(PropertyManager);
};
 
template<typename T>
std::vector<std::string> PropertyManager::getPropertyNames() const
{
  // Suppress annoying boost warnings on linux bothering many dependent
  // projects where it is not allowed any more and where it cannot be
  // suppressed with systemincludes since it's a macro.
#if defined(__GNUC__)
  #if !defined(MACOS) || defined(__clang__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wold-style-cast"
  #endif
#endif
  BOOST_MPL_ASSERT(( boost::mpl::contains<PropertyValue::SupportedPropertyTypes, T> ));
#if defined(__GNUC__)
  // pragma GCC diagnostic push is not available on the old Mac gcc.
  // Thus we can only use this mechanism on linux, or if we use clang.
  #if !defined(MACOS) || defined(__clang__)
    #pragma GCC diagnostic pop
  #endif
#endif
 
  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;
}
 
VESSELGRAPH_END_NAMESPACE
 
#endif // __MLPropertyManager_H