temporary_buffer.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_TEMPORARY_BUFFER_HPP__
#define NEFORCE_CORE_MEMORY_TEMPORARY_BUFFER_HPP__

 
#include "NeForce/core/algorithm/compare.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);
        len_ = _NEFORCE min(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& /*unused*/) noexcept {}
 
    template <typename U = value_type, enable_if_t<!is_trivially_copy_assignable_v<U>, int> = 0>
    NEFORCE_CONSTEXPR20 void initialize_buffer(const U& value) {
        _NEFORCE uninitialized_fill_n(buffer_, len_, value);
    }
 
public:
    temporary_buffer() noexcept = default;
 
    temporary_buffer(const temporary_buffer&) = delete;            
    temporary_buffer& operator=(const temporary_buffer&) = delete; 
 
    temporary_buffer(temporary_buffer&& other) noexcept :
    original_len_(other.original_len_),
    len_(other.len_),
    buffer_(other.buffer_) {
        other.original_len_ = 0;
        other.len_ = 0;
        other.buffer_ = nullptr;
    }
    temporary_buffer& operator=(temporary_buffer&& other) noexcept {
        if (addressof(other) == this) {
            return *this;
        }
        original_len_ = other.original_len_;
        len_ = other.len_;
        buffer_ = other.buffer_;
        other.original_len_ = 0;
        other.len_ = 0;
        other.buffer_ = nullptr;
        return *this;
    }

    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 (...) {
            if (buffer_ != nullptr) {
                allocator_type::deallocate(buffer_);
            }
            buffer_ = 0;
            len_ = 0;
            throw;
        }
    }

    NEFORCE_CONSTEXPR20 ~temporary_buffer() {
        if (buffer_ != nullptr) {
            _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__