smart_pointer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __SMART_POINTER__
#define __SMART_POINTER__
 
#include <functional>
#include <cstring>
#include <boost/pointee.hpp>
 
 
//  Policies
 
//  FreeDelete
template <typename T>
class FreeDelete
{
  public:
    static void free(const T* data) {if(data) delete data;}
};
class FreeDelete {…};
 
//  FreeDelete
template <typename T>
class FreeArrayDelete
{
  public:
    static void free(const T* data) {if(data) delete[] data;}
};
class FreeArrayDelete {…};
 
//  FreeRelease
template <typename T>
class FreeRelease
{
  public:
    static void free(const T* data) {data->Release;}
};
class FreeRelease {…};
 
 
//  PREDECLARATIONS
template <class T, template <class TT> class FreePolicy = FreeDelete> class SmartPtr;
template <class T, template <class TT> class FreePolicy = FreeDelete> class ConstSmartPtr;
 
 
 
class NullSmartPtr{
  public:
    NullSmartPtr()  {}
};
class NullSmartPtr {…};
 
const NullSmartPtr  SPNULL;
 
 
//  SmartPtr
template <typename T, template <class TT> class FreePolicy>
class SmartPtr
{
  friend class ConstSmartPtr<T, FreePolicy>;
  friend class SmartPtr<void>;
  friend class ConstSmartPtr<void>;
 
  public:
    explicit SmartPtr() : m_ptr(0), m_refCount(0) {}
    explicit SmartPtr(T* ptr) : m_ptr(ptr), m_refCount(0) {if(ptr) m_refCount = new int(1);}
    SmartPtr(NullSmartPtr) : m_ptr(0), m_refCount(0)  {}
    SmartPtr(const SmartPtr& sp) : m_ptr(sp.m_ptr), m_refCount(sp.m_refCount)
    {
      if(m_refCount) (*m_refCount)++;
    }
    SmartPtr(const SmartPtr& sp) : m_ptr(sp.m_ptr), m_refCount(sp.m_refCount) {…}
 
    template <class TPtr>
    SmartPtr(const SmartPtr<TPtr, FreePolicy>& sp) :
      m_ptr(sp.get_nonconst()),
      m_refCount(sp.refcount_ptr())
    {
      if(m_refCount) (*m_refCount)++;
    }
    SmartPtr(const SmartPtr<TPtr, FreePolicy>& sp) : {…}
 
    ~SmartPtr() {release();}
 
    T* operator->()       {return m_ptr;}
    const T* operator->() const {return m_ptr;}
 
    T& operator*()        {return *m_ptr;}
    const T& operator*() const  {return *m_ptr;}
 
    SmartPtr& operator=(NullSmartPtr) {
      if(m_ptr)
        release();
      m_ptr = 0;
      m_refCount = 0;
      return *this;
    }
    SmartPtr& operator=(NullSmartPtr) {…}
 
    SmartPtr& operator=(const SmartPtr& sp) {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCount = sp.m_refCount;
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    SmartPtr& operator=(const SmartPtr& sp) {…}
 
    template <class TIn>
    SmartPtr<T, FreePolicy>& operator=(const SmartPtr<TIn, FreePolicy>& sp) {
      if(m_ptr)
        release();
      m_ptr = sp.get_nonconst();
      m_refCount = sp.refcount_ptr();
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    SmartPtr<T, FreePolicy>& operator=(const SmartPtr<TIn, FreePolicy>& sp) {…}
 
    bool operator==(const SmartPtr& sp) const {
      return (this->get() == sp.get());
    }
    bool operator==(const SmartPtr& sp) const  {…}
 
    bool operator!=(const SmartPtr& sp) const {
      return !(this->operator==(sp));
    }
    bool operator!=(const SmartPtr& sp) const  {…}
 
    bool operator==(NullSmartPtr) const {
      return m_ptr == 0;
    }
    bool operator==(NullSmartPtr) const  {…}
 
    bool operator!=(NullSmartPtr) const {
      return m_ptr != 0;
    }
    bool operator!=(NullSmartPtr) const  {…}
 
    template <class TPtr>
    bool operator==(const ConstSmartPtr<TPtr, FreePolicy>& sp) const {
      return (this->get() == sp.get());
    }
    bool operator==(const ConstSmartPtr<TPtr, FreePolicy>& sp) const  {…}
 
    template <class TPtr>
    bool operator!=(const ConstSmartPtr<TPtr, FreePolicy>& sp) const {
      return !(this->operator==(sp));
    }
    bool operator!=(const ConstSmartPtr<TPtr, FreePolicy>& sp) const  {…}
 
    T* get()        {return m_ptr;}
 
    const T* get() const  {return m_ptr;}
 
    int refcount() const {if(m_refCount) return *m_refCount; return 0;}
 
    inline bool valid() const {return m_ptr != NULL;}
 
    // pointer compat -- behave like std::shared_ptr<T>
    explicit operator bool() const noexcept { return m_ptr != NULL; }
 
    inline bool invalid() const {return m_ptr == NULL;}
 
    template <class TDest>
    SmartPtr<TDest, FreePolicy> cast_dynamic() const{
      TDest* p = dynamic_cast<TDest*>(m_ptr);
      if(p) return SmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return SmartPtr<TDest, FreePolicy>(NULL);
    }
    SmartPtr<TDest, FreePolicy> cast_dynamic() const {…}
 
    template <class TDest>
    SmartPtr<TDest, FreePolicy> cast_static() const{
      TDest* p = static_cast<TDest*>(m_ptr);
      if(p) return SmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return SmartPtr<TDest, FreePolicy>(NULL);
    }
    SmartPtr<TDest, FreePolicy> cast_static() const {…}
 
    template <class TDest>
    SmartPtr<TDest, FreePolicy> cast_reinterpret() const{
      TDest* p = reinterpret_cast<TDest*>(m_ptr);
      if(p) return SmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return SmartPtr<TDest, FreePolicy>(NULL);
    }
    SmartPtr<TDest, FreePolicy> cast_reinterpret() const {…}
 
    template <class TDest>
    bool is_of_type() const
    {
      return dynamic_cast<TDest*>(m_ptr) != NULL;
    }
    bool is_of_type() const {…}
 
    ConstSmartPtr<T, FreePolicy> cast_const() const;
 
 
    explicit SmartPtr(T* ptr, int* refCount) : m_ptr(ptr), m_refCount(refCount)
    {
      if(m_refCount)
        (*m_refCount)++;
    }
    explicit SmartPtr(T* ptr, int* refCount) : m_ptr(ptr), m_refCount(refCount) {…}
 
 
    int* refcount_ptr() const   {return m_refCount;}
 
    T* get_nonconst() const {return m_ptr;}
  private:
    void release() {
      if(m_refCount)
      {
        (*m_refCount)--;
        if((*m_refCount) < 1)
        {
          delete m_refCount;
          //delete m_ptr;
          FreePolicy<T>::free(m_ptr);
        }
      }
    }
    void release() {…}
 
 
    static void free_void_ptr(const void* ptr){
      FreePolicy<T>::free(reinterpret_cast<const T*>(ptr));
    }
    static void free_void_ptr(const void* ptr) {…}
 
  private:
    T*    m_ptr;
    int*  m_refCount;
};
 
template <typename T, template <class TT> class FreePolicy>
class ConstSmartPtr
{
  friend class ConstSmartPtr<void>;
 
  public:
    explicit ConstSmartPtr() : m_ptr(0), m_refCount(0)  {}
    explicit ConstSmartPtr(const T* ptr) : m_ptr(ptr), m_refCount(0)  {if(ptr) m_refCount = new int(1);}
    ConstSmartPtr(NullSmartPtr) : m_ptr(0), m_refCount(0) {}
    ConstSmartPtr(const ConstSmartPtr& sp) : m_ptr(sp.m_ptr), m_refCount(sp.m_refCount)
    {
      if(m_refCount) (*m_refCount)++;
    }
    ConstSmartPtr(const ConstSmartPtr& sp) : m_ptr(sp.m_ptr), m_refCount(sp.m_refCount) {…}
 
    template <class TPtr>
    ConstSmartPtr(const SmartPtr<TPtr, FreePolicy>& sp) :
      m_ptr(sp.get()),
      m_refCount(sp.refcount_ptr())
    {
      if(m_refCount) (*m_refCount)++;
    }
    ConstSmartPtr(const SmartPtr<TPtr, FreePolicy>& sp) : {…}
 
    template <class TPtr>
    ConstSmartPtr(const ConstSmartPtr<TPtr, FreePolicy>& sp) :
      m_ptr(sp.get()),
      m_refCount(sp.refcount_ptr())
    {
      if(m_refCount) (*m_refCount)++;
    }
    ConstSmartPtr(const ConstSmartPtr<TPtr, FreePolicy>& sp) : {…}
 
    ~ConstSmartPtr() {release();}
 
    const T* operator->() const {return m_ptr;}
 
    const T& operator*() const  {return *m_ptr;}
 
    ConstSmartPtr& operator=(const SmartPtr<T, FreePolicy>& sp){
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCount = sp.m_refCount;
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    ConstSmartPtr& operator=(const SmartPtr<T, FreePolicy>& sp) {…}
 
    template <class TIn>
    ConstSmartPtr<T, FreePolicy>& operator=(const SmartPtr<TIn, FreePolicy>& sp){
      if(m_ptr)
        release();
      m_ptr = sp.get();
      m_refCount = sp.refcount_ptr();
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    ConstSmartPtr<T, FreePolicy>& operator=(const SmartPtr<TIn, FreePolicy>& sp) {…}
 
    ConstSmartPtr& operator=(const ConstSmartPtr& sp){
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCount = sp.m_refCount;
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    ConstSmartPtr& operator=(const ConstSmartPtr& sp) {…}
 
    template <class TIn>
    ConstSmartPtr<T, FreePolicy>& operator=(const ConstSmartPtr<TIn, FreePolicy>& sp){
      if(m_ptr)
        release();
      m_ptr = sp.get();
      m_refCount = sp.refcount_ptr();
      if(m_refCount)
        (*m_refCount)++;
      return *this;
    }
    ConstSmartPtr<T, FreePolicy>& operator=(const ConstSmartPtr<TIn, FreePolicy>& sp) {…}
 
    ConstSmartPtr& operator=(NullSmartPtr){
      if(m_ptr)
        release();
      m_ptr = 0;
      m_refCount = 0;
      return *this;
    }
    ConstSmartPtr& operator=(NullSmartPtr) {…}
 
    bool operator==(const ConstSmartPtr& sp) const{
      return (this->get() == sp.get());
    }
    bool operator==(const ConstSmartPtr& sp) const {…}
 
    template <class TPtr>
    bool operator==(const SmartPtr<TPtr, FreePolicy>& sp) const{
      return (this->get() == sp.get());
    }
    bool operator==(const SmartPtr<TPtr, FreePolicy>& sp) const {…}
 
    bool operator==(NullSmartPtr) const{
      return m_ptr == 0;
    }
    bool operator==(NullSmartPtr) const {…}
 
    bool operator!=(const ConstSmartPtr& sp) const{
      return !(this->operator==(sp));
    }
    bool operator!=(const ConstSmartPtr& sp) const {…}
 
    template <class TPtr>
    bool operator!=(const SmartPtr<TPtr, FreePolicy>& sp) const{
      return !(this->operator==(sp));
    }
    bool operator!=(const SmartPtr<TPtr, FreePolicy>& sp) const {…}
 
    bool operator!=(NullSmartPtr) const{
      return m_ptr != NULL;
    }
    bool operator!=(NullSmartPtr) const {…}
 
    const T* get() const  {return m_ptr;}
 
    int refcount() const {if(m_refCount) return *m_refCount; return 0;}
 
    inline bool valid() const {return m_ptr != NULL;}
 
    // pointer compat -- behave like std::shared_ptr<T>
    explicit operator bool() const noexcept { return m_ptr != NULL; }
 
    inline bool invalid() const {return m_ptr == NULL;}
 
    template <class TDest>
    ConstSmartPtr<TDest, FreePolicy> cast_dynamic() const{
      const TDest* p = dynamic_cast<const TDest*>(m_ptr);
      if(p) return ConstSmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return ConstSmartPtr<TDest, FreePolicy>(NULL);
    }
    ConstSmartPtr<TDest, FreePolicy> cast_dynamic() const {…}
 
    template <class TDest>
    ConstSmartPtr<TDest, FreePolicy> cast_static() const{
      const TDest* p = static_cast<const TDest*>(m_ptr);
      if(p) return ConstSmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return ConstSmartPtr<TDest, FreePolicy>(NULL);
    }
    ConstSmartPtr<TDest, FreePolicy> cast_static() const {…}
 
    template <class TDest>
    ConstSmartPtr<TDest, FreePolicy> cast_reinterpret() const{
      const TDest* p = reinterpret_cast<const TDest*>(m_ptr);
      if(p) return ConstSmartPtr<TDest, FreePolicy>(p, m_refCount);
      else return ConstSmartPtr<TDest, FreePolicy>(NULL);
    }
    ConstSmartPtr<TDest, FreePolicy> cast_reinterpret() const {…}
 
    SmartPtr<T, FreePolicy> cast_const() const{
      return SmartPtr<T, FreePolicy>(const_cast<T*>(m_ptr), m_refCount);
    }
    SmartPtr<T, FreePolicy> cast_const() const {…}
 
    template <class TDest>
    bool is_of_type() const
    {
      return dynamic_cast<TDest*>(m_ptr) != NULL;
    }
    bool is_of_type() const {…}
 
 
    explicit ConstSmartPtr(const T* ptr, int* refCount) : m_ptr(ptr), m_refCount(refCount)
    {
      if(m_refCount)
        (*m_refCount)++;
    }
    explicit ConstSmartPtr(const T* ptr, int* refCount) : m_ptr(ptr), m_refCount(refCount) {…}
 
 
    int* refcount_ptr() const {return m_refCount;}
 
  private:
    void release() {
      if(m_refCount)
      {
        (*m_refCount)--;
        if((*m_refCount) < 1)
        {
          delete m_refCount;
          //delete m_ptr;
          FreePolicy<T>::free(m_ptr);
        }
      }
    }
    void release() {…}
 
  //  this release method is required by SmartPtr<void>
    static void free_void_ptr(void* ptr){
      FreePolicy<T>::free(reinterpret_cast<T*>(ptr));
    }
    static void free_void_ptr(void* ptr) {…}
 
  private:
    const T*  m_ptr;
    int*    m_refCount;
};
class ConstSmartPtr {…};
 
template <typename T, template <class TT> class FreePolicy>
inline ConstSmartPtr<T, FreePolicy> SmartPtr<T, FreePolicy>::cast_const() const{
  return ConstSmartPtr<T, FreePolicy>(*this);
}
inline ConstSmartPtr<T, FreePolicy> SmartPtr<T, FreePolicy>::cast_const() const {…}
    ConstSmartPtr<T, FreePolicy> cast_const() const; {…}
 
 
template <>
class SmartPtr<void>
{
  friend class ConstSmartPtr<void>;
 
  public:
    explicit SmartPtr() : m_ptr(0), m_refCountPtr(0), m_freeFunc(0) {}
 
    SmartPtr(NullSmartPtr) : m_ptr(0), m_refCountPtr(0), m_freeFunc(0)  {}
 
    SmartPtr(const SmartPtr<void>& sp) :
      m_ptr(sp.m_ptr),
      m_refCountPtr(sp.m_refCountPtr),
      m_freeFunc(sp.m_freeFunc)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    SmartPtr(const SmartPtr<void>& sp) : {…}
 
    explicit SmartPtr(void* ptr, void (*freeFunc)(const void*)) :
      m_ptr(ptr),
      m_refCountPtr(0),
      m_freeFunc(freeFunc)
    {
      if(ptr) m_refCountPtr = new int(1);
    }
    explicit SmartPtr(void* ptr, void (*freeFunc)(const void*)) : {…}
 
    template <class T>
    SmartPtr(const SmartPtr<T>& sp) :
      m_ptr((void*)sp.m_ptr),
      m_refCountPtr(sp.m_refCount),
      m_freeFunc(&SmartPtr<T>::free_void_ptr)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    SmartPtr(const SmartPtr<T>& sp) : {…}
 
    ~SmartPtr() {release();}
 
    SmartPtr<void>& operator=(const SmartPtr<void>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCountPtr;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = sp.m_freeFunc;
      return *this;
    }
    SmartPtr<void>& operator=(const SmartPtr<void>& sp) {…}
 
    template <class T>
    SmartPtr<void>& operator=(const SmartPtr<T>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCount;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = &SmartPtr<T>::free_void_ptr;
      return *this;
    }
    SmartPtr<void>& operator=(const SmartPtr<T>& sp) {…}
 
    template <class T>
    SmartPtr<void>& operator=(NullSmartPtr)
    {
      if(m_ptr)
        release();
      m_ptr = 0;
      m_refCountPtr = 0;
      m_freeFunc = 0;
      return *this;
    }
    SmartPtr<void>& operator=(NullSmartPtr) {…}
 
 
    template <class T,  template <class TPtr> class TFreePolicy>
    SmartPtr<T, TFreePolicy> cast_reinterpret() const {
      return SmartPtr<T, TFreePolicy>(reinterpret_cast<T*>(m_ptr), m_refCountPtr);
    }
    SmartPtr<T, TFreePolicy> cast_reinterpret() const  {…}
 
 
    template <class T, template <class TPtr> class TFreePolicy>
    void set_impl(void* ptr)
    {
      m_ptr = ptr;
      m_freeFunc = &SmartPtr<T, TFreePolicy>::free_void_ptr;
    }
    void set_impl(void* ptr) {…}
 
    inline bool valid() const {return m_ptr != NULL;}
 
    // pointer compat -- behave like std::shared_ptr<T>
    explicit operator bool() const noexcept { return m_ptr != NULL; }
 
    inline bool invalid() const {return m_ptr == NULL;}
 
    void invalidate()       {if(valid())  release(); m_ptr = NULL;}
 
    void* get()       {return m_ptr;}
    const void* get() const {return m_ptr;}
 
    int refcount() const {if(m_refCountPtr) return *m_refCountPtr; return 0;}
 
  private:
    void release() {
      if(m_refCountPtr)
      {
        (*m_refCountPtr)--;
        if((*m_refCountPtr) < 1)
        {
          delete m_refCountPtr;
          m_freeFunc(m_ptr);
        }
      }
    }
    void release() {…}
 
    void* m_ptr;
    int* m_refCountPtr;
    void (*m_freeFunc)(const void*);
};
class SmartPtr<void> {…};
 
template <>
class ConstSmartPtr<void>
{
  public:
    explicit ConstSmartPtr() : m_ptr(0), m_refCountPtr(0), m_freeFunc(0) {}
 
    explicit ConstSmartPtr(void* ptr, void (*freeFunc)(const void*)) :
      m_ptr(ptr),
      m_refCountPtr(0),
      m_freeFunc(freeFunc)
    {
      if(ptr) m_refCountPtr = new int(1);
    }
    explicit ConstSmartPtr(void* ptr, void (*freeFunc)(const void*)) : {…}
 
    ConstSmartPtr(NullSmartPtr) : m_ptr(0), m_refCountPtr(0), m_freeFunc(0) {}
 
    ConstSmartPtr(const SmartPtr<void>& sp) :
      m_ptr(sp.m_ptr),
      m_refCountPtr(sp.m_refCountPtr),
      m_freeFunc(sp.m_freeFunc)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    ConstSmartPtr(const SmartPtr<void>& sp) : {…}
 
    ConstSmartPtr(const ConstSmartPtr<void>& sp) :
      m_ptr(sp.m_ptr),
      m_refCountPtr(sp.m_refCountPtr),
      m_freeFunc(sp.m_freeFunc)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    ConstSmartPtr(const ConstSmartPtr<void>& sp) : {…}
 
    template <class T, template <class TPtr> class TFreePolicy>
    ConstSmartPtr(const SmartPtr<T, TFreePolicy>& sp) :
      m_ptr((void*)sp.m_ptr),
      m_refCountPtr(sp.m_refCount),
      m_freeFunc(&SmartPtr<T, TFreePolicy>::free_void_ptr)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    ConstSmartPtr(const SmartPtr<T, TFreePolicy>& sp) : {…}
 
    template <class T, template <class TPtr> class TFreePolicy>
    ConstSmartPtr(const ConstSmartPtr<T, TFreePolicy>& sp) :
      m_ptr((void*)sp.m_ptr),
      m_refCountPtr(sp.m_refCount),
      m_freeFunc(&SmartPtr<T, TFreePolicy>::free_void_ptr)
    {
      if(m_refCountPtr) (*m_refCountPtr)++;
    }
    ConstSmartPtr(const ConstSmartPtr<T, TFreePolicy>& sp) : {…}
 
    ~ConstSmartPtr() {release();}
 
    ConstSmartPtr<void>& operator=(const SmartPtr<void>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCountPtr;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = sp.m_freeFunc;
      return *this;
    }
    ConstSmartPtr<void>& operator=(const SmartPtr<void>& sp) {…}
 
    ConstSmartPtr<void>& operator=(const ConstSmartPtr<void>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCountPtr;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = sp.m_freeFunc;
      return *this;
    }
    ConstSmartPtr<void>& operator=(const ConstSmartPtr<void>& sp) {…}
 
    template <class T, template <class TPtr> class TFreePolicy>
    ConstSmartPtr<void>& operator=(const SmartPtr<T, TFreePolicy>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCount;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = &SmartPtr<T, TFreePolicy>::free_void_ptr;
      return *this;
    }
    ConstSmartPtr<void>& operator=(const SmartPtr<T, TFreePolicy>& sp) {…}
 
    template <class T, template <class TPtr> class TFreePolicy>
    ConstSmartPtr<void>& operator=(const ConstSmartPtr<T, TFreePolicy>& sp)
    {
      if(m_ptr)
        release();
      m_ptr = sp.m_ptr;
      m_refCountPtr = sp.m_refCount;
      if(m_refCountPtr)
        (*m_refCountPtr)++;
      m_freeFunc = &SmartPtr<T, TFreePolicy>::free_void_ptr;
      return *this;
    }
    ConstSmartPtr<void>& operator=(const ConstSmartPtr<T, TFreePolicy>& sp) {…}
 
    ConstSmartPtr<void>& operator=(NullSmartPtr)
    {
      if(m_ptr)
        release();
      m_ptr = 0;
      m_refCountPtr = 0;
      m_freeFunc = 0;
      return *this;
    }
    ConstSmartPtr<void>& operator=(NullSmartPtr) {…}
 
 
    template <class T, template <class TPtr> class TFreePolicy>
    ConstSmartPtr<T, TFreePolicy> cast_reinterpret() const{
      return ConstSmartPtr<T, TFreePolicy>(reinterpret_cast<const T*>(m_ptr), m_refCountPtr);
    }
    ConstSmartPtr<T, TFreePolicy> cast_reinterpret() const {…}
 
 
    template <class T, template <class TPtr> class TFreePolicy>
    void set_impl(const void* ptr)
    {
      m_ptr = ptr;
      m_freeFunc = &SmartPtr<T, TFreePolicy>::free_void_ptr;
    }
    void set_impl(const void* ptr) {…}
 
    inline bool valid() const {return m_ptr != NULL;}
 
    // pointer compat -- behave like std::shared_ptr<T>
    explicit operator bool() const noexcept { return m_ptr != NULL; }
 
    inline bool invalid() const {return m_ptr == NULL;}
 
    void invalidate()       {if(valid())  release(); m_ptr = NULL;}
 
    const void* get() const {return m_ptr;}
 
    int refcount() const {if(m_refCountPtr) return *m_refCountPtr; return 0;}
 
  private:
    void release() {
      if(m_refCountPtr)
      {
        (*m_refCountPtr)--;
        if((*m_refCountPtr) < 1)
        {
          delete m_refCountPtr;
          m_freeFunc(const_cast<void*>(m_ptr));
        }
      }
    }
    void release() {…}
 
    const void* m_ptr;
    int* m_refCountPtr;
    void (*m_freeFunc)(const void*);
};
class ConstSmartPtr<void> {…};
 
 
 
namespace std
{
  template <class T, template <class TPtr> class TFreePolicy>
  struct less<SmartPtr<T, TFreePolicy> >
#if (__cplusplus < 201103L)
  : public binary_function<SmartPtr<T, TFreePolicy>, SmartPtr<T, TFreePolicy>, bool>
#endif
  {
    bool operator()(const SmartPtr<T, TFreePolicy>& lhs,
            const SmartPtr<T, TFreePolicy>& rhs) const
    {
      return less<T*>()(lhs.get(), rhs.get());
    }
    bool operator()(const SmartPtr<T, TFreePolicy>& lhs, {…}
  };
  struct less<SmartPtr<T, TFreePolicy> > {…};
}
namespace std {…}
 
 
//  Creation helper for SmartPtr
 
template <typename T, template <class TT> class FreePolicy>
SmartPtr<T, FreePolicy> make_sp(T* inst)
{
  return SmartPtr<T, FreePolicy>(inst);
}
SmartPtr<T, FreePolicy> make_sp(T* inst) {…}
 
template <typename T>
SmartPtr<T> make_sp(T* inst)
{
  return SmartPtr<T>(inst);
}
SmartPtr<T> make_sp(T* inst) {…}
 
namespace boost
{
  template <class T>
  struct pointee<SmartPtr<T> >
  {
      typedef T type;
  };
  struct pointee<SmartPtr<T> > {…};
 
  template <class T>
  struct pointee<ConstSmartPtr<T> >
  {
      typedef T type;
  };
  struct pointee<ConstSmartPtr<T> > {…};
}
 
// end group ugbase_common_util
 
#endif
class SmartPtr {…};