temporary_buffer.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_MEMORY_TEMPORARY_BUFFER_HPP__
#define MSTL_CORE_MEMORY_TEMPORARY_BUFFER_HPP__

 
#include "MSTL/core/memory/standard_allocator.hpp"
#include "MSTL/core/memory/uninitialized.hpp"
#include "MSTL/core/numeric/numeric_traits.hpp"
MSTL_BEGIN_NAMESPACE__


template <typename Iterator>
struct temporary_buffer {
    static_assert(is_ranges_fwd_iter_v<Iterator>, "temporary buffer requires forward iterator types.");
 
public:
    using value_type        = iter_value_t<Iterator>;   
    using pointer           = value_type*;              
    using const_pointer     = const value_type*;        
    using reference         = value_type&;              
    using const_reference   = const value_type&;        
    using size_type         = size_t;                
    using difference_type   = ptrdiff_t;                
    using allocator_type    = standard_allocator<value_type>;    
 
private:
    size_type original_len_ = 0;  
    size_type len_ = 0;           
    pointer buffer_ = nullptr;    
 
private:
    MSTL_CONSTEXPR20 void allocate_buffer() {
        original_len_ = len_;
        buffer_ = 0;
        constexpr size_t max = numeric_traits<uint32_t>::max() / sizeof(value_type);
        if (len_ > max) {
            len_ = max;
        }
 
        while (len_ > 0) {
            buffer_ = allocator_type::allocate(len_);
            if (buffer_) break;
            len_ /= 2;
        }
    }

    template <typename U = value_type, enable_if_t<is_trivially_copy_assignable_v<U>, int> = 0>
    MSTL_ALWAYS_INLINE MSTL_CONSTEXPR20 void initialize_buffer(const U& val) noexcept {}

    template <typename U = value_type, enable_if_t<!is_trivially_copy_assignable_v<U>, int> = 0>
    MSTL_ALWAYS_INLINE MSTL_CONSTEXPR20 void initialize_buffer(const U& val) {
        _MSTL uninitialized_fill_n(buffer_, len_, val);
    }
 
public:
    temporary_buffer(const temporary_buffer&) = delete;  
    void operator =(const temporary_buffer&) = delete;   

    MSTL_CONSTEXPR20 temporary_buffer(Iterator first, Iterator last) {
        try {
            len_ = _MSTL distance(first, last);
            this->allocate_buffer();
            if (len_ > 0) this->initialize_buffer(*first);
        } catch (...) {
            allocator_type::deallocate(buffer_);
            buffer_ = 0;
            len_ = 0;
            throw;
        }
    }

    MSTL_CONSTEXPR20 ~temporary_buffer() {
        _MSTL destroy(buffer_, buffer_ + len_);
        allocator_type::deallocate(buffer_);
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 size_type size() const noexcept {
        return len_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 size_type requested_size() const noexcept {
        return original_len_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 pointer begin() noexcept {
        return buffer_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 pointer end() noexcept {
        return buffer_ + len_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 const_pointer cbegin() const noexcept {
        return buffer_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 const_pointer cend() const noexcept {
        return buffer_ + len_;
    }

    MSTL_NODISCARD MSTL_CONSTEXPR20 bool empty() const noexcept {
        return len_ == 0;
    }
};
 // TemporaryBuffer
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_MEMORY_TEMPORARY_BUFFER_HPP__