mlLightweight.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_LIGHTWEIGHT_H
#define ML_LIGHTWEIGHT_H
 
 
 
#include "mlVesselGraphSystem.h"
 
// ML includes
#include "VesselGraphTypes.h"
 
// boost includes
#include "VesselGraphDisableWarnings.h"
#include <boost/ref.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/variant.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/less_equal.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/sizeof.hpp>
#include "VesselGraphRestoreWarnings.h"
 
VESSELGRAPH_BEGIN_NAMESPACE
 
namespace lightweight {
  
  template<typename T>
  class heap_storage
  {
  public:
    typedef heap_storage<T> SelfType;
    
    heap_storage(const T& value=T()) : _value(new T(value)) {};
    heap_storage(const SelfType& other) : _value(new T(*other._value)) {};
    ~heap_storage() { delete _value; };
    
    SelfType& operator=(const SelfType& other) { *_value = *other._value; return *this; }
    SelfType& operator=(const T& other) { *_value = *other._value; return *this; }
 
    bool operator==(const SelfType& other) const { return *_value == *other._value; }
    bool operator!=(const SelfType& other) const { return *_value != *other._value; }
    operator T&() { return *_value; }
    operator const T&() const { return *_value; }
  private:
    T* _value;
  };
  
  // template helper function to access the content of a possibly heap_storage wrapped variable
  template<typename T>
  T& access(T& storage) { return storage; }
  
  template<typename T>
  T& access(heap_storage<T>& storage) { return storage; }
  
  template<typename T>
  const T& access(const heap_storage<T>& storage) { return storage; }
 
  // template meta-function class which is used to get the leightweight type for an arbitrary type
  // if the size of the given type is less or equal to the size of a pointer, 
  struct make_lightweight
  {
    template<typename T>
    struct apply
    {
      typedef typename boost::mpl::if_< 
        typename boost::mpl::less_equal<boost::mpl::sizeof_<T>, boost::mpl::int_<8> >::type, 
        T, 
        heap_storage<T> 
      >::type type;
    };
  };
  
  // a wrapper for visitors which removes heap_storage wrapping of the visited value if applicable
  template<typename VisitorType>
  class lightweight_visitor {
  public:
    typedef typename VisitorType::result_type result_type;
 
    lightweight_visitor(VisitorType& visitor) : _visitor(visitor) {};
 
    template<typename T>
    result_type operator()(T& value) { return _visitor(access(value)); }
 
  private:
    VisitorType& _visitor;
  };
  
  // template function that applies a visitor to the possibly heap_storage wrapped content of a variant
  template<typename VisitorType, typename VariantType>
  inline
  typename VisitorType::result_type apply_visitor(VisitorType& visitor, VariantType& value) { lightweight_visitor<VisitorType> lVisitor(visitor); return boost::apply_visitor(lVisitor, value); }
} // namespace light_variant
 
VESSELGRAPH_END_NAMESPACE
 
#endif // __mlLightweight_HPP_