q_pmr_emulation_p.h

Go to the documentation of this file.

// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#ifndef Q_PMR_EMULATION_P_H
#define Q_PMR_EMULATION_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include <QtCore/qtconfigmacros.h>
 
#if defined(__APPLE__)
// minimum requirement: iOS 17.0, macOS 14.0, watchOS 10.0 and tvOS 17.0.
#  include <Availability.h>
#  if !_LIBCPP_AVAILABILITY_HAS_PMR
#    define QT_MM_PMR_EMULATION
#  endif
#endif
 
#if defined(Q_OS_VXWORKS)
// std::pmr::deque<variant> doesn't seem to compile on VxWorks, so we use our emulation
#  define QT_MM_PMR_EMULATION
#endif
 
#if !__has_include(<memory_resource>)
#  define QT_MM_PMR_EMULATION
#endif
 
#ifdef QT_MM_PMR_EMULATION
 
#  include <QtCore/qassert.h>
 
#  include <cstddef>
#  include <new>
#  include <typeinfo>
 
#else
 
#  include <memory_resource>
 
#endif
 
#include <map>
#include <vector>
 
QT_BEGIN_NAMESPACE
 
namespace QtMultimediaPrivate::pmr {
 
#ifndef QT_MM_PMR_EMULATION
 
using memory_resource = std::pmr::memory_resource;
template <typename T = std::byte>
using polymorphic_allocator = std::pmr::polymorphic_allocator<T>;
 
inline auto get_default_resource() noexcept
{
    return std::pmr::get_default_resource();
}
 
inline auto new_delete_resource() noexcept
{
    return std::pmr::new_delete_resource();
}
 
#else
 
class memory_resource;
memory_resource *get_default_resource() noexcept;
memory_resource *new_delete_resource() noexcept;
 
class memory_resource
{
public:
    memory_resource() = default;
    memory_resource(const memory_resource &) = delete;
    memory_resource &operator=(const memory_resource &) = delete;
    virtual ~memory_resource() noexcept = default;
 
    [[nodiscard]]
    void *allocate(size_t bytes, size_t alignment = alignof(std::max_align_t))
    {
        return do_allocate(bytes, alignment);
    }
 
    void deallocate(void *p, size_t bytes, size_t alignment = alignof(std::max_align_t))
    {
        do_deallocate(p, bytes, alignment);
    }
 
    bool is_equal(const memory_resource &other) const noexcept { return do_is_equal(other); }
 
protected:
    virtual void *do_allocate(size_t bytes, size_t alignment) = 0;
    virtual void do_deallocate(void *p, size_t bytes, size_t alignment) = 0;
    virtual bool do_is_equal(const memory_resource &other) const noexcept { return this == &other; }
 
private:
    template <class T>
    friend class polymorphic_allocator;
};
 
inline bool operator==(const memory_resource &a, const memory_resource &b) noexcept
{
    return &a == &b || a.is_equal(b);
}
 
inline bool operator!=(const memory_resource &a, const memory_resource &b) noexcept
{
    return !(a == b);
}
 
template <class T>
class polymorphic_allocator
{
public:
    using value_type = T;
 
    polymorphic_allocator() noexcept = default;
    polymorphic_allocator(memory_resource *r) : m_resource(r) { Q_ASSERT(r); }
    polymorphic_allocator(const polymorphic_allocator &other) noexcept = default;
 
    template <class U>
    polymorphic_allocator(const polymorphic_allocator<U> &other) noexcept
        : m_resource(other.resource())
    {
    }
 
    polymorphic_allocator &operator=(const polymorphic_allocator &other) noexcept = default;
 
    [[nodiscard]]
    T *allocate(size_t n)
    {
        void *ptr = m_resource->allocate(n * sizeof(T), alignof(T));
        return static_cast<T *>(ptr);
    }
 
    void deallocate(T *p, size_t n) { m_resource->deallocate(p, n * sizeof(T), alignof(T)); }
 
    [[nodiscard]]
    memory_resource *resource() const noexcept
    {
        return m_resource;
    }
 
    [[nodiscard]]
    polymorphic_allocator select_on_container_copy_construction() const
    {
        return polymorphic_allocator();
    }
 
private:
    memory_resource *m_resource = get_default_resource();
};
 
template <class T1, class T2>
bool operator==(const polymorphic_allocator<T1> &a, const polymorphic_allocator<T2> &b) noexcept
{
    return *a.resource() == *b.resource();
}
 
template <class T1, class T2>
bool operator!=(const polymorphic_allocator<T1> &a, const polymorphic_allocator<T2> &b) noexcept
{
    return !(a == b);
}
 
namespace detail {
 
class new_delete_resource_impl final : public memory_resource
{
public:
    using memory_resource::memory_resource;
 
protected:
    void *do_allocate(size_t bytes, size_t alignment) override
    {
        return ::operator new(bytes, static_cast<std::align_val_t>(alignment));
    }
 
    void do_deallocate(void *p, [[maybe_unused]] size_t bytes, size_t alignment) override
    {
#  ifdef __cpp_sized_deallocation
        ::operator delete(p, bytes, static_cast<std::align_val_t>(alignment));
#  else
        ::operator delete(p, static_cast<std::align_val_t>(alignment));
#  endif
    }
 
    bool do_is_equal(const memory_resource &other) const noexcept override
    {
        return &other == this || typeid(other) == typeid(new_delete_resource_impl);
    }
};
 
} // namespace detail
 
inline memory_resource *new_delete_resource() noexcept
{
    static detail::new_delete_resource_impl instance;
    return &instance;
}
 
inline memory_resource *get_default_resource() noexcept
{
    return new_delete_resource();
}
 
#endif
 
template <typename T>
using vector = std::vector<T, polymorphic_allocator<T>>;
 
template <typename K, typename V, typename C = std::less<K>>
using map = std::map<K, V, C, polymorphic_allocator<std::pair<const K, V>>>;
 
} // namespace QtMultimediaPrivate::pmr
 
QT_END_NAMESPACE
 
#ifdef QT_MM_PMR_EMULATION
#  undef QT_MM_PMR_EMULATION
#endif // QT_MM_PMR_EMULATION
 
#endif // Q_PMR_EMULATION_P_H