smartpointer.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, 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.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_smartpointer_h
#define dealii_smartpointer_h


#include <deal.II/base/config.h>

#include <deal.II/base/exceptions.h>

#include <atomic>
#include <typeinfo>

DEAL_II_NAMESPACE_OPEN

template <typename T, typename P = void>
class SmartPointer
{
public:
  SmartPointer();

  template <class Q>
  SmartPointer(const SmartPointer<T, Q> &tt);

  SmartPointer(const SmartPointer<T, P> &tt);

  SmartPointer(T *t, const std::string &id);

  SmartPointer(T *t);

  ~SmartPointer();

  SmartPointer<T, P> &
  operator=(T *tt);

  template <class Q>
  SmartPointer<T, P> &
  operator=(const SmartPointer<T, Q> &tt);

  SmartPointer<T, P> &
  operator=(const SmartPointer<T, P> &tt);

  void
  clear();

  operator T *() const;

  T &operator*() const;

  T *operator->() const;

  template <class Q>
  void
  swap(SmartPointer<T, Q> &tt);

  void
  swap(T *&tt);

  std::size_t
  memory_consumption() const;

private:
  T *t;

  const std::string id;

  std::atomic<bool> pointed_to_object_is_alive;
};


/* --------------------- inline Template functions ------------------------- */


template <typename T, typename P>
inline SmartPointer<T, P>::SmartPointer()
  : t(nullptr)
  , id(typeid(P).name())
  , pointed_to_object_is_alive(false)
{}



template <typename T, typename P>
inline SmartPointer<T, P>::SmartPointer(T *t)
  : t(t)
  , id(typeid(P).name())
  , pointed_to_object_is_alive(false)
{
  if (t != nullptr)
    t->subscribe(&pointed_to_object_is_alive, id);
}



template <typename T, typename P>
inline SmartPointer<T, P>::SmartPointer(T *t, const std::string &id)
  : t(t)
  , id(id)
  , pointed_to_object_is_alive(false)
{
  if (t != nullptr)
    t->subscribe(&pointed_to_object_is_alive, id);
}



template <typename T, typename P>
template <class Q>
inline SmartPointer<T, P>::SmartPointer(const SmartPointer<T, Q> &tt)
  : t(tt.t)
  , id(tt.id)
  , pointed_to_object_is_alive(false)
{
  if (tt.pointed_to_object_is_alive && t != nullptr)
    t->subscribe(&pointed_to_object_is_alive, id);
}



template <typename T, typename P>
inline SmartPointer<T, P>::SmartPointer(const SmartPointer<T, P> &tt)
  : t(tt.t)
  , id(tt.id)
  , pointed_to_object_is_alive(false)
{
  if (tt.pointed_to_object_is_alive && t != nullptr)
    t->subscribe(&pointed_to_object_is_alive, id);
}



template <typename T, typename P>
inline SmartPointer<T, P>::~SmartPointer()
{
  if (pointed_to_object_is_alive && t != nullptr)
    t->unsubscribe(&pointed_to_object_is_alive, id);
}



template <typename T, typename P>
inline void
SmartPointer<T, P>::clear()
{
  if (pointed_to_object_is_alive && t != nullptr)
    {
      t->unsubscribe(&pointed_to_object_is_alive, id);
      delete t;
      Assert(pointed_to_object_is_alive == false, ExcInternalError());
    }
  t = nullptr;
}



template <typename T, typename P>
inline SmartPointer<T, P> &
SmartPointer<T, P>::operator=(T *tt)
{
  // optimize if no real action is
  // requested
  if (t == tt)
    return *this;

  if (pointed_to_object_is_alive && t != nullptr)
    t->unsubscribe(&pointed_to_object_is_alive, id);
  t = tt;
  if (tt != nullptr)
    tt->subscribe(&pointed_to_object_is_alive, id);
  return *this;
}



template <typename T, typename P>
template <class Q>
inline SmartPointer<T, P> &
SmartPointer<T, P>::operator=(const SmartPointer<T, Q> &tt)
{
  // if objects on the left and right
  // hand side of the operator= are
  // the same, then this is a no-op
  if (&tt == this)
    return *this;

  if (pointed_to_object_is_alive && t != nullptr)
    t->unsubscribe(&pointed_to_object_is_alive, id);
  t = static_cast<T *>(tt);
  if (tt.pointed_to_object_is_alive && tt != nullptr)
    tt->subscribe(&pointed_to_object_is_alive, id);
  return *this;
}



template <typename T, typename P>
inline SmartPointer<T, P> &
SmartPointer<T, P>::operator=(const SmartPointer<T, P> &tt)
{
  // if objects on the left and right
  // hand side of the operator= are
  // the same, then this is a no-op
  if (&tt == this)
    return *this;

  if (pointed_to_object_is_alive && t != nullptr)
    t->unsubscribe(&pointed_to_object_is_alive, id);
  t = static_cast<T *>(tt);
  if (tt.pointed_to_object_is_alive && tt != nullptr)
    tt->subscribe(&pointed_to_object_is_alive, id);
  return *this;
}



template <typename T, typename P>
inline SmartPointer<T, P>::operator T *() const
{
  return t;
}



template <typename T, typename P>
inline T &SmartPointer<T, P>::operator*() const
{
  Assert(t != nullptr, ExcNotInitialized());
  Assert(pointed_to_object_is_alive,
         ExcMessage("The object pointed to is not valid anymore."));
  return *t;
}



template <typename T, typename P>
inline T *SmartPointer<T, P>::operator->() const
{
  Assert(t != nullptr, ExcNotInitialized());
  Assert(pointed_to_object_is_alive,
         ExcMessage("The object pointed to is not valid anymore."));
  return t;
}



template <typename T, typename P>
template <class Q>
inline void
SmartPointer<T, P>::swap(SmartPointer<T, Q> &tt)
{
#ifdef DEBUG
  SmartPointer<T, P> aux(t, id);
  *this = tt;
  tt    = aux;
#else
  std::swap(t, tt.t);
#endif
}



template <typename T, typename P>
inline void
SmartPointer<T, P>::swap(T *&tt)
{
  if (pointed_to_object_is_alive && t != nullptr)
    t->unsubscribe(pointed_to_object_is_alive, id);

  std::swap(t, tt);

  if (t != nullptr)
    t->subscribe(pointed_to_object_is_alive, id);
}



template <typename T, typename P>
inline std::size_t
SmartPointer<T, P>::memory_consumption() const
{
  return sizeof(SmartPointer<T, P>);
}



// The following function is not strictly necessary but is an optimization
// for places where you call swap(p1,p2) with SmartPointer objects p1, p2.
// Unfortunately, MS Visual Studio (at least up to the 2013 edition) trips
// over it when calling std::swap(v1,v2) where v1,v2 are std::vectors of
// SmartPointer objects: it can't determine whether it should call std::swap
// or ::swap on the individual elements (see bug #184 on our Google Code
// site. Consequently, just take this function out of the competition for this
// compiler.
#ifndef _MSC_VER

template <typename T, typename P, class Q>
inline void
swap(SmartPointer<T, P> &t1, SmartPointer<T, Q> &t2)
{
  t1.swap(t2);
}
#endif


template <typename T, typename P>
inline void
swap(SmartPointer<T, P> &t1, T *&t2)
{
  t1.swap(t2);
}



template <typename T, typename P>
inline void
swap(T *&t1, SmartPointer<T, P> &t2)
{
  t2.swap(t1);
}

DEAL_II_NAMESPACE_CLOSE

#endif