debug.h

Go to the documentation of this file.

#pragma once
 
#include "../utility/assert.h"
#include "../utility/empty_base.h"
#include "../utility/meta.h"
#include "../utility/source_location.h"
#include "debug_fwd.h"
#include "type_allocator.h"
 
#include <cstring>
#include <memory>
#include <ostream>
#include <type_traits>
 
namespace ktl
{
    template<typename Alloc, typename Container>
    class debug
    {
    private:
        static_assert(detail::has_no_value_type_v<Alloc>, "Building on top of typed allocators is not allowed. Use allocators without a type");
 
    public:
        typedef typename detail::get_size_type_t<Alloc> size_type;
 
    public:
        explicit debug(Container& container)
            noexcept(std::is_nothrow_default_constructible_v<Alloc>) :
            m_Container(container),
            m_Alloc() {}
 
        template<typename... Args,
            typename = std::enable_if_t<
            std::is_constructible_v<Alloc, Args...>>>
        explicit debug(Container& container, Args&&... args)
            noexcept(std::is_nothrow_constructible_v<Alloc, Args...>) :
            m_Container(container),
            m_Alloc(std::forward<Args>(args)...) {}
 
        debug(const debug&) = default;
 
        debug(debug&&) = default;
 
        debug& operator=(const debug&) = default;
 
        debug& operator=(debug&&) = default;
 
        bool operator==(const debug& rhs) const
            noexcept(detail::has_nothrow_equal_v<Alloc>)
        {
            return m_Alloc == rhs.m_Alloc;
        }
 
        bool operator!=(const debug& rhs) const
            noexcept(detail::has_nothrow_not_equal_v<Alloc>)
        {
            return m_Alloc != rhs.m_Alloc;
        }
 
#pragma region Allocation
        void* allocate(size_type n, const source_location& source = KTL_SOURCE())
            noexcept(detail::has_nothrow_allocate_v<Alloc>)
        {
#ifdef KTL_SOURCE_LOCATION
            m_Container.push_back({ source.file_name(), source.line(), n });
#endif
 
            return detail::allocate(m_Alloc, n, source);
        }
 
        void deallocate(void* p, size_type n)
            noexcept(detail::has_nothrow_deallocate_v<Alloc>)
        {
            m_Alloc.deallocate(p, n);
        }
#pragma endregion
 
#pragma region Construction
        template<typename T, typename... Args>
        typename std::enable_if<detail::has_construct_v<Alloc, T*, Args...>, void>::type
        construct(T* p, Args&&... args)
            noexcept(detail::has_nothrow_construct_v<Alloc, T*, Args...>)
        {
            m_Alloc.construct(p, std::forward<Args>(args)...);
        }
 
        template<typename T>
        typename std::enable_if<detail::has_destroy_v<Alloc, T*>, void>::type
        destroy(T* p)
            noexcept(detail::has_nothrow_destroy_v<Alloc, T*>)
        {
            m_Alloc.destroy(p);
        }
#pragma endregion
 
#pragma region Utility
        template<typename A = Alloc>
        typename std::enable_if<detail::has_max_size_v<A>, size_type>::type
        max_size() const
            noexcept(detail::has_nothrow_max_size_v<A>)
        {
            return m_Alloc.max_size();
        }
 
        template<typename A = Alloc>
        typename std::enable_if<detail::has_owns_v<A>, bool>::type
        owns(void* p) const
            noexcept(detail::has_nothrow_owns_v<A>)
        {
            return m_Alloc.owns(p);
        }
#pragma endregion
 
        Alloc& get_allocator() noexcept
        {
            return m_Alloc;
        }
 
        const Alloc& get_allocator() const noexcept
        {
            return m_Alloc;
        }
 
        Container& get_container() noexcept
        {
            return m_Container;
        }
 
        const Container& get_container() const noexcept
        {
            return m_Container;
        }
 
    private:
        Container& m_Container;
        KTL_EMPTY_BASE Alloc m_Alloc;
    };
}