• Log in

namespace std::pmr{// class memory_resourceclass memory_resource; bool operator==(const memory_resource& a,const memory_resource& b)noexcept; // class template polymorphic_allocatortemplate<class Tp>class polymorphic_allocator; template<class T1,class T2>bool operator==(const polymorphic_allocator<T1>& a,const polymorphic_allocator<T2>& b)noexcept; // global memory resources  memory_resource* new_delete_resource()noexcept;  memory_resource* null_memory_resource()noexcept;  memory_resource* set_default_resource(memory_resource* r)noexcept;  memory_resource* get_default_resource()noexcept; // pool resource classesstruct pool_options;class synchronized_pool_resource;class unsynchronized_pool_resource;class monotonic_buffer_resource;}

namespace std::pmr{class memory_resource{staticconstexpr size_t max_align= alignof(max_align_t);// exposition only public:    memory_resource()=default;    memory_resource(const memory_resource&)=default;virtual ~memory_resource();     memory_resource& operator=(const memory_resource&)=default; void* allocate(size_t bytes, size_t alignment= max_align);void deallocate(void* p, size_t bytes, size_t alignment= max_align); bool is_equal(const memory_resource& other)constnoexcept; private:virtualvoid* do_allocate(size_t bytes, size_t alignment)=0;virtualvoid do_deallocate(void* p, size_t bytes, size_t alignment)=0; virtualbool do_is_equal(const memory_resource& other)constnoexcept=0;};}

namespace std::pmr{template<class Tp= byte>class polymorphic_allocator{    memory_resource* memory_rsrc;// exposition only public:using value_type= Tp; // constructors    polymorphic_allocator()noexcept;    polymorphic_allocator(memory_resource* r);     polymorphic_allocator(const polymorphic_allocator& other)=default; template<class U>      polymorphic_allocator(const polymorphic_allocator<U>& other)noexcept;     polymorphic_allocator& operator=(const polymorphic_allocator&)= delete; // member functions    Tp* allocate(size_t n);void deallocate(Tp* p, size_t n); void* allocate_bytes(size_t nbytes, size_t alignment= alignof(max_align_t));void deallocate_bytes(void* p, size_t nbytes, size_t alignment= alignof(max_align_t));template<class T> T* allocate_object(size_t n=1);template<class T>void deallocate_object(T* p, size_t n=1);template<class T,class...CtorArgs>      T* new_object(CtorArgs&&...ctor_args);template<class T>void delete_object(T* p); template<class T,class...Args>void construct(T* p, Args&&...args); template<class T>void destroy(T* p);// deprecated     polymorphic_allocator select_on_container_copy_construction()const;     memory_resource* resource()const;};}

namespace std::pmr{struct pool_options{    size_t max_blocks_per_chunk=0;    size_t largest_required_pool_block=0;};}

namespace std::pmr{class synchronized_pool_resource:public memory_resource{public:    synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);     synchronized_pool_resource(): synchronized_pool_resource(pool_options(), get_default_resource()){}explicit synchronized_pool_resource(memory_resource* upstream): synchronized_pool_resource(pool_options(), upstream){}explicit synchronized_pool_resource(const pool_options& opts): synchronized_pool_resource(opts, get_default_resource()){}     synchronized_pool_resource(const synchronized_pool_resource&)= delete;virtual ~synchronized_pool_resource();     synchronized_pool_resource& operator=(const synchronized_pool_resource&)= delete; void release();    memory_resource* upstream_resource()const;    pool_options options()const; protected:void* do_allocate(size_t bytes, size_t alignment) override;void do_deallocate(void* p, size_t bytes, size_t alignment) override; bool do_is_equal(const memory_resource& other)constnoexcept override;};}

namespace std::pmr{class unsynchronized_pool_resource:public memory_resource{public:    unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream);     unsynchronized_pool_resource(): unsynchronized_pool_resource(pool_options(), get_default_resource()){}explicit unsynchronized_pool_resource(memory_resource* upstream): unsynchronized_pool_resource(pool_options(), upstream){}explicit unsynchronized_pool_resource(const pool_options& opts): unsynchronized_pool_resource(opts, get_default_resource()){}     unsynchronized_pool_resource(const unsynchronized_pool_resource&)= delete;virtual ~unsynchronized_pool_resource();     unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&)= delete; void release();    memory_resource* upstream_resource()const;    pool_options options()const; protected:void* do_allocate(size_t bytes, size_t alignment) override;void do_deallocate(void* p, size_t bytes, size_t alignment) override; bool do_is_equal(const memory_resource& other)constnoexcept override;};}

namespace std::pmr{class monotonic_buffer_resource:public memory_resource{    memory_resource* upstream_rsrc;// exposition onlyvoid* current_buffer;// exposition only    size_t next_buffer_size;// exposition only public:explicit monotonic_buffer_resource(memory_resource* upstream);    monotonic_buffer_resource(size_t initial_size, memory_resource* upstream);    monotonic_buffer_resource(void* buffer, size_t buffer_size, memory_resource* upstream);     monotonic_buffer_resource(): monotonic_buffer_resource(get_default_resource()){}explicit monotonic_buffer_resource(size_t initial_size): monotonic_buffer_resource(initial_size, get_default_resource()){}    monotonic_buffer_resource(void* buffer, size_t buffer_size): monotonic_buffer_resource(buffer, buffer_size, get_default_resource()){}     monotonic_buffer_resource(const monotonic_buffer_resource&)= delete; virtual ~monotonic_buffer_resource();     monotonic_buffer_resource& operator=(const monotonic_buffer_resource&)= delete; void release();    memory_resource* upstream_resource()const; protected:void* do_allocate(size_t bytes, size_t alignment) override;void do_deallocate(void* p, size_t bytes, size_t alignment) override; bool do_is_equal(const memory_resource& other)constnoexcept override;};}