General Purpose library for Freestanding C++ and POSIX systems
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

#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};
}
}
};
}