std_allocator.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2025 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_BASE_STD_ALLOCATOR_H
#define MI_BASE_STD_ALLOCATOR_H
 
#include <mi/base/types.h>
#include <mi/base/iallocator.h>
#include <mi/base/default_allocator.h>
 
namespace mi {
 
namespace base {
 
template <class T>
class Std_allocator
{
    // Allocator interface used for memory management.
    IAllocator* m_alloc;
public:
 
    using value_type      = T;                
    using pointer         = T*;               
    using const_pointer   = const T*;         
    using reference       = T&;               
    using const_reference = const T&;         
    using size_type       = std::size_t;      
    using difference_type = std::ptrdiff_t;   
 
    template <class T1> struct rebind
    {
        using other = Std_allocator<T1>;
    };
 
    Std_allocator() noexcept
        : m_alloc( Default_allocator::get_instance()) {}
 
    Std_allocator( base::IAllocator* allocator) noexcept
        : m_alloc( allocator ? allocator : Default_allocator::get_instance()) {}
 
    template <class T1>
    Std_allocator(const Std_allocator<T1>& other) noexcept
        : m_alloc( other.get_allocator()) {}
 
    pointer  address( reference x) const { return &x;}
 
    const_pointer address(const_reference x) const { return &x; }
 
    T* allocate( size_type n, const void* = nullptr) noexcept
    {
        return reinterpret_cast<T*>( m_alloc->malloc( n * sizeof(value_type)));
    }
 
    //           the standard allocator concept \p p must not be \c nullptr.
    void deallocate(pointer p, size_type)
    {
        m_alloc->free( p);
    }
 
    size_type max_size() const noexcept  { return SIZE_MAX_VALUE / sizeof(value_type); }
 
    void construct(pointer p, const_reference value) { new(p) T(value); }
 
    void destroy(pointer p) { p->~T(); }
 
    IAllocator* get_allocator() const { return m_alloc; }
 
    template <class T2>
    bool operator==( Std_allocator<T2> other) const noexcept
    {
        return m_alloc == other.get_allocator();
    }
 
    template <class T2>
    bool operator!=( Std_allocator<T2> other) const noexcept
    {
        return ! ((*this) == other);
    }
};
 // end group mi_base_iallocator
 
} // namespace base
 
} // namespace mi
 
#endif // MI_BASE_STD_ALLOCATOR_H