Du kannst nicht mehr als 25 Themen auswählen
Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
205 Zeilen
3.9 KiB
205 Zeilen
3.9 KiB
#pragma once
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <gp/optional.hpp>
|
|
#include <gp/iterator.hpp>
|
|
#include <gp/function.hpp>
|
|
#include <gp/exception.hpp>
|
|
#include <gp/algorithm/move.hpp>
|
|
|
|
namespace gp{
|
|
|
|
template<typename T>
|
|
class buffer final{
|
|
public:
|
|
struct buffer_iterator final
|
|
{
|
|
T* data;
|
|
typedef T value_type;
|
|
typedef std::size_t difference_type;
|
|
static constexpr iterator_type_t iterator_type = iterator_type_t::contiguous_iterator;
|
|
|
|
constexpr buffer_iterator(const buffer_iterator& oth)
|
|
: data{oth.data}
|
|
{}
|
|
|
|
constexpr buffer_iterator(T* ptr)
|
|
: data{ptr}
|
|
{}
|
|
|
|
constexpr operator T&()
|
|
{
|
|
return *data;
|
|
}
|
|
|
|
constexpr T& operator*(){
|
|
return *data;
|
|
}
|
|
|
|
constexpr buffer_iterator operator++()
|
|
{
|
|
return buffer_iterator{++data};
|
|
}
|
|
|
|
constexpr buffer_iterator operator++(int)
|
|
{
|
|
return buffer_iterator{data++};
|
|
}
|
|
|
|
constexpr buffer_iterator operator--()
|
|
{
|
|
return buffer_iterator{--data};
|
|
}
|
|
|
|
constexpr buffer_iterator operator--(int)
|
|
{
|
|
return buffer_iterator{data--};
|
|
}
|
|
|
|
constexpr buffer_iterator operator+(const std::size_t offset)
|
|
{
|
|
return buffer_iterator{data+offset};
|
|
}
|
|
|
|
constexpr buffer_iterator operator+(const int offset)
|
|
{
|
|
return buffer_iterator{data+offset};
|
|
}
|
|
|
|
constexpr buffer_iterator operator-(const std::size_t offset)
|
|
{
|
|
return buffer_iterator{data-offset};
|
|
}
|
|
|
|
constexpr buffer_iterator operator-(const int offset)
|
|
{
|
|
return buffer_iterator{data-offset};
|
|
}
|
|
|
|
constexpr difference_type operator-(const buffer_iterator& oth) const
|
|
{
|
|
return (T*)data-(T*)oth.data;
|
|
}
|
|
|
|
constexpr bool operator==(const buffer_iterator& oth)
|
|
{
|
|
return data==oth.data;
|
|
}
|
|
|
|
constexpr bool operator!=(buffer_iterator& oth)
|
|
{
|
|
return data!=oth.data;
|
|
}
|
|
|
|
constexpr bool before_or_equal(const buffer_iterator& oth)
|
|
{
|
|
return reinterpret_cast<std::intptr_t>(data) <= reinterpret_cast<std::intptr_t>(oth.data);
|
|
}
|
|
|
|
constexpr bool operator<=(const buffer_iterator& oth)
|
|
{
|
|
return before_or_equal(oth);
|
|
}
|
|
};
|
|
private:
|
|
buffer_iterator begin_elem;
|
|
buffer_iterator end_elem;
|
|
public:
|
|
using associated_iterator = buffer_iterator;
|
|
|
|
constexpr buffer(T* beg_ptr, T* end_ptr)
|
|
: begin_elem{beg_ptr}
|
|
, end_elem{end_ptr}
|
|
{}
|
|
|
|
constexpr buffer(T* beg_ptr, std::size_t sz)
|
|
: begin_elem{beg_ptr}
|
|
, end_elem{beg_ptr+sz}
|
|
{}
|
|
|
|
constexpr typename buffer_iterator::difference_type size() const
|
|
{
|
|
return end_elem - begin_elem;
|
|
}
|
|
|
|
constexpr associated_iterator begin() const
|
|
{
|
|
return begin_elem;
|
|
}
|
|
|
|
constexpr associated_iterator end() const
|
|
{
|
|
return end_elem;
|
|
}
|
|
|
|
constexpr T& operator[](std::size_t offset)
|
|
{
|
|
return *(begin_elem+offset);
|
|
}
|
|
|
|
optional<buffer_iterator> at(std::size_t offset)
|
|
{
|
|
auto elem = begin()+offset;
|
|
if(!contains(elem))
|
|
{
|
|
return nullopt;
|
|
}
|
|
return elem;
|
|
}
|
|
|
|
constexpr bool contains(buffer_iterator ptr)
|
|
{
|
|
return
|
|
ptr.data < end_elem.data
|
|
&& ptr.data >= begin_elem.data;
|
|
}
|
|
|
|
template<typename U>
|
|
buffer<U> cast()
|
|
{
|
|
if constexpr(sizeof(T)%sizeof(U) == 0)
|
|
{
|
|
return buffer<U>(reinterpret_cast<U*>(&*begin_elem), size()*(sizeof(T)/sizeof(U)));
|
|
}
|
|
else
|
|
{
|
|
if(size()*sizeof(T)/sizeof(U))
|
|
{
|
|
return buffer<U>(reinterpret_cast<U*>(&*begin_elem), size()*sizeof(T)/sizeof(U));
|
|
}
|
|
else if constexpr (gp_config::has_exceptions)
|
|
{
|
|
throw bad_buffer_cast<T, U>{};
|
|
}
|
|
else
|
|
{
|
|
return buffer<U>(reinterpret_cast<U*>(nullptr), 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
buffer slice_start(size_t new_sz)
|
|
{
|
|
if(new_sz<=size())
|
|
{
|
|
return buffer{&*begin(), &*(begin()+new_sz)};
|
|
}
|
|
else
|
|
{
|
|
return buffer{(T*)nullptr,(size_t)0};
|
|
}
|
|
}
|
|
|
|
buffer slice_end(size_t new_sz)
|
|
{
|
|
if(new_sz<=size())
|
|
{
|
|
return buffer{&*(end()-(1+new_sz)), &*end()};
|
|
}
|
|
else
|
|
{
|
|
return buffer{(T*)nullptr,(size_t)0};
|
|
}
|
|
}
|
|
};
|
|
}
|