89 lines
2.0 KiB
C++
89 lines
2.0 KiB
C++
#pragma once
|
|
|
|
#include <Orange/Core/Types.h>
|
|
#include <string.h>
|
|
|
|
namespace orange
|
|
{
|
|
template <typename T>
|
|
struct Span
|
|
{
|
|
Span(T* data, size_t size) : data(data), size(size) {}
|
|
|
|
template <size_t Count>
|
|
Span(T (&array)[Count]) : data(array), size(Count) {}
|
|
|
|
template <typename J>
|
|
Span(J& x)
|
|
: data(x.begin())
|
|
, size(x.end() - x.begin()) {}
|
|
|
|
T& operator [] (size_t idx) { return data[idx]; }
|
|
const T& operator [] (size_t idx) const { return data[idx]; }
|
|
|
|
template <typename J>
|
|
bool operator == (const Span<J>& other) const
|
|
{
|
|
if (other.size != size)
|
|
return false;
|
|
|
|
for (size_t i = 0; i < size; i++)
|
|
{
|
|
if (data[i] != other.data[i])
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool IsEmpty() const { return size == 0; }
|
|
|
|
T* begin() { return &data[0]; }
|
|
const T* begin() const { return &data[0]; }
|
|
|
|
T* end() { return &data[size]; }
|
|
const T* end() const { return &data[size]; }
|
|
|
|
T& front() { return data[0]; }
|
|
const T& front() const { return data[0]; }
|
|
|
|
T& back() { return data[size - 1]; }
|
|
const T& back() const { return data[size - 1]; }
|
|
|
|
void Copy(void* dst)
|
|
{
|
|
memcpy(dst, data, sizeof(T) * size);
|
|
}
|
|
|
|
T* data;
|
|
size_t size;
|
|
};
|
|
|
|
struct BufferView : public Span<uint8_t>
|
|
{
|
|
using Span<uint8_t>::Span;
|
|
};
|
|
|
|
struct StringView : public Span<const char>
|
|
{
|
|
using Span<const char>::Span;
|
|
|
|
StringView(const char* str)
|
|
: Span<const char>{str, strlen(str)} {}
|
|
};
|
|
|
|
struct Buffer : public BufferView
|
|
{
|
|
using BufferView::BufferView;
|
|
|
|
~Buffer() { delete[] data; }
|
|
};
|
|
|
|
struct TextBuffer : public Span<char>
|
|
{
|
|
using Span<char>::Span;
|
|
|
|
~TextBuffer() { delete[] data; }
|
|
};
|
|
}
|