PolymorphicAllocator.h

Go to the documentation of this file.

#ifndef ZSERIO_PMR_POLYMORPHIC_ALLOCATOR_H_INC
#define ZSERIO_PMR_POLYMORPHIC_ALLOCATOR_H_INC
 
#include <limits>
#include <type_traits>
#include <utility>
 
#include "zserio/Types.h"
#include "zserio/pmr/MemoryResource.h"
 
namespace zserio
{
namespace pmr
{
namespace detail
{
 
template <class T = uint8_t>
class PolymorphicAllocatorBase
{
public:
    using value_type = T;
 
    // Following typedefs are only present for compatibility with older std. libraries, that does not fully
    // conform to C++11. [old-compiler-support]
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using reference = value_type&;
    using const_reference = const value_type&;
 
    PolymorphicAllocatorBase(MemoryResource* resource = getDefaultResource()) noexcept :
            m_resource(resource != nullptr ? resource : getDefaultResource()) // non-standard extension
    {}
 
    ~PolymorphicAllocatorBase() = default;
 
    PolymorphicAllocatorBase(const PolymorphicAllocatorBase& other) noexcept = default;
    PolymorphicAllocatorBase& operator=(const PolymorphicAllocatorBase& other) noexcept = default;
 
    PolymorphicAllocatorBase(PolymorphicAllocatorBase&& other) noexcept = default;
    PolymorphicAllocatorBase& operator=(PolymorphicAllocatorBase&& other) noexcept = default;
    template <class U>
    PolymorphicAllocatorBase(const PolymorphicAllocatorBase<U>& other) noexcept :
            m_resource(other.resource())
    {}
 
    template <class U>
    PolymorphicAllocatorBase& operator=(const PolymorphicAllocatorBase<U>& other) noexcept
    {
        m_resource = other.resource();
        return *this;
    }
 
    value_type* allocate(size_t size)
    {
        return static_cast<value_type*>(m_resource->allocate(size * sizeof(value_type), alignof(value_type)));
    }
 
    void deallocate(value_type* memory, size_t size) noexcept
    {
        m_resource->deallocate(memory, size * sizeof(value_type), alignof(value_type));
    }
 
    MemoryResource* resource() const noexcept
    {
        return m_resource;
    }
 
    template <typename U, typename... Args>
    void construct(U* ptr, Args&&... args) noexcept(
            noexcept(new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...)))
    {
        new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
    }
 
    template <typename U>
    void destroy(U* ptr) noexcept(noexcept(ptr->~U()))
    {
        ptr->~U();
    }
 
    size_type max_size() const noexcept
    {
        return std::numeric_limits<size_type>::max() / sizeof(value_type);
    }
 
private:
    MemoryResource* m_resource;
};
 
template <class T, class U>
bool operator==(const PolymorphicAllocatorBase<T>& lhs, const PolymorphicAllocatorBase<U>& rhs) noexcept
{
    return *lhs.resource() == *rhs.resource();
}
 
template <class T, class U>
bool operator!=(const PolymorphicAllocatorBase<T>& lhs, const PolymorphicAllocatorBase<U>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
} // namespace detail
 
template <class T = uint8_t>
class PolymorphicAllocator : public detail::PolymorphicAllocatorBase<T>
{
public:
    using detail::PolymorphicAllocatorBase<T>::PolymorphicAllocatorBase;
 
    using propagate_on_container_copy_assignment = std::false_type;
    using propagate_on_container_move_assignment = std::false_type;
    using propagate_on_container_swap = std::false_type;
 
    PolymorphicAllocator select_on_container_copy_construction() const
    {
        return PolymorphicAllocator();
    }
 
    template <typename U>
    struct rebind
    {
        using other = PolymorphicAllocator<U>;
    };
};
 
template <class T = uint8_t>
class PropagatingPolymorphicAllocator : public detail::PolymorphicAllocatorBase<T>
{
public:
    using detail::PolymorphicAllocatorBase<T>::PolymorphicAllocatorBase;
 
    using propagate_on_container_copy_assignment = std::true_type;
    using propagate_on_container_move_assignment = std::true_type;
    using propagate_on_container_swap = std::true_type;
 
    PropagatingPolymorphicAllocator select_on_container_copy_construction() const
    {
        return *this;
    }
 
    template <typename U>
    struct rebind
    {
        using other = PropagatingPolymorphicAllocator<U>;
    };
};
 
} // namespace pmr
} // namespace zserio
 
#endif // ZSERIO_PMR_POLYMORPHIC_ALLOCATOR_H_INC