temporary_buffer.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_TEMPORARY_BUFFER_HPP__
#define NEFORCE_CORE_MEMORY_TEMPORARY_BUFFER_HPP__

 
#include "NeForce/core/memory/standard_allocator.hpp"
#include "NeForce/core/memory/uninitialized.hpp"
#include "NeForce/core/numeric/numeric_traits.hpp"
NEFORCE_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:
    NEFORCE_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>
    NEFORCE_CONSTEXPR20 void initialize_buffer(const U& val) noexcept {}

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

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

    NEFORCE_CONSTEXPR20 ~temporary_buffer() {
        _NEFORCE destroy(buffer_, buffer_ + len_);
        allocator_type::deallocate(buffer_);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_type size() const noexcept { return len_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_type requested_size() const noexcept { return original_len_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 pointer begin() noexcept { return buffer_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 pointer end() noexcept { return buffer_ + len_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 const_pointer cbegin() const noexcept { return buffer_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 const_pointer cend() const noexcept { return buffer_ + len_; }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool empty() const noexcept { return len_ == 0; }
};
 // TemporaryBuffer
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_TEMPORARY_BUFFER_HPP__