itkAutoPointer.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkAutoPointer.h,v $
  Language:  C++
  Date:      $Date: 2002/10/01 18:37:42 $
  Version:   $Revision: 1.6 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkAutoPointer_h
#define __itkAutoPointer_h

#include "itkMacro.h"
#include <iostream>

namespace itk
{

template <class TObjectType>
class ITK_EXPORT AutoPointer 
{
public:
  typedef TObjectType   ObjectType;
  typedef AutoPointer   Self;
  
  AutoPointer ():
    m_Pointer(0),
    m_IsOwner(false)
    { }

  explicit AutoPointer ( AutoPointer & p )
    {
    m_IsOwner = p.IsOwner(); // Ownership can only be taken from another owner
    m_Pointer = p.ReleaseOwnership(); // release ownership if appropriate
    }


  explicit AutoPointer ( ObjectType * p, bool takeOwnership ):
                    m_Pointer(p),
                    m_IsOwner(takeOwnership)
      { }


  ~AutoPointer ()
    { 
    if( m_IsOwner && m_Pointer ) 
      { 
      delete m_Pointer;
      }
    m_Pointer = 0;
    m_IsOwner = false;
    }
  
  ObjectType *operator -> () const
    { return m_Pointer; }

  void Reset( void ) 
    {
    if( m_IsOwner && m_Pointer ) 
      { 
      delete m_Pointer;
      }
    m_Pointer = 0;
    m_IsOwner = false;
    }


  void TakeOwnership(void) 
    { m_IsOwner = true; }

  void TakeOwnership(ObjectType * objectptr) 
    { 
    if( m_IsOwner && m_Pointer ) 
      { 
      delete m_Pointer; // remove the current one
      }
    m_Pointer = objectptr;
    m_IsOwner = true;
    }

  void TakeNoOwnership(ObjectType * objectptr) 
    { 
    if( m_IsOwner && m_Pointer ) 
      { 
      delete m_Pointer; // remove the current one
      }
    m_Pointer = objectptr;
    m_IsOwner = false;
    }

  bool IsOwner(void) const
    { return m_IsOwner; }

  ObjectType * ReleaseOwnership( void ) 
    {
    m_IsOwner = false;
    return m_Pointer;
    }

  ObjectType *GetPointer () const 
    { return m_Pointer; }

  bool operator == (const AutoPointer &r) const
    { return (void*)m_Pointer == (void*) r.m_Pointer; }

  bool operator != (const AutoPointer &r) const
    { return (void*)m_Pointer != (void*) r.m_Pointer; }
  
  bool operator < (const AutoPointer &r) const
    { return (void*)m_Pointer < (void*) r.m_Pointer; }
  
  bool operator > (const AutoPointer &r) const
    { return (void*)m_Pointer > (void*) r.m_Pointer; }

  bool operator <= (const AutoPointer &r) const
    { return (void*)m_Pointer <= (void*) r.m_Pointer; }

  bool operator >= (const AutoPointer &r) const
    { return (void*)m_Pointer >= (void*) r.m_Pointer; }

  AutoPointer &operator = (AutoPointer &r) const
    { 
    AutoPointer( r ).Swap( *this );
    return *this;
    }
  
  operator bool () const
    { return (m_Pointer!=NULL); }

  ObjectType *Print (std::ostream& os) const 
    { 
    // This prints the object pointed to by the pointer  
    (*m_Pointer).Print(os);  
    os << "Owner: " << m_IsOwner << std::endl;
    return m_Pointer;
    } 

private:

  void Swap(AutoPointer &r) throw()
    { 
    ObjectType * temp = m_Pointer;
    m_Pointer         = r.m_Pointer;
    r.m_Pointer       = temp; 
    }
 

  ObjectType* m_Pointer;
  bool        m_IsOwner;
};  

  
template <typename T>
std::ostream& operator<< (std::ostream& os, AutoPointer<T> p) 
{
  p.Print(os); 
  os << "Owner: " << p.IsOwner() << std::endl;
  return os;
}


template <typename TAutoPointerBase, typename TAutoPointerDerived>
void
ITK_EXPORT TransferAutoPointer(TAutoPointerBase & pa, TAutoPointerDerived & pb)
{
  pa.TakeNoOwnership( pb.GetPointer() ); // give a chance to natural polymorphism
  if( pb.IsOwner() )
    {
    pa.TakeOwnership();      // pa Take Ownership
    pb.ReleaseOwnership();   // pb Release Ownership and clears
    }
}


} // end namespace itk
  
#endif

---