SharedPtrImpl.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 __SharedPtrImpl_hh__
#define __SharedPtrImpl_hh__

#include <Base/Debug/Exception.hh>
#include <Base/Common/Constraints.hh>

namespace BIAS {

  ///////////////////////////////////////////////////////////////////////
  // access functions
  ///////////////////////////////////////////////////////////////////////

  /** @relates SharedPtr
      @brief access function to the raw pointer
      @author woelk 09/2007 */
  template <class T> 
  T* Get(SharedPtr<T>& t)
  { return (t.Data_)?(t.Data_->Ptr):(0); }
  
  /** @relates SharedPtr
      @brief access function to the raw pointer
      @author woelk 09/2007 */
  template <class T> 
  T* const Get(const SharedPtr<T>& t)
  { return (t.Data_)?(t.Data_->Ptr):(0); }
  
  /** @relates SharedPtr
      @brief access function to the reference count
      @author woelk 09/2007 */
  template <class T> 
  unsigned RefCount(const SharedPtr<T>& t)
  { return (t.Data_)?(t.Data_->Counter):(0u); }

  /** @relates SharedPtr
      @brief DynamicCast function
      @author woelk 02/2008 */
  template <class T, class U> 
  SharedPtr<T> DynamicCast(const SharedPtr<U> &src)
  {
    SharedPtr<T> res;
    return res.DynamicCast(src); 
  }

  /** @relates SharedPtr
      @brief DynamicCast function
      @author woelk 02/2008 */
  template <class T, class U> 
  SharedPtr<T> ConstCast(const SharedPtr<U> &src)
  {
    SharedPtr<T> res;
    return res.ConstCast(src); 
  }

  ///////////////////////////////////////////////////////////////////////
  // constructors
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  SharedPtr<T>::SharedPtr() 
    : Data_(0) 
  {}

  template <class T>
  SharedPtr<T>::SharedPtr(const SharedPtr<T> &pt) 
    : Data_(pt.Data_) 
  { 
    //std::cout << "copied data "<<Data_<<"\n";
    Increment_(); 
  }

  template <class T>
  template <class U>
  SharedPtr<T>::SharedPtr(const SharedPtr<U> &pt) 
    : Data_(reinterpret_cast<SharedPtrBase<T> *>(pt.Data_)) 
  { 
    // check if T = const U
    //SameButConst<U,T> t;
    // to allow assignemnet from child to father
    DerivedFrom<U,T> t;

    //std::cout << "copied data "<<Data_<<"\n";
    Increment_(); 
  }


  template <class T> 
  SharedPtr<T>::SharedPtr(T *pt) 
    : Data_(0)
  {
    if (pt){
      Data_ = new SharedPtrBase<T>(pt);
      //std::cout << "allocated data "<<Data_<<"\n";
    } else {
      //std::cout << "called constructor with null ptr\n";
    }
  }

  template <class T> 
  SharedPtr<T>::~SharedPtr()
  { 
    Decrement_();
  }

  template <class T> 
  SharedPtr<T>& SharedPtr<T>::operator=(const SharedPtr<T> &sp)
  { 
    Decrement_(); 
    Data_ = sp.Data_; 
    Increment_(); 
    return *this; 
  }

  ///////////////////////////////////////////////////////////////////////
  // access functions
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  T& SharedPtr<T>::operator*() const
  {
    if (!Data_){
      BIASERR("Trying to reference a null pointer");
      BIASABORT;
      BEXCEPTION("Trying to reference a null pointer");
    }
    BIASASSERT(Data_->Ptr);
    return *(Data_->Ptr); 
  }

  template <class T> 
  T* SharedPtr<T>::operator->() const
  {
    if (!Data_){
      BIASERR("Trying to access a null pointer");
      BIASABORT;
      BEXCEPTION("Trying to access a null pointer");
    }
    BIASASSERT(Data_->Ptr);
    return Data_->Ptr;
  }


  ///////////////////////////////////////////////////////////////////////
  // if (!ptr)   && if(ptr)
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  bool SharedPtr<T>::operator!() const
  {
    return (Data_ == 0);
  }

  /// enable the expression "if (ptr)", 
  /// see Alexandrescu "Modern C++ design", chap 7.8, p 178
  template <class T> 
  SharedPtr<T>::operator Tester*() const
  {
    if (Data_ == 0) return 0;
    static Tester test;
    return &test;
  }

  ///////////////////////////////////////////////////////////////////////
  // comparison
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator==(const SharedPtr<U> &rs) const
  {
    return (Get(*this) == Get(rs));
  }

  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator!=(const SharedPtr<U> &rs) const
  {
    return (Get(*this) != Get(rs));
  }

  ///////////////////////////////////////////////////////////////////////
  // ordering
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator<(const SharedPtr<U> &rs) const
  {
    return (Get(*this) < Get(rs));
  }
  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator<=(const SharedPtr<U> &rs) const
  {
    return (Get(*this) <= Get(rs));
  }
  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator>(const SharedPtr<U> &rs) const
  {
    return (Get(*this) > Get(rs));
  }
  template <class T> 
  template <class U> 
  bool SharedPtr<T>::operator>=(const SharedPtr<U> &rs) const
  {
    return (Get(*this) >= Get(rs));
  }

  ///////////////////////////////////////////////////////////////////////
  // cast
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  template <class U> 
  SharedPtr<T> SharedPtr<T>::DynamicCast(const SharedPtr<U>& rs)
  {
    T *tmp = dynamic_cast<T *>(Get(rs));
    if (tmp){
      Data_ = reinterpret_cast<SharedPtrBase<T> *>(rs.Data_);
      Increment_(); 
    } else {
      *this = SharedPtr<T>(NULL);
    }
    return *this;
  }

  template <class T> 
  template <class U> 
  SharedPtr<T> SharedPtr<T>::ConstCast(const SharedPtr<U>& rs)
  {
    T *tmp = const_cast<T *>(Get(rs));
    if (tmp){
      Data_ = reinterpret_cast<SharedPtrBase<T> *>(rs.Data_);
      Increment_(); 
    } else {
      *this = SharedPtr<T>(NULL);
    }
    return *this;
  }


  ///////////////////////////////////////////////////////////////////////
  // stream operator
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  std::ostream& operator<<(std::ostream& os, const SharedPtr<T>& t)
  {
    os << Get(t);
    return os;
  }

  ///////////////////////////////////////////////////////////////////////
  // privates
  ///////////////////////////////////////////////////////////////////////

  template <class T> 
  class SharedPtr<T>::Tester
  {
    void operator delete(void *) {};
  };

  template <class T> 
  void SharedPtr<T>::Increment_() 
  { 
    if (Data_) {
      BIASASSERT(Data_->Ptr);
      Data_->Counter++; 
      //std::cout << "incremented "<<Data_->Ptr<<" to "<<Data_->Counter<<"\n";
    }
  }

  template <class T> 
  void SharedPtr<T>::Decrement_()
  { 
    if (Data_){
      BIASASSERT(Data_->Counter>0); 
      BIASASSERT(Data_->Ptr); 
      Data_->Counter--;
      if (Data_->Counter==0){
        //         std::cout << "no references left, deleting ptr "
        //                   <<Data_->Ptr<<"..."<<std::flush;
        delete Data_->Ptr;
        Data_->Ptr = 0;
        //        std::cout << "finished\n";
    
        //        std::cout << "deleting data "<<Data_<<" ... "<<std::flush;
        delete Data_;
        Data_ = 0;
        //        std::cout << "finished\n";
    
      }
    }
  }

}

#endif // __SharedPtrImpl_hh__