itkAutoPointer.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkAutoPointer_h
#define itkAutoPointer_h
 
#include "itkMacro.h"
#include <iostream>
 
namespace itk
{
template <typename TObjectType>
class AutoPointer
{
public:
  using ObjectType = TObjectType;
  using Self = AutoPointer;

  AutoPointer()
    : m_Pointer(nullptr)
  {}

  explicit AutoPointer(AutoPointer & p)
    : m_IsOwner(p.IsOwner())
    , m_Pointer(p.ReleaseOwnership())
  {}

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

  ~AutoPointer() { this->Reset(); }

  ObjectType *
  operator->() const
  {
    return m_Pointer;
  }

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

  void
  TakeOwnership()
  {
    m_IsOwner = true;
  }

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

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

  [[nodiscard]] bool
  IsOwner() const
  {
    return m_IsOwner;
  }

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

  [[nodiscard]] ObjectType *
  GetPointer() const
  {
    return m_Pointer;
  }

  bool
  operator==(const AutoPointer & r) const
  {
    return m_Pointer == r.m_Pointer;
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);

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

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

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

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

  AutoPointer &
  operator=(AutoPointer & r)
  {
    AutoPointer(r).Swap(*this);
    return *this;
  }

  operator bool() const { return (m_Pointer != nullptr); }

  /*  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) noexcept
  {
    ObjectType * temp = m_Pointer;
 
    m_Pointer = r.m_Pointer;
    r.m_Pointer = temp;
  }

  bool         m_IsOwner{ false };
  ObjectType * m_Pointer;
};
 
template <typename T>
std::ostream &
operator<<(std::ostream & os, const AutoPointer<T> p)
{
  p.Print(os);
  os << "Owner: " << p.IsOwner() << std::endl;
  return os;
}

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