mlPropertyPersistence.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_PERSISTENCE_H
#define ML_PROPERTY_PERSISTENCE_H
 
 
 
#include "mlVesselGraphSystem.h"
#include "mlPropertyValue.h"
#include "mlPropertyTraits.h"
 
#include <boost/noncopyable.hpp>
 
#ifdef WIN32
#define DOT_TEMPLATE
#else
#define DOT_TEMPLATE template
#endif
 
VESSELGRAPH_BEGIN_NAMESPACE
 
class ToStringVisitor : public boost::static_visitor<std::string>
{
public:
  template<typename T>
  std::string operator()(const T& value) const { return StringConversion::writeToStdString(value); }
};
 
class TypeStringVisitor : public boost::static_visitor<std::string>
{
public:
  template<typename T>
  std::string operator()(const T& /* not used */) const { return PropertyTraits<typename boost::remove_const<T>::type>::name(); }
};
 
inline
void addToTree(TreeNode* parent, const PropertyValue& value)
{
  parent->addChild(value.apply(ToStringVisitor()), value.apply(TypeStringVisitor()).c_str());
}
 
template<typename Functor>
class ApplyFunctorWithType : public boost::static_visitor<>, boost::noncopyable
{
public:
  ApplyFunctorWithType(const Functor& functor, const std::string& typeString) : 
      _functor(functor), _typeString(typeString), _applied(false) {};
 
  template<typename T>
  void operator()(const T& /*t*/)
  { 
    if (_typeString==PropertyTraits<T>::name()) {
      _applied = true;
      _result = _functor.DOT_TEMPLATE operator()<T>();
    }
  }
 
  bool functorWasApplied() const { return _applied; }
  typename Functor::result_type getResult() const { return _result; }
 
private:
  Functor _functor;
  const std::string _typeString;
  bool _applied;
  typename Functor::result_type _result;
};
 
class FromStringFunctor : public boost::static_visitor<PropertyValue>
{
public:
  FromStringFunctor(const std::string& stringRepresentation) : _stringRepresentation(stringRepresentation) {};
 
  template<typename T>
  T operator()() const { 
    T value;
    bool success = StringConversion::readFromString(_stringRepresentation, value);
    if (!success) {
      std::string err("Could not convert \"");
      err += _stringRepresentation;
      err += "\" to type ";
      err += PropertyTraits<T>::name();
      throw TreeNodeException(TNE_Unknown, err.c_str());
    }
    return value;
  }
private:
  const std::string _stringRepresentation;
};
 
inline
PropertyValue fromString(const std::string& representation, const std::string& typeString)
{
  ApplyFunctorWithType<FromStringFunctor> visitor(FromStringFunctor(representation), typeString);
  boost::mpl::for_each<PropertyValue::SupportedPropertyTypes>(boost::ref(visitor));
  if (visitor.functorWasApplied()) {
    return visitor.getResult();
  }
  else {
    throw ML_BAD_PARAMETER;
  }
}
 
inline
PropertyValue readFromTree(TreeNode* parent)
{
  std::string valueString;
  parent->readChild(valueString);
  return fromString(valueString, parent->getLastReadChildName());
}
 
VESSELGRAPH_END_NAMESPACE
 
#endif // __mlPropertyPersistence_HPP