Handle.hpp

#pragma once
 
//boost
#ifdef WIN32
#  include <boost/detail/interlocked.hpp>
#endif
// atomic unsigned int classes
 
#ifdef BOOST_INTERLOCKED_INCREMENT  // Windows
#define IPF_ATOMIC_UNSIGNED  unsigned int
#define IPF_ATOMIC_INCREMENT(a) BOOST_INTERLOCKED_INCREMENT((long volatile *)&a)
#define IPF_ATOMIC_DECREMENT(a) BOOST_INTERLOCKED_DECREMENT((long volatile *)&a)
 
#elif defined(__GNUG__) // Linux
#include <atomic>
 
#define IPF_ATOMIC_UNSIGNED std::atomic<unsigned int>
#define IPF_ATOMIC_INCREMENT(a) static_cast<unsigned volatile>(++(a))
#define IPF_ATOMIC_DECREMENT(a) static_cast<unsigned volatile>(--(a))
 
#else
#  error "Unable to find atomic"
#endif
 
#include <boost/type_traits/is_base_of.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/is_scalar.hpp>
#include <boost/static_assert.hpp>
 
#include <assert.h>
#include <limits>
//PA
#include "DM/config.hpp"
#include "DM/ObjectBaseRefCounting.hpp"
 
//NG
#include "NG_Exception.hpp"
 
DM_NAMESPACE_BEGIN
 
DM_API void *allocate_internal(size_t);   //allocates memory inside DM heap
DM_API void deallocate_internal(void *);  //frees allocated memory from the DM heap
 
/**
  \brief  Allocator template class using new/delete
  \author JO
  \date   07.04.2005
  \see    PH_malloc_allocator
  
  The allocator class can be used in PH_List, PH_listOld, PH_vector and its 
  super classes as memory manager. The class uses new and delete for managing
  the memory. The code is based on the Boost Library http://www.boost.org/
*/
template <typename T>
struct DM_API Default_allocator
{
  typedef T * pointer;
  typedef const T * const_pointer;
  typedef T & reference;
  typedef const T & const_reference;
  typedef T value_type;
 
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
 
  template <typename U>
  struct rebind
  {
    typedef Default_allocator<U> other;
  };
 
  static pointer address(reference r) { return &r; }
  static const_pointer address(const_reference r) { return &r; }
 
  static pointer allocate(const size_type n, const pointer = 0)
  { return (pointer)allocate_internal(n * sizeof(T)); }
 
  static void deallocate(const pointer p, const size_type)
  { deallocate_internal((char *)p); }
  static size_type max_size() { return (std::numeric_limits<size_type>::max)(); }
 
  bool operator==(const Default_allocator &) const { return true; }
  bool operator!=(const Default_allocator &) const { return false; }
 
  Default_allocator() { }
  template <typename U>
  Default_allocator(const Default_allocator<U> &) { }
 
  static void construct(const pointer p, const_reference t)
  { new ((void *) p) T(t); }
  static void destroy(const pointer p)
  { p->~T(); }
};
 
 
/// \brief Smart pointer class using reference counting with support for DM objects (see ObjectBase)
template <class T, bool Thread_safe = true, class C = unsigned int, class Alloc = Default_allocator<T> >
class Handle
{
  template<bool Tb>
  struct bool_tag { typedef boost::integral_constant<bool,Tb> type; };
 
  /// the notify struct is used to communicate the reference conuter to the object it self (of derived from ObjectBaseRefCounting)
  template<typename AnyT, class CC = unsigned int>
  struct notify {
    //non notifying
    inline CC inc(T *t, CC count) const { return count; }
    inline CC dec(T *t, CC count) const { return count; }
  };
  template<class CC>
  struct notify<boost::true_type,CC> {
    //notifying template specialization
    inline CC inc(T *t, CC count) const { static_cast<ObjectBaseRefCounting *>(t)->refAdded(count);   return count; }
    inline CC dec(T *t, CC count) const { static_cast<ObjectBaseRefCounting *>(t)->refRemoved(count); return count; }
  };
 
 
  template<class TT, bool Thread_safe_, class CC = unsigned int>
  struct RefCountedT {
    typedef notify< typename boost::is_base_of<ObjectBaseRefCounting, typename boost::remove_pointer<T>::type >::type, CC> notify_type;
 
    inline CC increaseCount() { return notify_type().inc( t, IPF_ATOMIC_INCREMENT(count) ); }
    inline CC decreaseCount() { return notify_type().dec( t, IPF_ATOMIC_DECREMENT(count) ); }
    inline CC getCount() const { return static_cast<CC const volatile &>( count ); }    
 
    TT t;
#if defined(__GNUG__) // Linux
    std::atomic<CC> count;
#else
    CC count;
#endif
  };
  /// Non-thread safe specialisation
  template<class TT, class CC> 
  struct RefCountedT<TT, false, CC > {
    typedef notify< typename boost::is_base_of<ObjectBaseRefCounting, typename boost::remove_pointer<TT>::type >::type, CC> notify_type;
 
    inline CC increaseCount() { return notify_type().inc( t, ++count); }
    inline CC decreaseCount() { return notify_type().dec( t, --count); }
    inline CC getCount() const { return count; }    
    
    TT t;
    CC count;
  };
 
  
  typedef RefCountedT<T *, Thread_safe, C>                        RefCounted;
  typedef typename Alloc::template rebind< RefCounted >::other    Allocator;
  typedef typename Allocator::pointer                             pointer;
 
  static Allocator   allocator;
  pointer            ptr_;
 
  typedef Handle<T, Thread_safe, C, Alloc> self;
 
 
  void Delete(boost::false_type& isScalar, T *&t) {
    t->Delete();
  }
  void Delete(boost::true_type& isScalar, T *&t) {
    throw NG_exception("scalar types are not suited for this Handle class, since the do not provide a Delete function");
    //delete t;
  }
 
public:
  typedef T element_type;
 
  struct use_dynamic_cast {};
  struct use_static_cast {};
 
  Handle() : ptr_(0)
  {
  }
 
  Handle(const Handle& h)
    : ptr_(h.ptr_)
  {
    if (ptr_)
    {
      assert( (ptr_->count) < (std::numeric_limits<C>::max)() );
      ptr_->increaseCount();
    }
  }
 
  template<class T2, bool TS2, class C2, class A2>
  Handle(const Handle<T2, TS2, C2, A2> &other) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_static_cast<T2, TS2, C2, A2, 
                     typename boost::is_base_of<T, T2>::type,
                     typename boost::is_same<bool_tag<Thread_safe>, bool_tag<TS2>>::type, 
                     typename boost::is_same<Allocator, typename A2::template rebind< RefCounted >::other>::type >()(other.ptr_);
      assert( (ptr_->count) < (std::numeric_limits<C>::max)() );
      ptr_->increaseCount();
    }
  }
 
  template<class T2, bool TS2, class C2, class A2>
  Handle(const Handle<T2, TS2, C2, A2> &other, const use_static_cast &) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_static_cast<T2, TS2, C2, A2, 
                     typename boost::true_type,
                     typename boost::is_same<bool_tag<Thread_safe>, bool_tag<TS2>>::type, 
                     typename boost::is_same<Allocator, typename A2::template rebind< RefCounted >::other>::type >()(other.ptr_);
      assert( (ptr_->count) < (std::numeric_limits<C>::max)() );
      ptr_->increaseCount();
    }
  } 
  
  template<class T2, bool TS2, class C2, class A2>
  Handle(const Handle<T2, TS2, C2, A2> &other, const use_dynamic_cast &) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_dynamic_cast<T2, TS2, C2, A2, 
                     typename boost::is_same<bool_tag<Thread_safe>, bool_tag<TS2>>::type, 
                     typename boost::is_same<Allocator, typename A2::template rebind< RefCounted >::other>::type >()(other.ptr_);
      if (ptr_)
      {
        assert( (ptr_->count) < (std::numeric_limits<C>::max)() );
        ptr_->increaseCount();
      }
    }
  }
 
  Handle(T* p) : ptr_(0)
  {
    if (p)
    {
      ptr_ = (allocator.allocate(1));
      ptr_->t     = p;
      ptr_->count = 1;
    }
  }
 
 
 
  ~Handle()
  {
    if (ptr_)
    {
      if (ptr_->decreaseCount() == 0 ) 
      {
        //delete ptr_->t;
        typename boost::is_scalar<T>::type type;
        Delete( type, ptr_->t );
        allocator.destroy( ptr_);
        allocator.deallocate( ptr_, 1);
      }
    }
  }
 
  Handle& operator=(const Handle& h)
  {
      Handle tmp = h;
      swap(tmp);
      return *this;
  }
 
  template<class T2, bool TS2, class C2, class A2>
  Handle& operator=(const Handle<T2, TS2, C2, A2> &other)
  {
      Handle tmp = other;
      swap(tmp);
      return *this;
  }
 
  Handle&
  operator=(T *p)
  {
   *this = Handle(p);
    return *this;
  }
 
  size_type
  id() const
  { return reinterpret_cast<size_type>(&*ptr_); }
 
  /*void create_from_id(size_type id)
  {
    Handle tmp;
    tmp.ptr_ = reinterpret_cast<RefCounted *>(id);
    tmp.ptr_->increaseCount();
    swap(tmp);
  }*/
 
  operator const T &() const {
    return *(ptr_->t);
  }
 
  operator       T &()       {
    return *(ptr_->t);
  }
 
  const T *ptr() const
  {
    return (ptr_) ? ptr_->t : 0;
  }
 
  const T & operator*() const { return *(ptr_->t); }
        T & operator*()       { return *(ptr_->t); }
  const T * operator->() const { return (ptr_) ? ptr_->t : 0; }
        T * operator->()       { return (ptr_) ? ptr_->t : 0; }
 
  bool is_shared() const
  {
    return (ptr_ && ptr_->count > 1);
  }
 
  C get_count() const 
  {
    return (ptr_ ? ptr_->getCount() : 0);
  }
 
  T *release() 
  {
    if( ptr_ )
    {
      if (ptr_->decreaseCount() != 0)
        throw NG_exception("Shared objects (reference counter > 1) cannot be released");
 
      T *p = ptr_->t;
      allocator.destroy( ptr_);
      allocator.deallocate( ptr_, 1);
      ptr_ = 0;
      return p;
    }
    return 0;
  }
 
  void swap(Handle& h)
  {
    std::swap(ptr_, h.ptr_);
  }
 
  void reset() {
    Handle h = Handle();
    swap( h );
  }
 
  Handle clone() const
  {
    return (ptr_ ? Handle( ptr_->t->clone() ) : Handle() );
  }
 
  bool operator==(const Handle& h) const
  {
    return (ptr_ == h.ptr_);
  }
 
  bool operator!=(const Handle& h) const
  {
    return (ptr_ != h.ptr_);
  }
 
  bool operator>(const Handle& h) const
  {
    return (ptr_ > h.ptr_);
  }
 
  bool operator<(const Handle& h) const
  {
    return (ptr_ < h.ptr_);
  }
 
  typedef const T * (self::*unspecified_bool_type)() const;
 
  operator unspecified_bool_type() const
  {
      return ptr_ == 0
        ? 0
        : &self::ptr;
  }
 
protected:
  
  template<typename T2, bool TS2, class C2, class A2, typename BaseFlag, typename SameThreadFlag, typename SameAllocFlag>
  struct do_static_cast {
    RefCounted * operator()(const typename  Handle<T2, TS2, C2, A2>::RefCounted *ptr) {
      BOOST_STATIC_ASSERT(sizeof(ptr)==0);  //if you get an error here, an illegale handle conversion was tried to perfom:
                                  //possible reasons:
                                  //  * Thread_flag is different
                                  //  * C type (reference counter) is different
                                  //  * Allocator type is different
 
      return 0;
    }
  };
 
  template<typename T2, bool TS2, class A2>
  struct do_static_cast<T2, TS2, C, A2, boost::false_type, boost::true_type, boost::true_type> {
    RefCounted * operator()(const typename Handle<T2, TS2, C, A2>::RefCounted *ptr) {
      BOOST_STATIC_ASSERT(sizeof(ptr)==0);  //if you get an error here, an illegale cast was tried to perfom: 
                                  //T is not a base T2. You may try to use the "use_static_cast constructor"
 
      return 0;
    }
  };
 
  template<typename T2, bool TS2, class A2>
  struct do_static_cast<T2, TS2, C, A2, boost::true_type, boost::true_type, boost::true_type> {
    RefCounted * operator()(const typename Handle<T2, TS2, C, A2>::RefCounted *ptr) {
      return (RefCounted *)((void *)(ptr));
    }
  };
 
 
 
 
  template<typename T2, bool TS2, class C2, class A2, typename SameThreadFlag, typename SameAllocFlag>
  struct do_dynamic_cast {
    RefCounted * operator()(const typename  Handle<T2, TS2, C2, A2>::RefCounted *ptr) {
      BOOST_STATIC_ASSERT(sizeof(ptr)==0);  //if you get an error here, an illegale handle conversion was tried to perfom:
                                  //possible reasons:
                                  //  * Thread_flag is different
                                  //  * C type (reference counter) is different
                                  //  * Allocator type is different
 
      return 0;
    }
  };
 
  template<typename T2, bool TS2, class A2>
  struct do_dynamic_cast<T2, TS2, C, A2, boost::true_type, boost::true_type> {
    RefCounted * operator()(const typename Handle<T2, TS2, C, A2>::RefCounted *ptr) {
      T *p = dynamic_cast<T*>(ptr->t);
      if (p)
        return (RefCounted *)((void *)(ptr));
      else
        return 0;
    }
  };
 
 
  template<class T2, bool TT2, class C2, class A2>
  friend class Handle;
};
 
 
template <class T, bool TT, class C, class Allocator>
typename Handle<T, TT, C, Allocator>::Allocator
Handle<T, TT, C, Allocator>::allocator;
 
template <class T, bool TT, class C, class Allocator>
inline void swap(Handle<T, TT, C, Allocator> &h1, Handle<T, TT, C, Allocator> &h2)
{
  h1.swap(h2);
}
 
template <class T>
class StaticHandle
{
  typedef StaticHandle<T> self;
 
  typedef T*         pointer;
  pointer            ptr_;
 
public:
  typedef T element_type;
 
  struct use_dynamic_cast {};
  struct use_static_cast {};
 
  StaticHandle() : ptr_(0)
  {
  }
 
  StaticHandle(const StaticHandle& h)
    : ptr_(h.ptr_)
  {
  }
 
  template<class T2>
  StaticHandle(const StaticHandle<T2> &other) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_static_cast<T2, typename boost::is_base_of<T, T2>::type >()(other.ptr_);
    }
  }
 
  template<class T2>
  StaticHandle(const StaticHandle<T2> &other, const use_static_cast &) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_static_cast<T2, boost::true_type >()(other.ptr_);
    }
  } 
  
  template<class T2>
  StaticHandle(const StaticHandle<T2> &other, const use_dynamic_cast &) : ptr_(0)
  {
    if (other.ptr_)
    {
      ptr_ = do_dynamic_cast<T2>()(other.ptr_);
    }
  }
 
  StaticHandle(T* p) : ptr_(p)
  {
  }
 
  ~StaticHandle()
  {
  }
 
  StaticHandle& operator=(const StaticHandle& h)
  {
    ptr_ = h.ptr_;
    return *this;
  }
 
  template<class T2>
  StaticHandle& operator=(const StaticHandle<T2> &other)
  {
    StaticHandle tmp = other;
    ptr_ = tmp.ptr_;
    return *this;
  }
 
  StaticHandle&
  operator=(T *p)
  {
    ptr_ = p;
    return *this;
  }
 
  size_type
  id() const
  { return reinterpret_cast<size_type>(ptr_); }
 
  operator const T &() const {
    return *(ptr_);
  }
 
  const T *ptr() const
  {
    return (ptr_);
  }
 
  T &operator*() const { return *(ptr_); }
  T *operator->() const { return (ptr_); }
 
  /*bool is_shared() const
  {
    return (ptr_ && ptr_->count > 1);
  }
 
  C get_count() const 
  {
    return (ptr_ ? ptr_->getCount() : 0);
  }*/
 
  void swap(StaticHandle& h)
  {
    std::swap(ptr_, h.ptr_);
  }
 
  void reset() {
    ptr_ = (T *)0;
  }
 
  StaticHandle clone() const
  {
    return StaticHandle(ptr_);
  }
 
  bool operator==(const StaticHandle& h) const
  {
    return (ptr_ == h.ptr_);
  }
 
  bool operator!=(const StaticHandle& h) const
  {
    return (ptr_ != h.ptr_);
  }
 
  bool operator>(const StaticHandle& h) const
  {
    return (ptr_ > h.ptr_);
  }
 
  bool operator<(const StaticHandle& h) const
  {
    return (ptr_ < h.ptr_);
  }
 
  operator bool() const
  {
    return ptr_ != (T *)0;
  }
 
protected:
  
  template<typename T2, typename TagT>
  struct do_static_cast {
    pointer operator()(const typename StaticHandle<T2>::pointer *ptr) {
      BOOST_STATIC_ASSERT(sizeof(ptr)==0);  //if you get an error here, an illegale cast was tried to perfom: 
                                  //T is not a base T2. You may try to use the "use_static_cast constructor"
      return 0;
    }
  };
 
  template<typename T2>
  struct do_static_cast<T2, boost::true_type> {
    pointer operator()(const typename StaticHandle<T2>::pointer *ptr) {
      return (pointer)(ptr);
    }
  };
 
  template<typename T2>
  struct do_dynamic_cast {
    pointer operator()(const typename StaticHandle<T2>::pointer *ptr) {
      return dynamic_cast<pointer>(ptr);
    }
  };
 
 
  template<class T2>
  friend class StaticHandle;
};
 
 
 
DM_NAMESPACE_END