SharedPtr.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
#ifndef __SharedPtr_hh__
#define __SharedPtr_hh__

#include "bias_config.h"

#include <Base/Debug/Error.hh>

#include <iostream>

namespace BIAS {
  
  /** @class SharedPtrBase
   *  @test tested with TestSharedPtr.cpp
      @relates SharedPtr
      @brief pool ptr to the data and the reference count
      @author woelk 09/2007 (c) www.vision-n.de */ 
  template <class T>
  class SharedPtrBase
  {
  public:
    SharedPtrBase() : Ptr(0), Counter(0) {}
    SharedPtrBase(T* ptr) : Ptr(ptr), Counter((ptr)?(1):(0)) {}
    virtual ~SharedPtrBase(){}
    T* Ptr;
    unsigned Counter;
  };

  // forward declaration of class 
  template <class T> class SharedPtr;
  
  // forward declaration of friend functions
  template <class T>
  T* Get(SharedPtr<T> &t);
  template <class T>
  T* const Get(const SharedPtr<T> &t);
  template <class T>
  unsigned RefCount(const SharedPtr<T>& t);
  template <class T>
  std::ostream& operator<<(std::ostream& os, const SharedPtr<T>& t);
  template <class T, class U> 
  SharedPtr<T> DynamicCast(const SharedPtr<U> &src);
  template <class T, class U> 
  SharedPtr<T> ConstCast(const SharedPtr<U> &src);


  /** @class SharedPtr
      @ingroup g_utils
      @brief pointer with reference count and automatic deletion
      
      This class is tested see Base/Common/Tests/TestSharedPtr.cpp

      @TODO !this class is not thread safe!

      @author woelk 09/2007 (c) www.vision-n.de */
  template <class T>
  class SharedPtr {
  private:
    /// needed to enable the expression "if (ptr)" while at the same time
    /// preventing "delete ptr" from compiling
    class Tester; 
  public:
    SharedPtr();

    /// needed to enable assignement of SharedPtr<T>
    /// to SharedPtr<const T>
    template <class U>
    SharedPtr(const SharedPtr<U> &pt);

    SharedPtr(const SharedPtr<T> &pt);

    explicit SharedPtr(T *pt);

    virtual ~SharedPtr();

    SharedPtr<T>& operator=(const SharedPtr<T> &sp);

    T& operator*() const;

    T* operator->() const;

    /// enable the expression "if (!ptr)" 
    bool operator!() const;

    /// Enable the expression "if (ptr)", while at the same time preventing 
    /// "delete ptr" from compilling. This is done by providing an automatic 
    /// conversion operator to the "Tester" class. The tester class itself
    /// introduces an additional "delete" function and thus makes "delete ptr"
    /// ambiguous.
    /// See Alexandrescu "Modern C++ design", chap 7.8, p 178
    operator Tester*() const;

    /// comparisons 
    template <class U>
    bool operator==(const SharedPtr<U>& rs) const;
    template <class U>
    bool operator!=(const SharedPtr<U>& rs) const;
    
    /// ordering
    template <class U>
    bool operator<(const SharedPtr<U>& rs) const;
    template <class U>
    bool operator<=(const SharedPtr<U>& rs) const;
    template <class U>
    bool operator>(const SharedPtr<U>& rs) const;
    template <class U>
    bool operator>=(const SharedPtr<U>& rs) const;
    
    // casts
    
    /// eqivalent to *this = dynamic_cast<SharedPtr<T> >(rs)
    template <class U>
    SharedPtr<T> DynamicCast(const SharedPtr<U>& rs);

    /// eqivalent to *this = const_cast<SharedPtr<T> >(rs)
    template <class U>
    SharedPtr<T> ConstCast(const SharedPtr<U>& rs);

    /// access functions
    friend T* Get<>(SharedPtr<T> &t);
    friend T * const Get<>(const SharedPtr<T> &t);
    friend unsigned RefCount<>(const SharedPtr<T>& t);

    /// stream operator
    friend std::ostream& operator<<<>(std::ostream& os, const SharedPtr<T>& t);
 
    // friend class 
    template <class U> friend class SharedPtr;

  private:
    /// hold the  pointer and the reference counter
    SharedPtrBase<T> *Data_;
    
    ///
    void Increment_();

    void Decrement_(); 
    
    
  }; // class 




} // namespace 

#include "SharedPtrImpl.hh"

#endif // __SharedPtr_hh__