thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2025-12-18 05:52:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'cxx-io' into 'master'

Browse source 
C++ IO abstractions and std::span

See merge request KartKrew/Kart!840
This commit is contained in:
Eidolon 2022-12-31 03:46:30 +00:00
commit fe32cba866
9 changed files with 1470 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
.clang-format Normal file
View file

@ -0,0 +1,54 @@
---
Language: Cpp
Standard: c++17
IndentWidth: 4
UseTab: Always
TabWidth: 4
ColumnLimit: 120
AccessModifierOffset: -4
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: InlineOnly
AllowShortIfStatementsOnASingleLine: false
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false
BinPackParameters: false
BreakBeforeBraces: Attach # K&R/OTBS, braces on same line, Java style
BreakConstructorInitializers: BeforeComma
CompactNamespaces: true
ConstructorInitializerAllOnOneLineOrOnePerLine: true
Cpp11BracedListStyle: true
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: Always
FixNamespaceComments: true
IndentCaseBlocks: true
IndentCaseLabels: false
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: false
PointerAlignment: Left # Pointer and reference marker is an integral part of type ID
ReferenceAlignment: Left
ReflowComments: true
SortIncludes: CaseInsensitive
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false

43
.editorconfig Normal file
View file

@ -0,0 +1,43 @@
root = true
[*]
charset = utf-8
insert_final_newline = true
trim_trailing_whitespace = true
[.editorconfig]
indent_size = 4
indent_style = tab
tab_width = 4
[src/**.{c,h,cpp,hpp}]
indent_style = tab
indent_size = 4
tab_width = 4
[{CMakeLists.txt,*.cmake}]
indent_size = 4
indent_style = tab
tab_width = 4
[{Makefile,*.mk}]
indent_size = 8
indent_style = tab
tab_width = 8
[*{.yml,.yaml}]
indent_size = 2
indent_style = space
tab_width = 8
[*.sh]
indent_size = 4
indent_style = tab
tab_width = 4
end_of_line = lf
[*.bat]
indent_size = 4
indent_style = tab
tab_width = 4
end_of_line = crlf

4
src/CMakeLists.txt
View file

@ -1,5 +1,6 @@
add_executable(SRB2SDL2 MACOSX_BUNDLE WIN32
comptime.c
cxxutil.hpp
md5.c
config.h.in
string.c
@ -224,6 +225,8 @@ target_link_libraries(SRB2SDL2 PRIVATE DiscordRPC::DiscordRPC)
target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_DISCORDRPC -DUSE_STUN)
target_sources(SRB2SDL2 PRIVATE discord.c stun.c)
target_link_libraries(SRB2SDL2 PRIVATE tcbrindle::span)
set(SRB2_HAVE_THREADS ON)
target_compile_definitions(SRB2SDL2 PRIVATE -DHAVE_THREADS)
@ -535,6 +538,7 @@ if(SRB2_CONFIG_PROFILEMODE AND "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
target_link_options(SRB2SDL2 PRIVATE -pg)
endif()
add_subdirectory(io)
add_subdirectory(sdl)
add_subdirectory(objects)
add_subdirectory(tests)

4
src/io/CMakeLists.txt Normal file
View file

@ -0,0 +1,4 @@
target_sources(SRB2SDL2 PRIVATE
streams.cpp
streams.hpp
)

4
src/io/streams.cpp Normal file
View file

@ -0,0 +1,4 @@
#include "streams.hpp"
template class srb2::io::ZlibInputStream<srb2::io::SpanStream>;
template class srb2::io::ZlibInputStream<srb2::io::VecStream>;

733
src/io/streams.hpp Normal file
View file

@ -0,0 +1,733 @@
#ifndef __SRB2_IO_STREAMS_HPP__
#define __SRB2_IO_STREAMS_HPP__
#include <cstddef>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include <tcb/span.hpp>
#include <zlib.h>
namespace srb2::io {
using StreamSize = uint64_t;
using StreamOffset = int64_t;
enum class SeekFrom {
kStart,
kCurrent,
kEnd
};
template <typename T>
struct IsInputStream
: public std::is_same<decltype(std::declval<T&>().read(std::declval<tcb::span<std::byte>>())), StreamSize> {};
template <typename T>
struct IsOutputStream
: public std::is_same<decltype(std::declval<T&>().write(std::declval<tcb::span<const std::byte>>())), StreamSize> {
};
template <typename T>
struct IsSeekableStream
: public std::is_same<decltype(std::declval<T&>().seek(std::declval<SeekFrom>(), std::declval<StreamOffset>())),
StreamSize> {};
template <typename T>
struct IsStream : public std::disjunction<IsInputStream<T>, IsOutputStream<T>> {};
template <typename T>
struct IsInputOutputStream : public std::conjunction<IsInputStream<T>, IsOutputStream<T>> {};
template <typename T>
inline constexpr const bool IsInputStreamV = IsInputStream<T>::value;
template <typename T>
inline constexpr const bool IsOutputStreamV = IsOutputStream<T>::value;
template <typename T>
inline constexpr const bool IsSeekableStreamV = IsSeekableStream<T>::value;
template <typename T>
inline constexpr const bool IsStreamV = IsStream<T>::value;
template <typename T>
inline constexpr const bool IsInputOutputStreamV = IsInputOutputStream<T>::value;
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read_exact(I& stream, tcb::span<std::byte> buffer) {
std::size_t total = 0;
const std::size_t buf_size = buffer.size();
while (total < buf_size) {
total += stream.read(buffer.subspan(total, buf_size - total));
}
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write_exact(O& stream, tcb::span<const std::byte> buffer) {
std::size_t total = 0;
const std::size_t buf_size = buffer.size();
while (total < buf_size) {
total += stream.write(buffer.subspan(total, buf_size - total));
}
}
enum class Endian {
kLE,
kBE,
};
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(std::byte& value, I& stream) {
read_exact(stream, tcb::span {&value, 1});
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(std::byte value, O& stream) {
write_exact(stream, tcb::span {&value, 1});
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(uint8_t& value, I& stream) {
std::byte in;
read_exact(stream, tcb::span {&in, 1});
value = std::to_integer<uint8_t>(in);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
uint8_t read_uint8(I& stream) {
uint8_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(uint8_t value, O& stream) {
std::byte out {value};
write_exact(stream, tcb::span {&out, 1});
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(bool& value, I& stream) {
uint8_t v;
read(v, stream);
value = !(v == 0);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
bool read_bool(I& stream) {
bool ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(bool value, O& stream) {
uint8_t out;
if (value)
out = 1;
else
out = 0;
write(out, stream);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(int8_t& value, I& stream) {
uint8_t in;
read(in, stream);
value = *reinterpret_cast<int8_t*>(&in);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
int8_t read_int8(I& stream) {
int8_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(int8_t value, O& stream) {
write(*reinterpret_cast<uint8_t*>(&value), stream);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(uint16_t& value, I& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 2> out;
read_exact(stream, tcb::make_span(out));
if (endian == Endian::kBE)
value = std::to_integer<uint16_t>(out[1]) + (std::to_integer<uint16_t>(out[0]) << 8);
else
value = std::to_integer<uint16_t>(out[0]) + (std::to_integer<uint16_t>(out[1]) << 8);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
uint16_t read_uint16(I& stream) {
uint16_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(uint16_t value, O& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 2> out;
if (endian == Endian::kBE)
out = {std::byte {static_cast<uint8_t>((value & 0xFF00) >> 8)},
std::byte {static_cast<uint8_t>((value & 0x00FF) >> 0)}};
else
out = {std::byte {static_cast<uint8_t>((value & 0x00FF) >> 0)},
std::byte {static_cast<uint8_t>((value & 0xFF00) >> 8)}};
write_exact(stream, tcb::make_span(out));
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(int16_t& value, I& stream, Endian endian = Endian::kLE) {
uint16_t r;
read(r, stream, endian);
value = *reinterpret_cast<int16_t*>(&r);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
int16_t read_int16(I& stream) {
int16_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(int16_t value, O& stream, Endian endian = Endian::kLE) {
write(*reinterpret_cast<int16_t*>(&value), stream, endian);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(uint32_t& value, I& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 4> out;
read_exact(stream, tcb::make_span(out));
if (endian == Endian::kBE)
value = std::to_integer<uint32_t>(out[3]) + (std::to_integer<uint32_t>(out[2]) << 8) +
(std::to_integer<uint32_t>(out[1]) << 16) + (std::to_integer<uint32_t>(out[0]) << 24);
else
value = std::to_integer<uint32_t>(out[0]) + (std::to_integer<uint32_t>(out[1]) << 8) +
(std::to_integer<uint32_t>(out[2]) << 16) + (std::to_integer<uint32_t>(out[3]) << 24);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
uint32_t read_uint32(I& stream) {
uint32_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(uint32_t value, O& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 4> out;
if (endian == Endian::kBE)
out = {std::byte {static_cast<uint8_t>((value & 0xFF000000) >> 24)},
std::byte {static_cast<uint8_t>((value & 0x00FF0000) >> 16)},
std::byte {static_cast<uint8_t>((value & 0x0000FF00) >> 8)},
std::byte {static_cast<uint8_t>((value & 0x000000FF) >> 0)}};
else
out = {std::byte {static_cast<uint8_t>((value & 0x000000FF) >> 0)},
std::byte {static_cast<uint8_t>((value & 0x0000FF00) >> 8)},
std::byte {static_cast<uint8_t>((value & 0x00FF0000) >> 16)},
std::byte {static_cast<uint8_t>((value & 0xFF000000) >> 24)}};
write_exact(stream, tcb::make_span(out));
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(int32_t& value, I& stream, Endian endian = Endian::kLE) {
uint32_t r;
read(r, stream, endian);
value = *reinterpret_cast<int32_t*>(&r);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
int32_t read_int32(I& stream) {
int32_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(int32_t value, O& stream, Endian endian = Endian::kLE) {
write(*reinterpret_cast<uint32_t*>(&value), stream, endian);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(uint64_t& value, I& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 8> out;
read_exact(stream, tcb::make_span(out));
if (endian == Endian::kBE)
value = std::to_integer<uint64_t>(out[7]) + (std::to_integer<uint64_t>(out[6]) << 8) +
(std::to_integer<uint64_t>(out[5]) << 16) + (std::to_integer<uint64_t>(out[4]) << 24) +
(std::to_integer<uint64_t>(out[3]) << 32) + (std::to_integer<uint64_t>(out[2]) << 40) +
(std::to_integer<uint64_t>(out[1]) << 48) + (std::to_integer<uint64_t>(out[0]) << 56);
else
value = std::to_integer<uint64_t>(out[0]) + (std::to_integer<uint64_t>(out[1]) << 8) +
(std::to_integer<uint64_t>(out[2]) << 16) + (std::to_integer<uint64_t>(out[3]) << 24) +
(std::to_integer<uint64_t>(out[4]) << 32) + (std::to_integer<uint64_t>(out[5]) << 40) +
(std::to_integer<uint64_t>(out[6]) << 48) + (std::to_integer<uint64_t>(out[7]) << 56);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
uint64_t read_uint64(I& stream) {
uint64_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(uint64_t value, O& stream, Endian endian = Endian::kLE) {
std::array<std::byte, 8> out;
if (endian == Endian::kBE)
out = {std::byte {static_cast<uint8_t>((value & 0xFF00000000000000) >> 56)},
std::byte {static_cast<uint8_t>((value & 0x00FF000000000000) >> 48)},
std::byte {static_cast<uint8_t>((value & 0x0000FF0000000000) >> 40)},
std::byte {static_cast<uint8_t>((value & 0x000000FF00000000) >> 32)},
std::byte {static_cast<uint8_t>((value & 0x00000000FF000000) >> 24)},
std::byte {static_cast<uint8_t>((value & 0x0000000000FF0000) >> 16)},
std::byte {static_cast<uint8_t>((value & 0x000000000000FF00) >> 8)},
std::byte {static_cast<uint8_t>((value & 0x00000000000000FF) >> 0)}};
else
out = {std::byte {static_cast<uint8_t>((value & 0x00000000000000FF) >> 0)},
std::byte {static_cast<uint8_t>((value & 0x000000000000FF00) >> 8)},
std::byte {static_cast<uint8_t>((value & 0x0000000000FF0000) >> 16)},
std::byte {static_cast<uint8_t>((value & 0x00000000FF000000) >> 24)},
std::byte {static_cast<uint8_t>((value & 0x000000FF00000000) >> 32)},
std::byte {static_cast<uint8_t>((value & 0x0000FF0000000000) >> 40)},
std::byte {static_cast<uint8_t>((value & 0x00FF000000000000) >> 48)},
std::byte {static_cast<uint8_t>((value & 0xFF00000000000000) >> 56)}};
write_exact(stream, tcb::make_span(out));
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(int64_t& value, I& stream, Endian endian = Endian::kLE) {
uint64_t r;
read(r, stream, endian);
value = *reinterpret_cast<int64_t*>(&r);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
int64_t read_int64(I& stream) {
int64_t ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(int64_t value, O& stream, Endian endian = Endian::kLE) {
write(*reinterpret_cast<uint64_t*>(&value), stream, endian);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(float& value, I& stream, Endian endian = Endian::kLE) {
uint32_t r;
read(r, stream, endian);
value = *reinterpret_cast<float*>(&r);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
float read_float(I& stream) {
float ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(float value, O& stream, Endian endian = Endian::kLE) {
write(*reinterpret_cast<int32_t*>(&value), stream, endian);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
void read(double& value, I& stream, Endian endian = Endian::kLE) {
uint64_t r;
read(r, stream, endian);
value = *reinterpret_cast<double*>(&r);
}
template <typename I, typename std::enable_if_t<IsInputStreamV<I>>* = nullptr>
double read_double(I& stream) {
double ret;
read(ret, stream);
return ret;
}
template <typename O, typename std::enable_if_t<IsOutputStreamV<O>>* = nullptr>
void write(double value, O& stream, Endian endian = Endian::kLE) {
write(*reinterpret_cast<int64_t*>(&value), stream, endian);
}
template <typename S, typename std::enable_if_t<IsSeekableStreamV<S>>* = nullptr>
StreamSize remaining(S& stream) {
const StreamSize current = stream.seek(SeekFrom::kCurrent, 0);
const StreamSize end = stream.seek(SeekFrom::kEnd, 0);
stream.seek(SeekFrom::kStart, current);
return end - current;
}
// Kinds of streams
class SpanStream {
public:
SpanStream() noexcept = default;
SpanStream(tcb::span<std::byte> span) : span_(span), head_(0) {
if (span_.size() > static_cast<StreamSize>(static_cast<StreamOffset>(-1))) {
throw std::logic_error("Span must not be greater than 2 billion bytes");
}
};
StreamSize read(tcb::span<std::byte> buffer) {
if (head_ >= span_.size())
return 0;
const auto begin = buffer.begin();
const auto end = std::copy(
span_.begin() + head_, span_.begin() + head_ + std::min(buffer.size(), span_.size() - head_), begin);
head_ += std::distance(begin, end);
return std::distance(begin, end);
}
StreamSize write(tcb::span<const std::byte> buffer) {
if (head_ >= span_.size())
return 0;
const auto begin = span_.begin() + head_;
const auto end =
std::copy(buffer.begin(), buffer.begin() + std::min(span_.size() - head_, buffer.size()), begin);
head_ += std::distance(begin, end);
return std::distance(begin, end);
}
StreamSize seek(SeekFrom seek_from, StreamOffset offset) {
std::size_t head = 0;
switch (seek_from) {
case SeekFrom::kStart:
if (offset < 0 || offset >= static_cast<StreamOffset>(span_.size())) {
throw std::logic_error("start offset is out of bounds");
}
head = offset;
break;
case SeekFrom::kEnd:
if (-offset >= static_cast<StreamOffset>(span_.size())) {
throw std::logic_error("end offset is out of bounds");
}
head = span_.size() - offset;
break;
case SeekFrom::kCurrent:
if (head_ + offset < 0 || head_ + offset >= span_.size()) {
throw std::logic_error("offset is out of bounds");
}
head = head_ + offset;
break;
}
std::swap(head, head_);
return head_;
}
private:
tcb::span<std::byte> span_;
std::size_t head_ {0};
};
class VecStream {
std::vector<std::byte> vec_;
std::size_t head_ {0};
public:
VecStream() = default;
VecStream(const std::vector<std::byte>& vec) : vec_(vec) {}
VecStream(std::vector<std::byte>&& vec) : vec_(std::move(vec)) {}
VecStream(const VecStream& rhs) = default;
VecStream(VecStream&& rhs) = default;
VecStream& operator=(const VecStream& rhs) = default;
VecStream& operator=(VecStream&& rhs) = default;
StreamSize read(tcb::span<std::byte> buffer) {
if (head_ >= vec_.size())
return 0;
const auto begin = buffer.begin();
const auto end =
std::copy(vec_.begin() + head_, vec_.begin() + head_ + std::min(buffer.size(), vec_.size() - head_), begin);
head_ += std::distance(begin, end);
return std::distance(begin, end);
}
StreamSize write(tcb::span<const std::byte> buffer) {
const std::size_t buffer_size = buffer.size();
if (head_ + buffer_size >= vec_.size()) {
vec_.resize(head_ + buffer_size);
}
const auto begin = vec_.begin() + head_;
const auto end =
std::copy(buffer.begin(), buffer.begin() + std::min(vec_.size() - head_, buffer.size()), begin);
head_ += std::distance(begin, end);
return std::distance(begin, end);
}
StreamSize seek(SeekFrom seek_from, StreamOffset offset) {
std::size_t head = 0;
switch (seek_from) {
case SeekFrom::kStart:
if (offset < 0 || offset >= static_cast<StreamOffset>(vec_.size())) {
throw std::logic_error("start offset is out of bounds");
}
head = offset;
break;
case SeekFrom::kEnd:
if (-offset >= static_cast<StreamOffset>(vec_.size())) {
throw std::logic_error("end offset is out of bounds");
}
head = vec_.size() - offset;
break;
case SeekFrom::kCurrent:
if (head_ + offset < 0 || head_ + offset >= vec_.size()) {
throw std::logic_error("offset is out of bounds");
}
head = head_ + offset;
break;
}
std::swap(head, head_);
return head_;
}
std::vector<std::byte>& vector() { return vec_; }
};
class ZlibException : public std::exception {
int err_ {0};
std::string msg_;
public:
ZlibException(int err, const char* msg = nullptr) : err_(err), msg_("srb2::io::ZlibException: zlib error: ") {
const char* err_msg = "(UNKNOWN) ";
switch (err_) {
case Z_OK:
err_msg = "(Z_OK) ";
break;
case Z_STREAM_END:
err_msg = "(Z_STREAM_END) ";
break;
case Z_NEED_DICT:
err_msg = "(Z_NEED_DICT) ";
break;
case Z_ERRNO:
err_msg = "(Z_ERRNO) ";
break;
case Z_STREAM_ERROR:
err_msg = "(Z_STREAM_ERROR) ";
break;
case Z_DATA_ERROR:
err_msg = "(Z_DATA_ERROR) ";
break;
case Z_MEM_ERROR:
err_msg = "(Z_MEM_ERROR) ";
break;
case Z_BUF_ERROR:
err_msg = "(Z_BUF_ERROR) ";
break;
case Z_VERSION_ERROR:
err_msg = "(Z_VERSION_ERROR) ";
break;
}
msg_.append(err_msg);
if (msg != nullptr)
msg_.append(msg);
else
msg_.append("nullptr");
}
virtual const char* what() const noexcept override final { return msg_.c_str(); }
};
template <typename I,
typename std::enable_if_t<IsInputStreamV<I> && std::is_move_constructible_v<I> &&
std::is_move_assignable_v<I>>* = nullptr>
class ZlibInputStream {
I inner_;
z_stream stream_;
std::vector<std::byte> buf_;
std::size_t buf_head_;
bool zstream_initialized_;
bool zstream_ended_;
public:
ZlibInputStream(I&& inner)
: inner_(std::move(inner))
, stream_ {}
, buf_()
, buf_head_(0)
, zstream_initialized_ {false}
, zstream_ended_ {false} {}
ZlibInputStream(const ZlibInputStream& rhs) = delete;
ZlibInputStream(ZlibInputStream&& rhs) = delete;
ZlibInputStream& operator=(const ZlibInputStream& rhs) = delete;
ZlibInputStream& operator=(ZlibInputStream&& rhs) = delete;
StreamSize read(tcb::span<std::byte> buffer) {
if (zstream_ended_)
return 0;
std::size_t written = 0;
const std::size_t buffer_size = buffer.size();
while (written < buffer_size && !zstream_ended_) {
_fill_read_buffer();
if (buf_.size() == 0) {
break;
}
const std::size_t written_this_time = _inflate(buffer.subspan(written));
written += written_this_time;
}
return written;
}
I& stream() { return inner_; }
void close() {
if (!zstream_initialized_)
return;
int ret = inflateEnd(&stream_);
if (ret != Z_OK)
throw ZlibException {ret, stream_.msg};
zstream_initialized_ = false;
zstream_ended_ = true;
}
~ZlibInputStream() {
if (zstream_initialized_) {
int ret = inflateEnd(&stream_);
if (ret != Z_OK)
// can't throw exceptions in destructors
std::terminate();
zstream_initialized_ = false;
zstream_ended_ = true;
}
};
private:
constexpr static const std::size_t kReadHighWater = 2048;
void _init() {
stream_.avail_in = buf_.size() - buf_head_;
const std::size_t start_avail_in = stream_.avail_in;
stream_.next_in = reinterpret_cast<Bytef*>(buf_.data() + buf_head_);
int ret = inflateInit2(&stream_, 32);
if (ret != Z_OK) {
throw ZlibException {ret, stream_.msg};
}
buf_head_ += start_avail_in - stream_.avail_in;
_move_buf_backwards();
zstream_initialized_ = true;
zstream_ended_ = false;
}
void _fill_read_buffer() {
const std::size_t old_size = buf_.size();
if (old_size < kReadHighWater) {
buf_.resize(kReadHighWater);
const std::size_t read = inner_.read(tcb::span(buf_.data() + old_size, buf_.size() - old_size));
buf_.resize(old_size + read);
}
}
StreamSize _inflate(tcb::span<std::byte> out) {
if (!zstream_initialized_) {
_init();
}
if (zstream_ended_)
return 0;
const std::size_t out_size = out.size();
stream_.avail_in = buf_.size() - buf_head_;
const std::size_t start_avail_in = stream_.avail_in;
stream_.next_in = reinterpret_cast<Bytef*>(buf_.data() + buf_head_);
stream_.avail_out = out_size;
const std::size_t start_avail_out = stream_.avail_out;
stream_.next_out = reinterpret_cast<Bytef*>(out.data());
int ret = inflate(&stream_, Z_NO_FLUSH);
if (ret == Z_STREAM_END) {
zstream_ended_ = true;
} else if (ret != Z_OK && ret != Z_BUF_ERROR) {
throw ZlibException {ret, stream_.msg};
}
buf_head_ += start_avail_in - stream_.avail_in;
const std::size_t written = start_avail_out - stream_.avail_out;
_move_buf_backwards();
return written;
}
void _move_buf_backwards() {
if (buf_head_ == 0) {
return;
}
if (buf_head_ >= buf_.size()) {
buf_.clear();
buf_head_ = 0;
return;
}
auto end = std::move(buf_.begin() + buf_head_, buf_.end(), buf_.begin());
buf_.resize(end - buf_.begin());
buf_head_ = 0;
}
};
// Utility functions
template <typename I, typename O>
StreamSize pipe_all(I& input, O& output) {
std::vector<std::byte> buf;
StreamSize total_written = 0;
StreamSize read_this_time = 0;
do {
buf.clear();
buf.resize(2048);
read_this_time = input.read(tcb::make_span(buf));
buf.resize(read_this_time);
write_exact(output, tcb::make_span(buf));
total_written += read_this_time;
} while (read_this_time != 0);
return total_written;
}
template <typename I>
std::vector<std::byte> read_to_vec(I& input) {
VecStream out;
pipe_all(input, out);
return std::move(out.vector());
}
// Instantiated templates
extern template class ZlibInputStream<SpanStream>;
extern template class ZlibInputStream<VecStream>;
} // namespace srb2::io
#endif // __SRB2_IO_STREAMS_HPP__

2
thirdparty/CMakeLists.txt vendored
View file

@ -540,3 +540,5 @@ if(NOT "${SRB2_CONFIG_SYSTEM_LIBRARIES}")
target_include_directories(discord-rpc INTERFACE "${DiscordRPC_SOURCE_DIR}/include")
add_library(DiscordRPC::DiscordRPC ALIAS discord-rpc)
endif()
add_subdirectory(tcbrindle_span)

8
thirdparty/tcbrindle_span/CMakeLists.txt vendored Normal file
View file

@ -0,0 +1,8 @@
# https://github.com/tcbrindle/span/
# Portable implementation of C++20 std::span
# Boost License 1.0
add_library(tcbrindle_span INTERFACE include/tcb/span.hpp)
target_include_directories(tcbrindle_span INTERFACE include)
add_library(tcbrindle::span ALIAS tcbrindle_span)

618
thirdparty/tcbrindle_span/include/tcb/span.hpp vendored Normal file
View file

@ -0,0 +1,618 @@
/*
This is an implementation of C++20's std::span
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4820.pdf
*/
// Copyright Tristan Brindle 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file ../../LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef TCB_SPAN_HPP_INCLUDED
#define TCB_SPAN_HPP_INCLUDED
#include <array>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#ifndef TCB_SPAN_NO_EXCEPTIONS
// Attempt to discover whether we're being compiled with exception support
#if !(defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND))
#define TCB_SPAN_NO_EXCEPTIONS
#endif
#endif
#ifndef TCB_SPAN_NO_EXCEPTIONS
#include <cstdio>
#include <stdexcept>
#endif
// Various feature test macros
#ifndef TCB_SPAN_NAMESPACE_NAME
#define TCB_SPAN_NAMESPACE_NAME tcb
#endif
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#define TCB_SPAN_HAVE_CPP17
#endif
#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
#define TCB_SPAN_HAVE_CPP14
#endif
namespace TCB_SPAN_NAMESPACE_NAME {
// Establish default contract checking behavior
#if !defined(TCB_SPAN_THROW_ON_CONTRACT_VIOLATION) && \
!defined(TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION) && \
!defined(TCB_SPAN_NO_CONTRACT_CHECKING)
#if defined(NDEBUG) || !defined(TCB_SPAN_HAVE_CPP14)
#define TCB_SPAN_NO_CONTRACT_CHECKING
#else
#define TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION
#endif
#endif
#if defined(TCB_SPAN_THROW_ON_CONTRACT_VIOLATION)
struct contract_violation_error : std::logic_error {
explicit contract_violation_error(const char* msg) : std::logic_error(msg)
{}
};
inline void contract_violation(const char* msg)
{
throw contract_violation_error(msg);
}
#elif defined(TCB_SPAN_TERMINATE_ON_CONTRACT_VIOLATION)
[[noreturn]] inline void contract_violation(const char* /*unused*/)
{
std::terminate();
}
#endif
#if !defined(TCB_SPAN_NO_CONTRACT_CHECKING)
#define TCB_SPAN_STRINGIFY(cond) #cond
#define TCB_SPAN_EXPECT(cond) \
cond ? (void) 0 : contract_violation("Expected " TCB_SPAN_STRINGIFY(cond))
#else
#define TCB_SPAN_EXPECT(cond)
#endif
#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_inline_variables)
#define TCB_SPAN_INLINE_VAR inline
#else
#define TCB_SPAN_INLINE_VAR
#endif
#if defined(TCB_SPAN_HAVE_CPP14) || \
(defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
#define TCB_SPAN_HAVE_CPP14_CONSTEXPR
#endif
#if defined(TCB_SPAN_HAVE_CPP14_CONSTEXPR)
#define TCB_SPAN_CONSTEXPR14 constexpr
#else
#define TCB_SPAN_CONSTEXPR14
#endif
#if defined(TCB_SPAN_HAVE_CPP14_CONSTEXPR) && \
(!defined(_MSC_VER) || _MSC_VER > 1900)
#define TCB_SPAN_CONSTEXPR_ASSIGN constexpr
#else
#define TCB_SPAN_CONSTEXPR_ASSIGN
#endif
#if defined(TCB_SPAN_NO_CONTRACT_CHECKING)
#define TCB_SPAN_CONSTEXPR11 constexpr
#else
#define TCB_SPAN_CONSTEXPR11 TCB_SPAN_CONSTEXPR14
#endif
#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_deduction_guides)
#define TCB_SPAN_HAVE_DEDUCTION_GUIDES
#endif
#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_byte)
#define TCB_SPAN_HAVE_STD_BYTE
#endif
#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_array_constexpr)
#define TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC
#endif
#if defined(TCB_SPAN_HAVE_CONSTEXPR_STD_ARRAY_ETC)
#define TCB_SPAN_ARRAY_CONSTEXPR constexpr
#else
#define TCB_SPAN_ARRAY_CONSTEXPR
#endif
#ifdef TCB_SPAN_HAVE_STD_BYTE
using byte = std::byte;
#else
using byte = unsigned char;
#endif
#if defined(TCB_SPAN_HAVE_CPP17)
#define TCB_SPAN_NODISCARD [[nodiscard]]
#else
#define TCB_SPAN_NODISCARD
#endif
TCB_SPAN_INLINE_VAR constexpr std::size_t dynamic_extent = SIZE_MAX;
template <typename ElementType, std::size_t Extent = dynamic_extent>
class span;
namespace detail {
template <typename E, std::size_t S>
struct span_storage {
constexpr span_storage() noexcept = default;
constexpr span_storage(E* p_ptr, std::size_t /*unused*/) noexcept
: ptr(p_ptr)
{}
E* ptr = nullptr;
static constexpr std::size_t size = S;
};
template <typename E>
struct span_storage<E, dynamic_extent> {
constexpr span_storage() noexcept = default;
constexpr span_storage(E* p_ptr, std::size_t p_size) noexcept
: ptr(p_ptr), size(p_size)
{}
E* ptr = nullptr;
std::size_t size = 0;
};
// Reimplementation of C++17 std::size() and std::data()
#if defined(TCB_SPAN_HAVE_CPP17) || \
defined(__cpp_lib_nonmember_container_access)
using std::data;
using std::size;
#else
template <class C>
constexpr auto size(const C& c) -> decltype(c.size())
{
return c.size();
}
template <class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept
{
return N;
}
template <class C>
constexpr auto data(C& c) -> decltype(c.data())
{
return c.data();
}
template <class C>
constexpr auto data(const C& c) -> decltype(c.data())
{
return c.data();
}
template <class T, std::size_t N>
constexpr T* data(T (&array)[N]) noexcept
{
return array;
}
template <class E>
constexpr const E* data(std::initializer_list<E> il) noexcept
{
return il.begin();
}
#endif // TCB_SPAN_HAVE_CPP17
#if defined(TCB_SPAN_HAVE_CPP17) || defined(__cpp_lib_void_t)
using std::void_t;
#else
template <typename...>
using void_t = void;
#endif
template <typename T>
using uncvref_t =
typename std::remove_cv<typename std::remove_reference<T>::type>::type;
template <typename>
struct is_span : std::false_type {};
template <typename T, std::size_t S>
struct is_span<span<T, S>> : std::true_type {};
template <typename>
struct is_std_array : std::false_type {};
template <typename T, std::size_t N>
struct is_std_array<std::array<T, N>> : std::true_type {};
template <typename, typename = void>
struct has_size_and_data : std::false_type {};
template <typename T>
struct has_size_and_data<T, void_t<decltype(detail::size(std::declval<T>())),
decltype(detail::data(std::declval<T>()))>>
: std::true_type {};
template <typename C, typename U = uncvref_t<C>>
struct is_container {
static constexpr bool value =
!is_span<U>::value && !is_std_array<U>::value &&
!std::is_array<U>::value && has_size_and_data<C>::value;
};
template <typename T>
using remove_pointer_t = typename std::remove_pointer<T>::type;
template <typename, typename, typename = void>
struct is_container_element_type_compatible : std::false_type {};
template <typename T, typename E>
struct is_container_element_type_compatible<
T, E,
typename std::enable_if<
!std::is_same<
typename std::remove_cv<decltype(detail::data(std::declval<T>()))>::type,
void>::value &&
std::is_convertible<
remove_pointer_t<decltype(detail::data(std::declval<T>()))> (*)[],
E (*)[]>::value
>::type>
: std::true_type {};
template <typename, typename = size_t>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
} // namespace detail
template <typename ElementType, std::size_t Extent>
class span {
static_assert(std::is_object<ElementType>::value,
"A span's ElementType must be an object type (not a "
"reference type or void)");
static_assert(detail::is_complete<ElementType>::value,
"A span's ElementType must be a complete type (not a forward "
"declaration)");
static_assert(!std::is_abstract<ElementType>::value,
"A span's ElementType cannot be an abstract class type");
using storage_type = detail::span_storage<ElementType, Extent>;
public:
// constants and types
using element_type = ElementType;
using value_type = typename std::remove_cv<ElementType>::type;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using pointer = element_type*;
using const_pointer = const element_type*;
using reference = element_type&;
using const_reference = const element_type&;
using iterator = pointer;
using reverse_iterator = std::reverse_iterator<iterator>;
static constexpr size_type extent = Extent;
// [span.cons], span constructors, copy, assignment, and destructor
template <
std::size_t E = Extent,
typename std::enable_if<(E == dynamic_extent || E <= 0), int>::type = 0>
constexpr span() noexcept
{}
TCB_SPAN_CONSTEXPR11 span(pointer ptr, size_type count)
: storage_(ptr, count)
{
TCB_SPAN_EXPECT(extent == dynamic_extent || count == extent);
}
TCB_SPAN_CONSTEXPR11 span(pointer first_elem, pointer last_elem)
: storage_(first_elem, last_elem - first_elem)
{
TCB_SPAN_EXPECT(extent == dynamic_extent ||
last_elem - first_elem ==
static_cast<std::ptrdiff_t>(extent));
}
template <std::size_t N, std::size_t E = Extent,
typename std::enable_if<
(E == dynamic_extent || N == E) &&
detail::is_container_element_type_compatible<
element_type (&)[N], ElementType>::value,
int>::type = 0>
constexpr span(element_type (&arr)[N]) noexcept : storage_(arr, N)
{}
template <typename T, std::size_t N, std::size_t E = Extent,
typename std::enable_if<
(E == dynamic_extent || N == E) &&
detail::is_container_element_type_compatible<
std::array<T, N>&, ElementType>::value,
int>::type = 0>
TCB_SPAN_ARRAY_CONSTEXPR span(std::array<T, N>& arr) noexcept
: storage_(arr.data(), N)
{}
template <typename T, std::size_t N, std::size_t E = Extent,
typename std::enable_if<
(E == dynamic_extent || N == E) &&
detail::is_container_element_type_compatible<
const std::array<T, N>&, ElementType>::value,
int>::type = 0>
TCB_SPAN_ARRAY_CONSTEXPR span(const std::array<T, N>& arr) noexcept
: storage_(arr.data(), N)
{}
template <
typename Container, std::size_t E = Extent,
typename std::enable_if<
E == dynamic_extent && detail::is_container<Container>::value &&
detail::is_container_element_type_compatible<
Container&, ElementType>::value,
int>::type = 0>
constexpr span(Container& cont)
: storage_(detail::data(cont), detail::size(cont))
{}
template <
typename Container, std::size_t E = Extent,
typename std::enable_if<
E == dynamic_extent && detail::is_container<Container>::value &&
detail::is_container_element_type_compatible<
const Container&, ElementType>::value,
int>::type = 0>
constexpr span(const Container& cont)
: storage_(detail::data(cont), detail::size(cont))
{}
constexpr span(const span& other) noexcept = default;
template <typename OtherElementType, std::size_t OtherExtent,
typename std::enable_if<
(Extent == dynamic_extent || OtherExtent == dynamic_extent ||
Extent == OtherExtent) &&
std::is_convertible<OtherElementType (*)[],
ElementType (*)[]>::value,
int>::type = 0>
constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
: storage_(other.data(), other.size())
{}
~span() noexcept = default;
TCB_SPAN_CONSTEXPR_ASSIGN span&
operator=(const span& other) noexcept = default;
// [span.sub], span subviews
template <std::size_t Count>
TCB_SPAN_CONSTEXPR11 span<element_type, Count> first() const
{
TCB_SPAN_EXPECT(Count <= size());
return {data(), Count};
}
template <std::size_t Count>
TCB_SPAN_CONSTEXPR11 span<element_type, Count> last() const
{
TCB_SPAN_EXPECT(Count <= size());
return {data() + (size() - Count), Count};
}
template <std::size_t Offset, std::size_t Count = dynamic_extent>
using subspan_return_t =
span<ElementType, Count != dynamic_extent
? Count
: (Extent != dynamic_extent ? Extent - Offset
: dynamic_extent)>;
template <std::size_t Offset, std::size_t Count = dynamic_extent>
TCB_SPAN_CONSTEXPR11 subspan_return_t<Offset, Count> subspan() const
{
TCB_SPAN_EXPECT(Offset <= size() &&
(Count == dynamic_extent || Offset + Count <= size()));
return {data() + Offset,
Count != dynamic_extent ? Count : size() - Offset};
}
TCB_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
first(size_type count) const
{
TCB_SPAN_EXPECT(count <= size());
return {data(), count};
}
TCB_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
last(size_type count) const
{
TCB_SPAN_EXPECT(count <= size());
return {data() + (size() - count), count};
}
TCB_SPAN_CONSTEXPR11 span<element_type, dynamic_extent>
subspan(size_type offset, size_type count = dynamic_extent) const
{
TCB_SPAN_EXPECT(offset <= size() &&
(count == dynamic_extent || offset + count <= size()));
return {data() + offset,
count == dynamic_extent ? size() - offset : count};
}
// [span.obs], span observers
constexpr size_type size() const noexcept { return storage_.size; }
constexpr size_type size_bytes() const noexcept
{
return size() * sizeof(element_type);
}
TCB_SPAN_NODISCARD constexpr bool empty() const noexcept
{
return size() == 0;
}
// [span.elem], span element access
TCB_SPAN_CONSTEXPR11 reference operator[](size_type idx) const
{
TCB_SPAN_EXPECT(idx < size());
return *(data() + idx);
}
TCB_SPAN_CONSTEXPR11 reference front() const
{
TCB_SPAN_EXPECT(!empty());
return *data();
}
TCB_SPAN_CONSTEXPR11 reference back() const
{
TCB_SPAN_EXPECT(!empty());
return *(data() + (size() - 1));
}
constexpr pointer data() const noexcept { return storage_.ptr; }
// [span.iterators], span iterator support
constexpr iterator begin() const noexcept { return data(); }
constexpr iterator end() const noexcept { return data() + size(); }
TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rbegin() const noexcept
{
return reverse_iterator(end());
}
TCB_SPAN_ARRAY_CONSTEXPR reverse_iterator rend() const noexcept
{
return reverse_iterator(begin());
}
private:
storage_type storage_{};
};
#ifdef TCB_SPAN_HAVE_DEDUCTION_GUIDES
/* Deduction Guides */
template <class T, size_t N>
span(T (&)[N])->span<T, N>;
template <class T, size_t N>
span(std::array<T, N>&)->span<T, N>;
template <class T, size_t N>
span(const std::array<T, N>&)->span<const T, N>;
template <class Container>
span(Container&)->span<typename std::remove_reference<
decltype(*detail::data(std::declval<Container&>()))>::type>;
template <class Container>
span(const Container&)->span<const typename Container::value_type>;
#endif // TCB_HAVE_DEDUCTION_GUIDES
template <typename ElementType, std::size_t Extent>
constexpr span<ElementType, Extent>
make_span(span<ElementType, Extent> s) noexcept
{
return s;
}
template <typename T, std::size_t N>
constexpr span<T, N> make_span(T (&arr)[N]) noexcept
{
return {arr};
}
template <typename T, std::size_t N>
TCB_SPAN_ARRAY_CONSTEXPR span<T, N> make_span(std::array<T, N>& arr) noexcept
{
return {arr};
}
template <typename T, std::size_t N>
TCB_SPAN_ARRAY_CONSTEXPR span<const T, N>
make_span(const std::array<T, N>& arr) noexcept
{
return {arr};
}
template <typename Container>
constexpr span<typename std::remove_reference<
decltype(*detail::data(std::declval<Container&>()))>::type>
make_span(Container& cont)
{
return {cont};
}
template <typename Container>
constexpr span<const typename Container::value_type>
make_span(const Container& cont)
{
return {cont};
}
template <typename ElementType, std::size_t Extent>
span<const byte, ((Extent == dynamic_extent) ? dynamic_extent
: sizeof(ElementType) * Extent)>
as_bytes(span<ElementType, Extent> s) noexcept
{
return {reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
}
template <
class ElementType, size_t Extent,
typename std::enable_if<!std::is_const<ElementType>::value, int>::type = 0>
span<byte, ((Extent == dynamic_extent) ? dynamic_extent
: sizeof(ElementType) * Extent)>
as_writable_bytes(span<ElementType, Extent> s) noexcept
{
return {reinterpret_cast<byte*>(s.data()), s.size_bytes()};
}
template <std::size_t N, typename E, std::size_t S>
constexpr auto get(span<E, S> s) -> decltype(s[N])
{
return s[N];
}
} // namespace TCB_SPAN_NAMESPACE_NAME
namespace std {
template <typename ElementType, size_t Extent>
class tuple_size<TCB_SPAN_NAMESPACE_NAME::span<ElementType, Extent>>
: public integral_constant<size_t, Extent> {};
template <typename ElementType>
class tuple_size<TCB_SPAN_NAMESPACE_NAME::span<
ElementType, TCB_SPAN_NAMESPACE_NAME::dynamic_extent>>; // not defined
template <size_t I, typename ElementType, size_t Extent>
class tuple_element<I, TCB_SPAN_NAMESPACE_NAME::span<ElementType, Extent>> {
public:
static_assert(Extent != TCB_SPAN_NAMESPACE_NAME::dynamic_extent &&
I < Extent,
"");
using type = ElementType;
};
} // end namespace std
#endif // TCB_SPAN_HPP_INCLUDED