referencecounter.hh

#ifndef DUNE_FEM_REFERENCECOUNTER_HH
#define DUNE_FEM_REFERENCECOUNTER_HH
 
#include <cassert>
#include <type_traits>
 
#include <dune/fem/misc/bartonnackmaninterface.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    template< class RCT >
    class ReferenceCounterInterface
    : public BartonNackmanInterface< ReferenceCounterInterface< RCT >, typename RCT::ReferenceCounterType >
    {
      typedef ReferenceCounterInterface< RCT > ThisType;
      typedef BartonNackmanInterface< ThisType, typename RCT::ReferenceCounterType > BaseType;
 
    public:
      typedef RCT Traits;
 
      typedef typename Traits::ReferenceCounterType ReferenceCounterType;
 
      typedef ThisType ReferenceCounterInterfaceType;
 
      typedef typename Traits::ObjectType ObjectType;
 
    protected:
      using BaseType::asImp;
 
    public:
      void addReference () const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().addReference() );
      }
 
      void deleteObject ()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().deleteObject() );
      }
 
      const ObjectType &getObject () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().getObject() );
        return asImp().getObject();
      }
 
      ObjectType &getObject ()
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().getObject() );
        return asImp().getObject();
      }
 
      void removeReference () const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().removeReference() );
      }
    };
 
 
 
    template< class ReferenceCounter >
    struct SupportsReferenceCounterInterface
    {
      typedef ReferenceCounterInterface< typename ReferenceCounter::Traits > ReferenceCounterInterfaceType;
      static const bool v = std::is_convertible< ReferenceCounter, ReferenceCounterInterfaceType >::value;
    };
 
 
 
    template< class RCT >
    class ReferenceCounterDefault
    : public ReferenceCounterInterface< RCT >
    {
      typedef ReferenceCounterDefault< RCT > ThisType;
      typedef ReferenceCounterInterface< RCT > BaseType;
 
    public:
      typedef typename BaseType::ReferenceCounterType ReferenceCounterType;
 
    protected:
      using BaseType::asImp;
 
    public:
      explicit ReferenceCounterDefault ( unsigned int refcount = 1 )
      : refcount_( refcount )
      {}
 
      ReferenceCounterDefault ( const ThisType& ) = delete;
      ThisType& operator= ( const ThisType& ) = delete;
 
      void addReference () const
      {
        ++refcount_;
      }
 
      void deleteObject ()
      {
        delete this;
      }
 
      void removeReference () const
      {
        assert( refcount_ > 0 );
        --refcount_;
        if( refcount_ == 0 )
          const_cast< ReferenceCounterType& >( asImp() ).deleteObject();
      }
 
      unsigned int referenceCounter () const { return refcount_; }
 
    protected:
      mutable unsigned int refcount_;
    };
 
 
 
    template< class ReferenceCounter >
    class ObjectPointer
    {
      typedef ObjectPointer< ReferenceCounter > ThisType;
 
      static_assert( SupportsReferenceCounterInterface< ReferenceCounter >::v, "ObjectPointer can only point to reference counting types." );
 
    public:
      typedef ReferenceCounter ReferenceCounterType;
 
      typedef typename ReferenceCounterType::ObjectType ObjectType;
 
      explicit ObjectPointer ( ReferenceCounterType *const object = 0 )
      : object_( object )
      {
        if( object_ != 0 )
          object_->addReference();
      }
 
      ObjectPointer ( const ThisType &other )
      : object_( other.object_ )
      {
        if( object_ != 0 )
          object_->addReference();
      }
 
      ~ObjectPointer ()
      {
        if( object_ != 0 )
          object_->removeReference();
      }
 
      ThisType &operator= ( const ThisType &other )
      {
        // Note that it is safe to remove the reference first. If other holds
        // a reference to the same object, the reference counter cannot reach
        // zero.
        if( object_ != 0 )
          object_->removeReference();
        object_ = other.object_;
        if( object_ != 0 )
          object_->addReference();
 
        return *this;
      }
 
      ObjectType &operator* () const
      {
        assert( object_ != 0 );
        return object_->getObject();
      }
 
      unsigned int referenceCounter () const { return object_->referenceCounter(); }
 
    protected:
      ReferenceCounterType *object_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_REFERENCECOUNTER_HH