115 行
3.1 KiB
C++
115 行
3.1 KiB
C++
#pragma once
|
|
|
|
#include <nall/array-view.hpp>
|
|
|
|
namespace nall {
|
|
|
|
template<typename T> struct array_span : array_view<T> {
|
|
using type = array_span;
|
|
using super = array_view<T>;
|
|
|
|
array_span() {
|
|
super::_data = nullptr;
|
|
super::_size = 0;
|
|
}
|
|
|
|
array_span(nullptr_t) {
|
|
super::_data = nullptr;
|
|
super::_size = 0;
|
|
}
|
|
|
|
array_span(void* data, u64 size) {
|
|
super::_data = (T*)data;
|
|
super::_size = (s32)size;
|
|
}
|
|
|
|
template<s32 size> array_span(T (&data)[size]) {
|
|
super::_data = data;
|
|
super::_size = size;
|
|
}
|
|
|
|
explicit operator bool() const {
|
|
return super::_data && super::_size > 0;
|
|
}
|
|
|
|
explicit operator T*() {
|
|
return (T*)super::_data;
|
|
}
|
|
|
|
T& operator*() const {
|
|
return (T&)*super::_data;
|
|
}
|
|
|
|
auto operator++() -> type& { super::_data++; super::_size--; return *this; }
|
|
auto operator--() -> type& { super::_data--; super::_size++; return *this; }
|
|
|
|
auto operator++(s32) -> type { auto copy = *this; ++(*this); return copy; }
|
|
auto operator--(s32) -> type { auto copy = *this; --(*this); return copy; }
|
|
|
|
auto operator[](u32 index) -> T& { return (T&)super::operator[](index); }
|
|
|
|
template<typename U = T> auto data() -> U* { return (U*)super::_data; }
|
|
template<typename U = T> auto data() const -> const U* { return (const U*)super::_data; }
|
|
|
|
auto begin() -> iterator<T> { return {(T*)super::_data, (u32)0}; }
|
|
auto end() -> iterator<T> { return {(T*)super::_data, (u32)super::_size}; }
|
|
|
|
auto rbegin() -> reverse_iterator<T> { return {(T*)super::_data, (u32)super::_size - 1}; }
|
|
auto rend() -> reverse_iterator<T> { return {(T*)super::_data, (u32)-1}; }
|
|
|
|
auto write(T value) -> void {
|
|
operator[](0) = value;
|
|
super::_data++;
|
|
super::_size--;
|
|
}
|
|
|
|
auto span(u32 offset, u32 length) -> type {
|
|
#ifdef DEBUG
|
|
struct out_of_bounds {};
|
|
if(offset + length >= super::_size) throw out_of_bounds{};
|
|
#endif
|
|
return {(T*)super::_data + offset, length};
|
|
}
|
|
|
|
//array_span<u8> specializations
|
|
template<typename U> auto writel(U value, u32 size) -> void;
|
|
template<typename U> auto writem(U value, u32 size) -> void;
|
|
template<typename U> auto writevn(U value, u32 size) -> void;
|
|
template<typename U> auto writevi(U value, u32 size) -> void;
|
|
};
|
|
|
|
//array_span<u8>
|
|
|
|
template<> inline auto array_span<u8>::write(u8 value) -> void {
|
|
operator[](0) = value;
|
|
_data++;
|
|
_size--;
|
|
}
|
|
|
|
template<> template<typename U> inline auto array_span<u8>::writel(U value, u32 size) -> void {
|
|
for(u32 byte : range(size)) write(value >> byte * 8);
|
|
}
|
|
|
|
template<> template<typename U> inline auto array_span<u8>::writem(U value, u32 size) -> void {
|
|
for(u32 byte : reverse(range(size))) write(value >> byte * 8);
|
|
}
|
|
|
|
template<> template<typename U> inline auto array_span<u8>::writevn(U value, u32 size) -> void {
|
|
while(true) {
|
|
auto byte = value & 0x7f;
|
|
value >>= 7;
|
|
if(value == 0) return write(0x80 | byte);
|
|
write(byte);
|
|
value--;
|
|
}
|
|
}
|
|
|
|
template<> template<typename U> inline auto array_span<u8>::writevi(U value, u32 size) -> void {
|
|
bool negate = value < 0;
|
|
if(negate) value = ~value;
|
|
value = value << 1 | negate;
|
|
writevn(value);
|
|
}
|
|
|
|
}
|