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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#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