AllocationTestUtilities.hpp

Go to the documentation of this file.

 
//                Copyright Oliver J. Rosten 2020.                //
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0. //
//    (See accompanying file LICENSE.md or copy at                //
//          https://www.gnu.org/licenses/gpl-3.0.en.html)         //
 
#pragma once
 
#include "sequoia/Core/Meta/TypeTraits.hpp"
 
namespace sequoia::testing
{
  template<class T, bool PropagateCopy=true, bool PropagateMove=true, bool PropagateSwap=false>
  class shared_counting_allocator
  {
  public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using propagate_on_container_copy_assignment = std::bool_constant<PropagateCopy>;
    using propagate_on_container_move_assignment = std::bool_constant<PropagateMove>;
    using propagate_on_container_swap            = std::bool_constant<PropagateSwap>;
    using is_always_equal = std::false_type;
 
    // TO DO: Remove when libc++ is updated
    template< class U > struct rebind
    {
      using other = shared_counting_allocator<U, PropagateCopy, PropagateMove, PropagateSwap>;
    };
 
    shared_counting_allocator()
      : m_pAllocs{std::make_shared<int>()}, m_pDeallocs{std::make_shared<int>()}
    {}
 
    shared_counting_allocator(const shared_counting_allocator&) = default;
 
    shared_counting_allocator& operator=(const shared_counting_allocator&) = default;
 
    [[nodiscard]] T* allocate(std::size_t n)
    {
      const auto ptr{static_cast<T*>(::operator new(n * sizeof(T)))};
 
      if(n) ++(*m_pAllocs);
 
      return ptr;
    }
 
    void deallocate(T* p, std::size_t n)
    {
      ::operator delete(p);
      if(n) ++(*m_pDeallocs);
    }
 
    [[nodiscard]]
    int allocs() const noexcept { return *m_pAllocs; }
 
    [[nodiscard]]
    int deallocs() const noexcept { return *m_pDeallocs; }
 
    [[nodiscard]]
    friend bool operator==(const shared_counting_allocator&, const shared_counting_allocator&) noexcept = default;
  private:
    std::shared_ptr<int> m_pAllocs{}, m_pDeallocs{};
 
#ifdef _MSC_VER
#if _ITERATOR_DEBUG_LEVEL != 0
 
    // The MSVC implementation for std::vector's destructor has an interesting structure
    // for debug builds. The following ensures successful compilation.
 
    template<class, bool, bool, bool>
    friend class shared_counting_allocator;
 
    shared_counting_allocator(std::shared_ptr<int> pAllocs, std::shared_ptr<int> pDeallocs)
      : m_pAllocs{ std::move(pAllocs) }
      , m_pDeallocs{ std::move(pDeallocs) }
    {}
 
  public:
    template<class U>
    explicit operator shared_counting_allocator<U, PropagateCopy, PropagateMove, PropagateSwap>() const
    {
        return {m_pAllocs, m_pDeallocs};
    }
#endif
#endif
  };
 
  template<class T>
  struct type_demangler;
 
  template<class T, bool PropagateCopy, bool PropagateMove, bool PropagateSwap>
  struct type_demangler<shared_counting_allocator<T, PropagateCopy, PropagateMove, PropagateSwap>>
  {
    [[nodiscard]]
    static std::string make()
    {
      auto info{std::string{"shared_counting_allocator<\n\t\t"}.append(demangle<T>()).append(",\n")};
 
      auto toString{[](bool b){ return b ? "true" : "false";}};
 
      info.append("\t\tPropagate on copy assignment = ").append(toString(PropagateCopy)).append(",\n");
      info.append("\t\tPropagate on move assignment = ").append(toString(PropagateMove)).append(",\n");
      info.append("\t\tPropagate on swap = ").append(toString(PropagateSwap)).append("\n >");
 
      return info;
    }
  };
}