smartpointer.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2017 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/subscriptor.h>

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 char *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 char *const id;
};


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


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



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



template <typename T, typename P>
inline SmartPointer<T, P>::SmartPointer(T *t, const char *id)
  : t(t)
  , id(id)
{
  if (t != nullptr)
    t->subscribe(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)
{
  if (t != nullptr)
    t->subscribe(id);
}



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



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



template <typename T, typename P>
inline void
SmartPointer<T, P>::clear()
{
  if (t != nullptr)
    {
      t->unsubscribe(id);
      delete t;
      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 (t != nullptr)
    t->unsubscribe(id);
  t = tt;
  if (tt != nullptr)
    tt->subscribe(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 (t != nullptr)
    t->unsubscribe(id);
  t = static_cast<T *>(tt);
  if (tt != nullptr)
    tt->subscribe(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 (t != nullptr)
    t->unsubscribe(id);
  t = static_cast<T *>(tt);
  if (tt != nullptr)
    tt->subscribe(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());
  return *t;
}



template <typename T, typename P>
inline T *SmartPointer<T, P>::operator->() const
{
  Assert(t != nullptr, ExcNotInitialized());
  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 (t != nullptr)
    t->unsubscribe(id);

  std::swap(t, tt);

  if (t != nullptr)
    t->subscribe(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