MnRefCountedPointer.h

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
 
/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/
 
#ifndef ROOT_Minuit2_MnRefCountedPointer
#define ROOT_Minuit2_MnRefCountedPointer
 
#include "MnReferenceCounter.h"
 
namespace ROOT {
 
namespace Minuit2 {
 
template <class T>
class MnRefCountedPointer {
 
public:
   // Default constructor needed for use inside array, vector, etc.
   MnRefCountedPointer() : fPtr(0), fCounter(0) {}
 
   MnRefCountedPointer(T *pt) : fPtr(pt), fCounter(new MnReferenceCounter()) { AddReference(); }
 
   MnRefCountedPointer(const MnRefCountedPointer<T> &other) : fPtr(other.fPtr), fCounter(other.fCounter)
   {
      AddReference();
   }
 
   ~MnRefCountedPointer()
   {
      /*
      if(References() == 0) {
        if(fPtr) delete fPtr;
        if(fCounter) delete fCounter;
      }
      else RemoveReference();
      */
      if (References() != 0)
         RemoveReference();
   }
 
   bool IsValid() const { return fPtr != 0; }
 
   MnRefCountedPointer &operator=(const MnRefCountedPointer<T> &other)
   {
      if (this != &other && fPtr != other.fPtr) {
         RemoveReference();
         fPtr = other.fPtr;
         fCounter = other.fCounter;
         AddReference();
      }
      return *this;
   }
 
   MnRefCountedPointer &operator=(T *ptr)
   {
      if (fPtr != ptr) {
         fPtr = ptr;
         fCounter = new MnReferenceCounter();
      }
      return *this;
   }
 
   T *Get() const { return fPtr; }
 
   T *operator->() const
   {
      DoCheck();
      return fPtr;
   }
 
   T &operator*() const
   {
      DoCheck();
      return *fPtr;
   }
 
   bool operator==(const T *otherP) const { return fPtr == otherP; }
 
   bool operator<(const T *otherP) const { return fPtr < otherP; }
 
   unsigned int References() const { return fCounter->References(); }
 
   void AddReference() const { fCounter->AddReference(); }
 
   void RemoveReference()
   {
      fCounter->RemoveReference();
      if (References() == 0) {
         delete fPtr;
         fPtr = 0;
         delete fCounter;
         fCounter = 0;
      }
   }
 
private:
   T *fPtr;
   MnReferenceCounter *fCounter;
 
private:
   void DoCheck() const { assert(IsValid()); }
};
 
} // namespace Minuit2
 
} // namespace ROOT
 
#endif // ROOT_Minuit2_MnRefCountedPointer