SPAR/AIModule/Utils/ReferenceCounted.h

Go to the documentation of this file.

#pragma once

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
  #include <map>
#else
  #include <string>
#endif

#include "Utils.h"
#include <iostream>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits.hpp>

template <class ReferenceCounted>
class AutoPtr;

class ReferenceCounted
{
public:
  ReferenceCounted()
    : m_nbRef(0)
  {
#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    this->m_previous = s_head;
    this->m_next = NULL;
    if (s_head != NULL)
      s_head->m_next = this;
    s_head = this;
#endif
  }

  ReferenceCounted(const ReferenceCounted&)
    : m_nbRef(0)
  {
#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    this->m_previous = s_head;
    this->m_next = NULL;
    if (s_head != NULL)
      s_head->m_next = this;
    s_head = this;
#endif
  }

  virtual ~ReferenceCounted()
  {
#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    removeFromList();
#endif
  }

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
  void removeFromList()
  {
    if (this->m_previous != NULL)
      this->m_previous->m_next = this->m_next;
    if (this->m_next != NULL)
      this->m_next->m_previous = this->m_previous;
    if (s_head == this)
      s_head = this->m_previous;
  }
#endif

  void markAsStatic()
  {
    // This reference is never going to be released as to not accidentally delete a static object
    ++m_nbRef;

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    removeFromList();
#endif
  }

  template <class Acquirer>
  void acquire(const Acquirer *acquirer) const
  {
    ++m_nbRef;

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    std::pair<std::map<const void*, boost::tuple<const type_info*, size_t, bool>>::iterator, bool> result = 
      m_acquirers.insert(std::make_pair(convertToVoidPtr(acquirer), 
                                        boost::make_tuple(&typeid(acquirer), 0, isReferenceCounted(acquirer))));

    ++(result.first->second.get<1>());
#else
    unused(acquirer);
#endif
  }

  template <class Acquirer>
  void release(const Acquirer *acquirer) const
  {
#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
    std::map<const void*, boost::tuple<const type_info*, size_t, bool>>::iterator it = m_acquirers.find(convertToVoidPtr(acquirer));
    if (it == m_acquirers.end()) {
      const char* typeName = typeid(acquirer).name();
      std::cout << "Error: '" << typeName
                << " " << std::hex << convertToVoidPtr(acquirer) << "' attempted to release '"
                << this->toString() << "' without acquiring it first" << std::endl;
    }
    else
    {
      if (--(it->second.get<1>()) == 0)
        m_acquirers.erase(it);
    }
#else
    unused(acquirer);
#endif
    if (--m_nbRef == 0)
      delete this;
  }

  void considerDeletion() const
  {
    if (m_nbRef == 0)
    {
      delete this;
    }
  }

  virtual std::string toString() const = 0;

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
  static size_t signalMemoryLeaks();
#endif

private:
  template <class ReferenceCounted>
  friend class AutoPtr;

  struct ReferenceCountedType
  {
    template <class T>
    static const void* convertToVoidPtr(const T* t)
    {
      const ReferenceCounted* r = dynamic_cast<const ReferenceCounted*>(t);
      assert(r != NULL);
      return r;
    }
    static void considerDeletion(const ReferenceCounted& referenceCounted)
    {
      referenceCounted.considerDeletion();
    }
  };

  struct NotReferenceCountedType
  {
    template <class T>
    static const void* convertToVoidPtr(const T* t)
    {
      return static_cast<const void*>(t);
    }
    template <class T>
    static void considerDeletion(const T& t)
    {
      delete &t;
    }
  };

  template <class Acquirer>
  static const void* convertToVoidPtr(const Acquirer* acquirer)
  {
    return static_if_else<boost::is_convertible<Acquirer*, ReferenceCounted*>::value, 
                          ReferenceCountedType, 
                          NotReferenceCountedType>::type::convertToVoidPtr(acquirer);
  }

  template <class Acquirer>
  static bool isReferenceCounted(const Acquirer* acquirer)
  {
    return boost::is_convertible<Acquirer*, ReferenceCounted*>::value;
  }

  mutable size_t m_nbRef;

#if defined(_DEBUG) && defined(_DEBUG_REFERENCE_COUNTED)
  static const ReferenceCounted *s_head;

  mutable const ReferenceCounted* m_previous;

  mutable const ReferenceCounted* m_next;

  mutable std::map<const void*, boost::tuple<const type_info*, size_t, bool>> m_acquirers;
#endif

};

template <class ReferenceCounted>
class AutoPtr
{
public:
  template <class Acquirer>
  AutoPtr(ReferenceCounted* ref, const Acquirer& acquirer)
    : m_ref(ref)
    , m_acquirer(ReferenceCounted::convertToVoidPtr(&acquirer))
  {
    if (m_ref != NULL)
      m_ref->acquire(&acquirer);
  }
  AutoPtr(const AutoPtr& other)
    : m_ref(other.m_ref)
    , m_acquirer(other.m_acquirer)
  {
    if (m_ref != NULL)
      m_ref->acquire(m_acquirer);
  }
  ~AutoPtr()
  {
    if (m_ref != NULL)
      m_ref->release(m_acquirer);
  }
  const ReferenceCounted* operator->() const
  {
    return m_ref;
  }
  ReferenceCounted* operator->()
  {
    return m_ref;
  }
  const ReferenceCounted& operator*() const
  {
    return *m_ref;
  }
  ReferenceCounted& operator*()
  {
    return *m_ref;
  }
  operator const ReferenceCounted* () const
  {
    return m_ref;
  }
  operator ReferenceCounted* ()
  {
    return m_ref;
  }
  AutoPtr& operator=(const ReferenceCounted* ref)
  {
    if (ref != NULL)
      ref->acquire(m_acquirer):
    if (m_ref != NULL)
      ref->release(m_acquirer);
    m_ref = ref;
    return *this;
  }

protected:
  const void* const m_acquirer;
  ReferenceCounted* const m_ref;

private:
  AutoPtr& operator=(const AutoPtr& other);
};

namespace memory
{
  // These methods are wrapped in 'memory' to avoid name clashes with ReferenceCounted methods (like acquire())

  template <class Acquirer>
  void acquire(const Acquirer* acquirer, const ReferenceCounted& referenceCounted)
  {
    referenceCounted.acquire(acquirer);
  }

  template <class Acquirer, class T>
  void acquire(const Acquirer* acquirer, const T* const t)
  {
    acquire(acquirer, *t);
  }

  template <class Acquirer, class T>
  void acquire(const Acquirer* acquirer, T* const t)
  {
    acquire(acquirer, *t);
  }

  template <class Acquirer, class Iterator>
  void acquire(const Acquirer* acquirer, Iterator begin, Iterator end)
  {
    for (; begin != end; ++begin)
    {
      acquire(acquirer, *begin);
    }
  }

  template <class Acquirer>
  void release(const Acquirer* acquirer, const ReferenceCounted& referenceCounted)
  {
    referenceCounted.release(acquirer);
  }

  template <class Acquirer, class T>
  void release(const Acquirer* acquirer, const T* const t)
  {
    release(acquirer, *t);
  }

  template <class Acquirer, class T>
  void release(const Acquirer* acquirer, T* const t)
  {
    release(acquirer, *t);
  }

  template <class Acquirer, class Iterator>
  void release(const Acquirer* acquirer, Iterator begin, Iterator end)
  {
    for (; begin != end; ++begin)
    {
      release(acquirer, *begin);
    }
  }

  inline void considerDeletion(const ReferenceCounted& referenceCounted)
  {
    referenceCounted.considerDeletion();
  }

  template <class T>
  void considerDeletion(const T* const t)
  {
    considerDeletion(*t);
  }

  template <class T>
  void considerDeletion(T* const t)
  {
    considerDeletion(*t);
  }

  template <class Iterator>
  void considerDeletion(Iterator begin, Iterator end)
  {
    for (; begin != end; ++begin)
    {
      considerDeletion(*begin);
    }
  }
};