PhysicsNtuple/Handle.h

Go to the documentation of this file.

#ifndef ANP_HANDLE_H
#define ANP_HANDLE_H




// C++/C
#include <iostream>

namespace Anp
{
   class Base
   {
   public:
      
      Base();
      virtual ~Base();
         
      void add_ref();
   
      void release();
         
      unsigned int use_count() const;
         
   private:
      
      // copy constructor and assignment operator are
      // private and not implemented by design
      Base(const Base &);
      Base& operator=(const Base &);

   private:
   
      unsigned int fCount;
   };

   //
   // Inlined Base member functions
   //
   inline Base::Base() : fCount(0) {}
   inline Base::~Base() {}
         
   inline void Base::add_ref() { ++fCount; }
   inline void Base::release() { if ( --fCount == 0 ) delete this; }
   inline unsigned int Base::use_count() const { return fCount; }   


template <typename T>
   class Handle 
{
public:

    Handle();
    
    explicit Handle(T* ptr);
    
    Handle(const Handle& rhs);
    
    ~Handle();

    const Handle& operator=(const Handle& rhs);
    
    T* operator->() const;

    T* get() const;
    
    T& operator*() const;

    bool valid() const;

    void release();

private:

    T* p;
    
    void init();
};


template <typename T>
Handle<T>::Handle() : p(0)
{}

template <typename T>
Handle<T>::Handle(T* realPtr) : p(realPtr)
{
    init();
}

template <typename T>
Handle<T>::Handle(const Handle& rhs) : p(rhs.p)
{
    init();
}


template <typename T>
const Handle<T>& Handle<T>::operator=(const Handle& rhs)
{
   if (p != rhs.p)
   {
      if (p)
      {
         p -> release();
      }
      
      p = rhs.p;
      init();
   }

   return *this;
}


template <typename T>
void Handle<T>::init()
{
   if (p)
   {
      p -> add_ref();
   }
}

template <typename T>
Handle<T>::~Handle()
{
   if (p)
   {
      p -> release();
   }
}

template <typename T>
T* Handle<T>::operator->() const 
{ 
   return p; 
}

template <typename T>
T* Handle<T>::get() const 
{ 
   return p; 
}

template <typename T>
T& Handle<T>::operator*() const 
{ 
   return *p; 
}

template <typename T>
bool Handle<T>::valid() const
{
   if (p)
   {
      return true;
   }
   
   return false;
}

template <typename T>
   void Handle<T>::release()
{
   if (p)
   {
      p -> release();
   }
   p = 0;
}
   
template <typename T>
std::ostream& operator<<(std::ostream& o, const Handle<T>& handle)
{
   o << *handle;
   return o;
}

} // end of Anp namespace

#endif  // HANDLE_H

---