2437 lines
83 KiB
C++
2437 lines
83 KiB
C++
#pragma once
|
||
#define use_fastio
|
||
#ifdef use_fastio
|
||
#include "./fast_io/include/fast_io.h"
|
||
#endif
|
||
|
||
#include <bit>
|
||
#include <cassert>
|
||
#include <cmath>
|
||
#include <concepts>
|
||
#include <span>
|
||
#include <string>
|
||
#include <utility>
|
||
|
||
namespace na::nbt::v7 {
|
||
namespace impl {
|
||
enum class nbt_parse_error
|
||
{
|
||
end_of_file,
|
||
invalid
|
||
};
|
||
|
||
struct nbt_document;
|
||
|
||
namespace swapper {
|
||
template<typename T>
|
||
inline T& byte_as_type(std::byte* ptr) noexcept;
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_get(std::byte* ptr) noexcept;
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_make_native_get(std::byte* ptr) noexcept;
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_get_make_native(std::byte* ptr) noexcept;
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline void endian_make_native(std::byte* ptr) noexcept;
|
||
|
||
template<typename read_swapper, std::endian nbt_endian>
|
||
concept read_swapper_for_endian = requires(std::byte * &t)
|
||
{
|
||
read_swapper::template tag_byte<nbt_endian>(t);
|
||
read_swapper::template tag_short<nbt_endian>(t);
|
||
read_swapper::template tag_int<nbt_endian>(t);
|
||
read_swapper::template tag_long<nbt_endian>(t);
|
||
read_swapper::template tag_float<nbt_endian>(t);
|
||
read_swapper::template tag_double<nbt_endian>(t);
|
||
read_swapper::template tag_byte_array<nbt_endian>(t);
|
||
read_swapper::template tag_string<nbt_endian>(t);
|
||
read_swapper::template tag_int_array<nbt_endian>(t);
|
||
read_swapper::template tag_long_array<nbt_endian>(t);
|
||
};
|
||
template<typename read_swapper_t>
|
||
concept read_swapper =
|
||
read_swapper_for_endian<read_swapper_t, std::endian::big> &&
|
||
read_swapper_for_endian<read_swapper_t, std::endian::little>;
|
||
|
||
template<typename write_swapper, std::endian nbt_endian>
|
||
concept write_swapper_for_endian = requires(std::byte * &t)
|
||
{
|
||
write_swapper::template tag_byte<nbt_endian>(t);
|
||
write_swapper::template tag_short<nbt_endian>(t);
|
||
write_swapper::template tag_int<nbt_endian>(t);
|
||
write_swapper::template tag_long<nbt_endian>(t);
|
||
write_swapper::template tag_float<nbt_endian>(t);
|
||
write_swapper::template tag_double<nbt_endian>(t);
|
||
write_swapper::template tag_byte_array<nbt_endian>(t);
|
||
write_swapper::template tag_string<nbt_endian>(t);
|
||
write_swapper::template tag_int_array<nbt_endian>(t);
|
||
write_swapper::template tag_long_array<nbt_endian>(t);
|
||
};
|
||
template<typename write_swapper_t>
|
||
concept write_swapper =
|
||
write_swapper_for_endian<write_swapper_t, std::endian::big> &&
|
||
write_swapper_for_endian<write_swapper_t, std::endian::little>;
|
||
|
||
} // namespace swapper
|
||
namespace read_write {
|
||
template<bool in_place, bool bound_check, std::endian nbt_endian, swapper::read_swapper rswap>
|
||
[[nodiscard]] inline auto read(std::byte* source, std::size_t source_len) -> nbt_document;
|
||
|
||
} // namespace read_write
|
||
union mark_t
|
||
{
|
||
struct
|
||
{
|
||
uint32_t general_parrent_offset; // 4
|
||
uint32_t list_current_length; // 4
|
||
uint32_t list_total_length; // 4
|
||
uint16_t list_type; // 2
|
||
uint16_t general_is_compound; // 2
|
||
} cache;
|
||
struct
|
||
{
|
||
uint64_t flat_next_mark; // offset from this
|
||
std::byte* end;
|
||
} store;
|
||
};
|
||
|
||
struct nbt_document
|
||
{
|
||
mark_t* mark_m;
|
||
std::byte* source_m;
|
||
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
std::size_t mark_len; //可能小于 mark_m 已分配内存
|
||
std::size_t source_len; //可能小于 source_m 已分配内存
|
||
};
|
||
|
||
enum class nbt_type : ::std::uint8_t
|
||
{
|
||
tag_end = 0,
|
||
tag_byte = 1,
|
||
tag_short = 2,
|
||
tag_int = 3,
|
||
tag_long = 4,
|
||
tag_float = 5,
|
||
tag_double = 6,
|
||
tag_byte_array = 7,
|
||
tag_string = 8,
|
||
tag_list = 9,
|
||
tag_compound = 10,
|
||
tag_int_array = 11,
|
||
tag_long_array = 12
|
||
};
|
||
|
||
struct any_tag
|
||
{
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
|
||
#ifndef NDEBUG
|
||
nbt_type type;
|
||
#endif
|
||
};
|
||
|
||
struct nbt_list
|
||
{
|
||
struct iterator
|
||
{
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
|
||
std::int32_t index;
|
||
|
||
#ifndef NDEBUG
|
||
nbt_type type;
|
||
#endif
|
||
};
|
||
#ifndef NDEBUG
|
||
nbt_type element_type;
|
||
#endif
|
||
std::int32_t length;
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
};
|
||
|
||
struct nbt_compound
|
||
{
|
||
struct iterator
|
||
{
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
};
|
||
mark_t* mark;
|
||
std::byte* source;
|
||
};
|
||
|
||
namespace nbt_document_function {
|
||
|
||
/// <summary>
|
||
/// 释放 doc 所有的内存并置空所有指针.
|
||
/// </summary>
|
||
/// <param name="doc"></param>
|
||
inline void nbt_document_free(nbt_document* doc) noexcept
|
||
{
|
||
doc->source = nullptr;
|
||
doc->mark = nullptr;
|
||
if (doc->source_m != nullptr)
|
||
{
|
||
#ifdef use_fastio
|
||
fast_io::native_global_allocator::deallocate(doc->source_m);
|
||
#else
|
||
free(doc->source_m);
|
||
#endif
|
||
}
|
||
if (doc->mark_m != nullptr)
|
||
{
|
||
#ifdef use_fastio
|
||
fast_io::native_global_allocator::deallocate(doc->mark_m);
|
||
#else
|
||
free(doc->mark_m);
|
||
#endif
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 将 from 中已分配内存的所有权转移到 to.
|
||
/// to 中不能所有已分配内存，否则会导致泄漏.
|
||
/// 移动之后，from 中所有指针被置空.
|
||
/// </summary>
|
||
/// <param name="from"></param>
|
||
/// <param name="to"></param>
|
||
inline void nbt_document_move(nbt_document* from, nbt_document* to) noexcept
|
||
{
|
||
*to = *from;
|
||
from->mark_m = nullptr;
|
||
from->source_m = nullptr;
|
||
from->mark = nullptr;
|
||
from->source = nullptr;
|
||
}
|
||
|
||
inline const std::u8string_view nbt_document_root_key(const nbt_document* doc) noexcept
|
||
{
|
||
if (static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(doc->source)) == nbt_type::tag_end) [[unlikely]]
|
||
{
|
||
return {};
|
||
}
|
||
return std::u8string_view(
|
||
reinterpret_cast<char8_t*>(doc->source + sizeof(std::uint8_t)),
|
||
swapper::byte_as_type<std::uint16_t>(doc->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline any_tag nbt_document_root_value(const nbt_document* doc) noexcept
|
||
{
|
||
return any_tag{
|
||
.mark = doc->mark,
|
||
.source = doc->source + sizeof(std::uint8_t) + sizeof(std::uint16_t) + swapper::byte_as_type<std::uint16_t>(doc->source + sizeof(std::uint8_t))
|
||
#ifndef NDEBUG
|
||
,
|
||
.type = static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(doc->source))
|
||
#endif
|
||
};
|
||
}
|
||
} // namespace nbt_document_function
|
||
namespace any_tag_function {
|
||
|
||
inline auto any_tag_get_end(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_end);
|
||
return;
|
||
}
|
||
|
||
inline auto any_tag_get_byte(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_byte);
|
||
return swapper::byte_as_type<std::int8_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_short(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_short);
|
||
return swapper::byte_as_type<std::int16_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_int(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_int);
|
||
return swapper::byte_as_type<std::int32_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_long(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_long);
|
||
return swapper::byte_as_type<std::int64_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_float(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_float);
|
||
return swapper::byte_as_type<std::float_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_double(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_double);
|
||
return swapper::byte_as_type<std::double_t>(tag->source);
|
||
}
|
||
|
||
inline auto any_tag_get_byte_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_byte_array);
|
||
return std::span<const std::int8_t, std::dynamic_extent>(reinterpret_cast<std::int8_t*>(tag->source + sizeof(std::int32_t)), swapper::byte_as_type<std::int32_t>(tag->source));
|
||
}
|
||
|
||
inline auto any_tag_get_string(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_string);
|
||
return std::u8string_view(reinterpret_cast<char8_t*>(tag->source + sizeof(std::uint16_t)), swapper::byte_as_type<std::uint16_t>(tag->source));
|
||
}
|
||
|
||
inline auto any_tag_get_list_end(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_end);
|
||
return;
|
||
}
|
||
|
||
inline auto any_tag_get_list_byte(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_byte);
|
||
return std::span<std::int8_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::int8_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_short(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_short);
|
||
return std::span<std::int16_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::int16_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_int(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_int);
|
||
return std::span<std::int32_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::int32_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_long(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_long);
|
||
return std::span<std::int64_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::int64_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_float(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_float);
|
||
return std::span<std::float_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::float_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_double(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_double);
|
||
return std::span<std::double_t, std::dynamic_extent>(
|
||
reinterpret_cast<std::double_t*>(tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)),
|
||
swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)));
|
||
}
|
||
|
||
inline auto any_tag_get_list_byte_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_byte_array);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_byte_array,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_list_string(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_string);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_string,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_list_list(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_list);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_list,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_list_compound(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_compound);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_compound,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_list_int_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_int_array);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_int_array,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_list_long_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_list);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(tag->source)) == nbt_type::tag_long_array);
|
||
return nbt_list{
|
||
#ifndef NDEBUG
|
||
.element_type = nbt_type::tag_long_array,
|
||
#endif
|
||
.length = swapper::byte_as_type<std::int32_t>(tag->source + sizeof(std::uint8_t)),
|
||
.mark = tag->mark,
|
||
.source = tag->source + sizeof(std::uint8_t) + sizeof(std::int32_t)};
|
||
}
|
||
|
||
inline auto any_tag_get_compound(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_compound);
|
||
return nbt_compound{
|
||
.mark = tag->mark,
|
||
.source = tag->source};
|
||
}
|
||
|
||
inline auto any_tag_get_int_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_int_array);
|
||
return std::span<const std::int32_t, std::dynamic_extent>(reinterpret_cast<std::int32_t*>(tag->source + sizeof(std::int32_t)), swapper::byte_as_type<std::int32_t>(tag->source));
|
||
}
|
||
|
||
inline auto any_tag_get_long_array(const any_tag* tag) noexcept
|
||
{
|
||
assert(tag->type == nbt_type::tag_long_array);
|
||
return std::span<const std::int64_t, std::dynamic_extent>(reinterpret_cast<std::int64_t*>(tag->source + sizeof(std::int32_t)), swapper::byte_as_type<std::int32_t>(tag->source));
|
||
}
|
||
|
||
inline auto any_tag_valid(const any_tag* tag) noexcept
|
||
{
|
||
return tag->mark != nullptr && tag->source != nullptr
|
||
#ifndef NDEBUG
|
||
&& tag->type == nbt_type::tag_end
|
||
#endif
|
||
;
|
||
}
|
||
|
||
} // namespace any_tag_function
|
||
namespace nbt_compound_function {
|
||
inline auto nbt_compound_iterator_begin(const nbt_compound* comp) noexcept
|
||
{
|
||
return nbt_compound::iterator{
|
||
.mark = comp->mark + 1,
|
||
.source = comp->source};
|
||
}
|
||
inline auto nbt_compound_iterator_end(const nbt_compound* comp) noexcept
|
||
{
|
||
return nbt_compound::iterator{
|
||
.mark = nullptr,
|
||
.source = comp->mark->store.end - 1 //at tag_end
|
||
};
|
||
}
|
||
inline void nbt_compound_iterator_next(nbt_compound::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
auto type = static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(iter->source));
|
||
assert(type != nbt_type::tag_end);
|
||
auto len = swapper::byte_as_type<::std::uint16_t>(iter->source + 1); //name length
|
||
|
||
switch (type)
|
||
{
|
||
case nbt_type::tag_byte:
|
||
iter->source = iter->source + 1 + 2 + len + 1;
|
||
return;
|
||
case nbt_type::tag_short:
|
||
iter->source = iter->source + 1 + 2 + len + 2;
|
||
return;
|
||
case nbt_type::tag_int:
|
||
iter->source = iter->source + 1 + 2 + len + 4;
|
||
return;
|
||
case nbt_type::tag_long:
|
||
iter->source = iter->source + 1 + 2 + len + 8;
|
||
return;
|
||
case nbt_type::tag_float:
|
||
iter->source = iter->source + 1 + 2 + len + 4;
|
||
return;
|
||
case nbt_type::tag_double:
|
||
iter->source = iter->source + 1 + 2 + len + 8;
|
||
return;
|
||
case nbt_type::tag_string:
|
||
iter->source = iter->source + 1 + 2 + len; //payload begin
|
||
iter->source = iter->source + 2 + swapper::byte_as_type<::std::uint16_t>(iter->source);
|
||
return;
|
||
case nbt_type::tag_byte_array:
|
||
iter->source = iter->source + 1 + 2 + len; //payload begin
|
||
iter->source = iter->source + 4 + swapper::byte_as_type<::std::int32_t>(iter->source);
|
||
return;
|
||
case nbt_type::tag_int_array:
|
||
iter->source = iter->source + 1 + 2 + len; //payload begin
|
||
iter->source = iter->source + 4 + static_cast<std::ptrdiff_t>(swapper::byte_as_type<::std::int32_t>(iter->source)) * 4;
|
||
return;
|
||
case nbt_type::tag_long_array:
|
||
iter->source = iter->source + 1 + 2 + len; //payload begin
|
||
iter->source = iter->source + 4 + static_cast<std::ptrdiff_t>(swapper::byte_as_type<::std::int32_t>(iter->source)) * 8;
|
||
return;
|
||
case nbt_type::tag_list:
|
||
case nbt_type::tag_compound:
|
||
iter->source = iter->mark->store.end;
|
||
iter->mark = iter->mark + iter->mark->store.flat_next_mark;
|
||
return;
|
||
default:
|
||
std::unreachable();
|
||
}
|
||
}
|
||
|
||
inline bool nbt_compound_iter_equal(const nbt_compound::iterator* left, const nbt_compound::iterator* right)
|
||
{
|
||
assert(left->source != nullptr);
|
||
assert(right->source != nullptr);
|
||
return left->source == right->source;
|
||
}
|
||
inline const std::u8string_view nbt_compound_iter_key(const nbt_compound::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(iter->source)) != nbt_type::tag_end);
|
||
return std::u8string_view(reinterpret_cast<char8_t*>(iter->source + sizeof(std::uint8_t) + sizeof(std::uint16_t)), swapper::byte_as_type<std::uint16_t>(iter->source + sizeof(std::uint8_t)));
|
||
}
|
||
inline any_tag nbt_compound_iter_value(const nbt_compound::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(iter->source)) != nbt_type::tag_end);
|
||
return any_tag{
|
||
.mark = iter->mark,
|
||
.source = iter->source + sizeof(std::uint8_t) + sizeof(std::uint16_t) + swapper::byte_as_type<std::uint16_t>(iter->source + sizeof(std::uint8_t))
|
||
#ifndef NDEBUG
|
||
,
|
||
.type = static_cast<nbt_type>(swapper::byte_as_type<std::uint8_t>(iter->source))
|
||
#endif
|
||
};
|
||
}
|
||
|
||
inline auto nbt_compound_find_value(const std::u8string_view key, const nbt_compound::iterator* begin, const nbt_compound::iterator* end) noexcept
|
||
{
|
||
for (auto iter{*begin}; !nbt_compound_iter_equal(std::addressof(iter), end); nbt_compound_iterator_next(std::addressof(iter)))
|
||
{
|
||
if (nbt_compound_iter_key(std::addressof(iter)).compare(key) == 0)
|
||
{
|
||
return iter;
|
||
}
|
||
}
|
||
return *end;
|
||
}
|
||
|
||
inline auto nbt_compound_find_value(const nbt_compound* comp, const std::u8string_view key) noexcept
|
||
{
|
||
auto begin{nbt_compound_iterator_begin(comp)};
|
||
auto end{nbt_compound_iterator_end(comp)};
|
||
return nbt_compound_find_value(key, std::addressof(begin), std::addressof(end));
|
||
}
|
||
} // namespace nbt_compound_function
|
||
namespace nbt_list_function {
|
||
inline auto nbt_list_iterator_begin(const nbt_list* list) noexcept
|
||
{
|
||
return nbt_list::iterator{
|
||
.mark = list->mark + 1,
|
||
.source = list->source,
|
||
.index = 0
|
||
#ifndef NDEBUG
|
||
,
|
||
.type = list->element_type
|
||
#endif
|
||
};
|
||
}
|
||
inline auto nbt_list_iterator_end(const nbt_list* list) noexcept
|
||
{
|
||
return nbt_list::iterator{
|
||
.mark = nullptr,
|
||
.source = list->mark->store.end,
|
||
.index = list->length};
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_end(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_end);
|
||
|
||
iter->index++;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_byte(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_byte);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 1;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_short(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_short);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 2;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_int(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_int);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 4;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_long(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_long);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 8;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_float(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_float);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 4;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_double(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_double);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 8;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_string(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_string);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 2 + swapper::byte_as_type<::std::uint16_t>(iter->source);
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_byte_array(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_byte_array);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 4 + swapper::byte_as_type<::std::int32_t>(iter->source);
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_int_array(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_int_array);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 4 + swapper::byte_as_type<::std::int32_t>(iter->source) * 4;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_long_array(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_long_array);
|
||
|
||
iter->index++;
|
||
iter->source = iter->source + 4 + swapper::byte_as_type<::std::int32_t>(iter->source) * 8;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_list(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_list);
|
||
|
||
iter->index++;
|
||
iter->source = iter->mark->store.end;
|
||
iter->mark = iter->mark + iter->mark->store.flat_next_mark;
|
||
return;
|
||
}
|
||
|
||
inline void nbt_list_iterator_next_compound(nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
assert(iter->type == nbt_type::tag_compound);
|
||
|
||
iter->index++;
|
||
iter->source = iter->mark->store.end;
|
||
iter->mark = iter->mark + iter->mark->store.flat_next_mark;
|
||
return;
|
||
}
|
||
|
||
inline bool nbt_list_iter_equal(const nbt_list::iterator* left, const nbt_list::iterator* right)
|
||
{
|
||
assert(left->source != nullptr);
|
||
assert(right->source != nullptr);
|
||
return left->source == right->source;
|
||
}
|
||
inline any_tag nbt_list_iter_value(const nbt_list::iterator* iter) noexcept
|
||
{
|
||
assert(iter->mark != nullptr);
|
||
assert(iter->source != nullptr);
|
||
return any_tag{
|
||
.mark = iter->mark,
|
||
.source = iter->source
|
||
#ifndef NDEBUG
|
||
,
|
||
.type = iter->type
|
||
#endif
|
||
};
|
||
}
|
||
|
||
inline auto nbt_list_find_value_end(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_end(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_byte(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_byte(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_short(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_short(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_int(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_int(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_long(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_long(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_float(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_float(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_double(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_double(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_byte_array(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_byte_array(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_string(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_string(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_list(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_list(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_compound(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_compound(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_int_array(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_int_array(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_long_array(std::int32_t index, const nbt_list::iterator* begin, const nbt_list::iterator* end) noexcept
|
||
{
|
||
auto iter{*begin};
|
||
while (index--)
|
||
{
|
||
nbt_list_iterator_next_long_array(std::addressof(iter));
|
||
}
|
||
return iter;
|
||
}
|
||
|
||
inline auto nbt_list_find_value_end(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_end);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_end(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_byte(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_byte);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_byte(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_short(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_short);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_short(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_int(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_int);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_int(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_long(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_long);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_long(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_float(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_float);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_float(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_double(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_double);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_double(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_byte_array(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_byte_array);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_byte_array(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_string(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_string);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_string(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_list(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_list);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_list(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_compound(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_compound);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_compound(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_int_array(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_int_array);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_int_array(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
inline auto nbt_list_find_value_long_array(const nbt_list* list, std::int32_t index) noexcept
|
||
{
|
||
assert(list->mark != nullptr);
|
||
assert(list->source != nullptr);
|
||
assert(list->element_type == nbt_type::tag_long_array);
|
||
auto begin{nbt_list_iterator_begin(list)};
|
||
auto end{nbt_list_iterator_end(list)};
|
||
if (index >= list->length)
|
||
{
|
||
return end;
|
||
}
|
||
return nbt_list_find_value_long_array(index, std::addressof(begin), std::addressof(end));
|
||
}
|
||
|
||
} // namespace nbt_list_function
|
||
namespace swapper {
|
||
|
||
template<typename T>
|
||
inline T& byte_as_type(std::byte* ptr) noexcept
|
||
{
|
||
return *reinterpret_cast<T*>(ptr);
|
||
}
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_get(std::byte* ptr) noexcept
|
||
{
|
||
if constexpr (nbt_endian == std::endian::big)
|
||
{
|
||
return fast_io::big_endian(byte_as_type<std::make_unsigned_t<T>>(ptr));
|
||
}
|
||
else
|
||
{
|
||
return fast_io::little_endian(byte_as_type<std::make_unsigned_t<T>>(ptr));
|
||
}
|
||
}
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_make_native_get(std::byte* ptr) noexcept
|
||
{
|
||
using unsigned_T = std::make_unsigned_t<T>;
|
||
T& t = byte_as_type<T>(ptr);
|
||
if constexpr (nbt_endian == std::endian::big)
|
||
{
|
||
t = static_cast<T>(fast_io::big_endian(static_cast<unsigned_T>(t)));
|
||
}
|
||
else
|
||
{
|
||
t = static_cast<T>(fast_io::little_endian(static_cast<unsigned_T>(t)));
|
||
}
|
||
return t;
|
||
}
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline T endian_get_make_native(std::byte* ptr) noexcept
|
||
{
|
||
using unsigned_T = std::make_unsigned_t<T>;
|
||
T& t = byte_as_type<T>(ptr);
|
||
T ret = t;
|
||
if constexpr (nbt_endian == std::endian::big)
|
||
{
|
||
t = static_cast<T>(fast_io::big_endian(static_cast<unsigned_T>(t)));
|
||
}
|
||
else
|
||
{
|
||
t = static_cast<T>(fast_io::little_endian(static_cast<unsigned_T>(t)));
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
template<typename T, std::endian nbt_endian>
|
||
requires(nbt_endian == std::endian::big || nbt_endian == std::endian::little) inline void endian_make_native(std::byte* ptr) noexcept
|
||
{
|
||
using unsigned_T = std::make_unsigned_t<T>;
|
||
unsigned_T& t = byte_as_type<unsigned_T>(ptr);
|
||
if constexpr (nbt_endian == std::endian::big)
|
||
{
|
||
t = fast_io::big_endian(t);
|
||
}
|
||
else
|
||
{
|
||
t = fast_io::little_endian(t);
|
||
}
|
||
return;
|
||
}
|
||
|
||
struct default_read_swapper
|
||
{
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_byte(std::byte*& current_pos) noexcept
|
||
{
|
||
current_pos += (sizeof(std::int8_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_short(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint16_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int16_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_int(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint32_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int32_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_long(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint64_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int64_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_float(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint32_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::float_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_double(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint64_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::double_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_byte_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_make_native_get<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
current_pos += sizeof(std::int8_t) * len;
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_string(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_make_native_get<std::uint16_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::uint16_t);
|
||
current_pos += sizeof(char) * len;
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_int_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_make_native_get<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
if constexpr (nbt_endian == std::endian::native)
|
||
{
|
||
current_pos += sizeof(std::int32_t) * len;
|
||
}
|
||
else
|
||
{
|
||
for (std::int32_t _index = 0; _index < len; _index++)
|
||
{
|
||
endian_make_native<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
}
|
||
}
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_long_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_make_native_get<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
current_pos += sizeof(std::int32_t);
|
||
if constexpr (nbt_endian == std::endian::native)
|
||
{
|
||
current_pos += sizeof(std::int64_t) * len;
|
||
}
|
||
else
|
||
{
|
||
for (std::int32_t _index = 0; _index < len; _index++)
|
||
{
|
||
endian_make_native<std::int64_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int64_t);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
struct default_write_swapper
|
||
{
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_byte(std::byte*& current_pos) noexcept
|
||
{
|
||
current_pos += (sizeof(std::int8_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_short(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint16_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int16_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_int(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint32_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int32_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_long(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint64_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::int64_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_float(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint32_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::float_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_double(std::byte*& current_pos) noexcept
|
||
{
|
||
endian_make_native<std::uint64_t, nbt_endian>(current_pos);
|
||
current_pos += (sizeof(std::double_t));
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_byte_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_get_make_native<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
current_pos += sizeof(std::int8_t) * len;
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_string(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_get_make_native<std::uint16_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::uint16_t);
|
||
current_pos += sizeof(char) * len;
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_int_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_get_make_native<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
//current_pos += sizeof(std::int32_t) * len;
|
||
for (std::int32_t _index = 0; _index < len; _index++)
|
||
{
|
||
endian_make_native<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
}
|
||
}
|
||
template<std::endian nbt_endian>
|
||
static constexpr inline void tag_long_array(std::byte*& current_pos) noexcept
|
||
{
|
||
auto len = endian_get_make_native<std::int32_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int32_t);
|
||
//current_pos += sizeof(std::int64_t) * len;
|
||
for (std::int32_t _index = 0; _index < len; _index++)
|
||
{
|
||
endian_make_native<std::int64_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::int64_t);
|
||
}
|
||
}
|
||
};
|
||
|
||
} // namespace swapper
|
||
namespace read_write {
|
||
|
||
template<bool in_place = true, bool bound_check = false, std::endian nbt_endian = std::endian::big, swapper::read_swapper rswap = swapper::default_read_swapper>
|
||
[[nodiscard]] inline auto read(std::byte* source, std::size_t source_len) -> nbt_document
|
||
{
|
||
#define bound_check_return(pos) \
|
||
if ((pos) > source_len) [[unlikely]] \
|
||
{ \
|
||
throw nbt_parse_error::end_of_file; \
|
||
}
|
||
|
||
nbt_document t{};
|
||
if constexpr (in_place)
|
||
{
|
||
t.source_m = nullptr;
|
||
t.source = source;
|
||
t.source_len = source_len;
|
||
}
|
||
else
|
||
{
|
||
t.source_m = static_cast<std::byte*>(fast_io::native_global_allocator::allocate(source_len));
|
||
t.source = t.source_m;
|
||
t.source_len = source_len;
|
||
fast_io::freestanding::non_overlapped_copy_n(source, source_len, t.source);
|
||
}
|
||
auto src{t.source};
|
||
std::size_t readed_length{0};
|
||
|
||
auto current_pos{src + 1}; //read first byte (id), +1
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 1;
|
||
bound_check_return(readed_length);
|
||
}
|
||
if (swapper::endian_get<std::uint8_t, nbt_endian>(src) != 0) [[likely]] //is tag_end, ignore tag name and payload
|
||
{
|
||
//read tag name
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += sizeof(std::uint16_t);
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::uint16_t, nbt_endian>(src + 1);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
std::uint16_t len = swapper::endian_make_native_get<std::uint16_t, nbt_endian>(src + 1); //read name length
|
||
current_pos += sizeof(std::uint16_t);
|
||
current_pos += len; // read name, +2 +length*1
|
||
}
|
||
switch (swapper::endian_get<std::uint8_t, nbt_endian>(src))
|
||
{
|
||
case 1: //tag_byte
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 1;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_byte<nbt_endian>(current_pos);
|
||
break;
|
||
case 2: //tag_short
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 2;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_short<nbt_endian>(current_pos);
|
||
break;
|
||
case 3: //tag_int
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_int<nbt_endian>(current_pos);
|
||
break;
|
||
case 4: //tag_long
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 8;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_long<nbt_endian>(current_pos);
|
||
break;
|
||
case 5: //tag_float
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_float<nbt_endian>(current_pos);
|
||
break;
|
||
case 6: //tag_double
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 8;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_double<nbt_endian>(current_pos);
|
||
break;
|
||
case 7: //tag_byte_array
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_byte_array<nbt_endian>(current_pos);
|
||
break;
|
||
case 8: //tag_string
|
||
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 2;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::uint16_t, nbt_endian>(current_pos);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_string<nbt_endian>(current_pos);
|
||
break;
|
||
case 9: //tag_list
|
||
goto general_start;
|
||
case 10: //tag_compound
|
||
goto general_start;
|
||
case 11: //tag_int_array
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len * sizeof(std::int32_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_int_array<nbt_endian>(current_pos);
|
||
break;
|
||
case 12: //tag_long_array
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len * sizeof(std::int64_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_long_array<nbt_endian>(current_pos);
|
||
break;
|
||
default:
|
||
throw nbt_parse_error::invalid;
|
||
}
|
||
}
|
||
t.mark_m = nullptr;
|
||
t.mark = t.mark_m;
|
||
t.mark_len = 0;
|
||
return t;
|
||
general_start:
|
||
using mark = mark_t;
|
||
std::size_t alc_len{static_cast<std::size_t>(t.source_len) / 32 /*todo: magic number*/ + 4 /*avoid zero*/};
|
||
mark* mark_hdr{static_cast<mark*>(fast_io::native_global_allocator::allocate(alc_len * sizeof(mark)))}; //first element of mark array
|
||
mark* mark_end{mark_hdr + alc_len}; //end+1 of mark array
|
||
mark* use_end{mark_hdr}; //last element used
|
||
mark* _mark_tmp{nullptr}; //tmp
|
||
mark* current{use_end}; //current container
|
||
mark* parent{use_end}; //parent container
|
||
|
||
current->cache.general_parrent_offset = 0;
|
||
|
||
if (swapper::endian_get<std::uint8_t, nbt_endian>(src) == 9) //list
|
||
{
|
||
goto list_general_begin;
|
||
}
|
||
else //compound
|
||
{
|
||
goto comp_general_begin;
|
||
}
|
||
|
||
comp_begin:
|
||
parent = current;
|
||
use_end++;
|
||
if (use_end > mark_end) [[unlikely]]
|
||
{
|
||
alc_len += alc_len / 2;
|
||
if (std::is_constant_evaluated())
|
||
{
|
||
_mark_tmp = reinterpret_cast<mark*>(fast_io::native_global_allocator::reallocate_n(mark_hdr, (mark_end - mark_hdr) * sizeof(mark), alc_len * sizeof(mark)));
|
||
}
|
||
else
|
||
{
|
||
_mark_tmp = reinterpret_cast<mark*>(fast_io::native_global_allocator::reallocate(mark_hdr, alc_len * sizeof(mark))); //reallocate should make sure that the allocation is successful.
|
||
}
|
||
use_end = _mark_tmp + (use_end - mark_hdr);
|
||
parent = _mark_tmp + (parent - mark_hdr);
|
||
mark_hdr = _mark_tmp;
|
||
mark_end = _mark_tmp + alc_len;
|
||
}
|
||
current = use_end;
|
||
comp_general_begin:
|
||
current->cache.general_parrent_offset = static_cast<std::uint32_t>(use_end - parent);
|
||
current->cache.general_is_compound = 1;
|
||
// goto comp_item_begin
|
||
comp_item_begin:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length++;
|
||
bound_check_return(readed_length);
|
||
}
|
||
const std::uint8_t id{swapper::endian_get<std::uint8_t, nbt_endian>(current_pos)};
|
||
current_pos++;
|
||
if (id == 0) [[unlikely]]
|
||
{
|
||
goto comp_end;
|
||
}
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += sizeof(std::uint16_t);
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::uint16_t, nbt_endian>(current_pos);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
auto len = swapper::endian_make_native_get<std::uint16_t, nbt_endian>(current_pos);
|
||
current_pos += sizeof(std::uint16_t);
|
||
current_pos += (len * sizeof(char));
|
||
switch (id)
|
||
{
|
||
case 1:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 1;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_byte<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 2;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_short<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_int<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 8;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_long<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 5:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_float<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 6:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 8;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_double<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 7:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto arrlen = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += arrlen;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_byte_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 8:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 2;
|
||
bound_check_return(readed_length);
|
||
auto arrlen = swapper::endian_get<std::uint16_t, nbt_endian>(current_pos);
|
||
readed_length += arrlen;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_string<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 9:
|
||
{
|
||
goto list_begin;
|
||
}
|
||
case 10:
|
||
{
|
||
goto comp_begin;
|
||
}
|
||
case 11:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
std::size_t arrlen = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += arrlen * sizeof(std::int32_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_int_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 12:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
std::size_t arrlen = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += arrlen * sizeof(std::int64_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_long_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
default:
|
||
fast_io::native_global_allocator::deallocate_n(mark_hdr, alc_len * sizeof(mark));
|
||
throw nbt_parse_error::invalid;
|
||
};
|
||
goto comp_item_begin;
|
||
}
|
||
comp_end:
|
||
if (current->cache.general_parrent_offset == 0) [[unlikely]]
|
||
{
|
||
current->store.end = current_pos;
|
||
current->store.flat_next_mark = use_end - current + 1;
|
||
goto read_finish;
|
||
}
|
||
current->store.end = current_pos;
|
||
current->store.flat_next_mark = use_end - current + 1;
|
||
current = parent;
|
||
parent = parent - (parent->cache.general_parrent_offset);
|
||
if (current->cache.general_is_compound == 1)
|
||
{
|
||
goto comp_item_begin;
|
||
}
|
||
else
|
||
{
|
||
goto list_item_begin;
|
||
}
|
||
list_begin:
|
||
parent = current;
|
||
use_end++;
|
||
if (use_end > mark_end) [[unlikely]]
|
||
{
|
||
alc_len += alc_len / 2;
|
||
if (std::is_constant_evaluated())
|
||
{
|
||
#ifdef use_fastio
|
||
_mark_tmp = reinterpret_cast<mark*>(fast_io::native_global_allocator::reallocate_n(mark_hdr, (mark_end - mark_hdr) * sizeof(mark), alc_len * sizeof(mark)));
|
||
#else
|
||
_mark_tmp = reinterpret_cast<mark*>(realloc(mark_hdr, (mark_end - mark_hdr) * sizeof(mark), alc_len * sizeof(mark)));
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
_mark_tmp = reinterpret_cast<mark*>(fast_io::native_global_allocator::reallocate(mark_hdr, alc_len * sizeof(mark))); //reallocate should make sure that the allocation is successful.
|
||
}
|
||
use_end = _mark_tmp + (use_end - mark_hdr);
|
||
parent = _mark_tmp + (parent - mark_hdr);
|
||
mark_hdr = _mark_tmp;
|
||
mark_end = _mark_tmp + alc_len;
|
||
}
|
||
current = use_end;
|
||
list_general_begin:
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length++;
|
||
readed_length += sizeof(std::uint32_t);
|
||
bound_check_return(readed_length);
|
||
auto id = swapper::endian_get<std::uint8_t, nbt_endian>(current_pos);
|
||
if (id >= 0 && id <= 6)
|
||
{
|
||
const std::size_t len = swapper::endian_get<std::uint32_t, nbt_endian>(current_pos + 1);
|
||
switch (id)
|
||
{
|
||
case 0:
|
||
break;
|
||
case 1:
|
||
readed_length += len;
|
||
break;
|
||
case 2:
|
||
readed_length += len * 2;
|
||
break;
|
||
case 3:
|
||
readed_length += len * 4;
|
||
break;
|
||
case 4:
|
||
readed_length += len * 8;
|
||
break;
|
||
case 5:
|
||
readed_length += len * 4;
|
||
break;
|
||
case 6:
|
||
readed_length += len * 8;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
bound_check_return(readed_length);
|
||
}
|
||
}
|
||
current->cache.list_type = swapper::endian_get<std::uint8_t, nbt_endian>(current_pos);
|
||
current->cache.general_parrent_offset = static_cast<std::uint32_t>(current - parent);
|
||
current->cache.general_is_compound = 0;
|
||
current_pos++;
|
||
current->cache.list_total_length = swapper::endian_make_native_get<std::uint32_t, nbt_endian>(current_pos);
|
||
current->cache.list_current_length = 0;
|
||
current_pos += sizeof(std::uint32_t);
|
||
goto list_item_begin;
|
||
list_item_begin:
|
||
if (current->cache.list_current_length >= current->cache.list_total_length) [[unlikely]]
|
||
{
|
||
goto list_end;
|
||
}
|
||
|
||
current->cache.list_current_length++;
|
||
switch (current->cache.list_type)
|
||
{
|
||
case 0:
|
||
{
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
rswap::template tag_byte<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
rswap::template tag_short<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
rswap::template tag_int<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
rswap::template tag_long<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 5:
|
||
{
|
||
rswap::template tag_float<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 6:
|
||
{
|
||
rswap::template tag_double<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 7:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_byte_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 8:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 2;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::uint16_t, nbt_endian>(current_pos);
|
||
readed_length += len;
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_string<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 9:
|
||
{
|
||
goto list_begin;
|
||
}
|
||
case 10:
|
||
{
|
||
goto comp_begin;
|
||
}
|
||
case 11:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len * sizeof(std::int32_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_int_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
case 12:
|
||
{
|
||
if constexpr (bound_check)
|
||
{
|
||
readed_length += 4;
|
||
bound_check_return(readed_length);
|
||
auto len = swapper::endian_get<std::int32_t, nbt_endian>(current_pos);
|
||
readed_length += len * sizeof(std::int64_t);
|
||
bound_check_return(readed_length);
|
||
}
|
||
rswap::template tag_long_array<nbt_endian>(current_pos);
|
||
break;
|
||
}
|
||
default:
|
||
fast_io::native_global_allocator::deallocate_n(mark_hdr, alc_len * sizeof(mark));
|
||
throw nbt_parse_error::invalid;
|
||
};
|
||
goto list_item_begin;
|
||
list_end:
|
||
if (current->cache.general_parrent_offset == 0) [[unlikely]]
|
||
{
|
||
current->store.end = current_pos;
|
||
current->store.flat_next_mark = use_end - current + 1;
|
||
goto read_finish;
|
||
}
|
||
current->store.end = current_pos;
|
||
current->store.flat_next_mark = use_end - current + 1;
|
||
current = parent;
|
||
parent = parent - (parent->cache.general_parrent_offset);
|
||
if (current->cache.general_is_compound == 1)
|
||
{
|
||
goto comp_item_begin;
|
||
}
|
||
else
|
||
{
|
||
goto list_item_begin;
|
||
}
|
||
|
||
read_finish:
|
||
t.mark_m = mark_hdr;
|
||
t.mark = t.mark_m;
|
||
t.mark_len = (mark_end - mark_hdr);
|
||
return t;
|
||
|
||
#undef bound_check_return
|
||
}
|
||
} // namespace read_write
|
||
} // namespace impl
|
||
|
||
using nbt_parse_error = impl::nbt_parse_error;
|
||
using nbt_type = impl::nbt_type;
|
||
struct nbt_type_error
|
||
{
|
||
nbt_type is;
|
||
nbt_type as;
|
||
};
|
||
class nbt_document;
|
||
template<nbt_type tag_type, nbt_type list_element_type>
|
||
class nbt_any_tag;
|
||
template<nbt_type list_element_type>
|
||
class nbt_list;
|
||
class nbt_compound;
|
||
|
||
template<bool in_place, bool bound_check, std::endian nbt_endian, impl::swapper::read_swapper rswap>
|
||
[[nodiscard]] inline auto read(std::span<std::byte, std::dynamic_extent> source) -> nbt_document;
|
||
|
||
template<nbt_type list_element_type>
|
||
class nbt_list
|
||
{
|
||
private:
|
||
impl::nbt_list impl_list;
|
||
|
||
template<nbt_type tag_type, nbt_type list_element_type_>
|
||
friend class nbt_any_tag;
|
||
|
||
public:
|
||
class iterator
|
||
{
|
||
private:
|
||
impl::nbt_list::iterator impl_iterator;
|
||
|
||
public:
|
||
inline iterator& operator++() noexcept
|
||
{
|
||
if constexpr (list_element_type == nbt_type::tag_end)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_end(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_byte(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_short)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_short(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_int(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_long)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_long(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_float)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_float(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_double)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_double(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte_array)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_byte_array(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_string)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_string(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_list)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_list(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_compound)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_compound(std::addressof(impl_iterator));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int_array)
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_int_array(std::addressof(impl_iterator));
|
||
}
|
||
else
|
||
{
|
||
impl::nbt_list_function::nbt_list_iterator_next_long_array(std::addressof(impl_iterator));
|
||
}
|
||
return *this;
|
||
}
|
||
inline const iterator operator++(int) noexcept
|
||
{
|
||
auto old = *this;
|
||
++(*this);
|
||
return old;
|
||
}
|
||
[[nodiscard]] inline bool operator==(const iterator& x) const noexcept
|
||
{
|
||
return impl::nbt_list_function::nbt_list_iter_equal(std::addressof(impl_iterator), std::addressof(x.impl_iterator));
|
||
}
|
||
[[nodiscard]] inline bool operator!=(const iterator& x) const noexcept
|
||
{
|
||
return !impl::nbt_list_function::nbt_list_iter_equal(std::addressof(impl_iterator), std::addressof(x.impl_iterator));
|
||
}
|
||
|
||
template<nbt_type element_type = nbt_type::tag_end>
|
||
[[nodiscard]] inline auto value() const
|
||
{
|
||
nbt_any_tag<list_element_type, element_type> tag{};
|
||
if constexpr (list_element_type == nbt_type::tag_list)
|
||
{
|
||
auto list_type{
|
||
static_cast<nbt_type>(*impl_iterator.source)};
|
||
if (list_type != element_type)
|
||
{
|
||
throw nbt_type_error{.is = list_type, .as = element_type};
|
||
}
|
||
}
|
||
tag.impl_any_tag = impl::nbt_list_function::nbt_list_iter_value(std::addressof(impl_iterator));
|
||
return tag.get();
|
||
}
|
||
|
||
[[nodiscard]] inline consteval nbt_type type() const noexcept
|
||
{
|
||
return list_element_type;
|
||
}
|
||
|
||
[[nodiscard]] inline nbt_type element_type() const noexcept
|
||
{
|
||
return static_cast<nbt_type>(*impl_iterator.source);
|
||
}
|
||
|
||
friend class nbt_list<list_element_type>;
|
||
};
|
||
|
||
[[nodiscard]] inline iterator begin() const noexcept
|
||
{
|
||
iterator iter{};
|
||
iter.impl_iterator = impl::nbt_list_function::nbt_list_iterator_begin(std::addressof(impl_list));
|
||
return iter;
|
||
}
|
||
|
||
[[nodiscard]] inline iterator end() const noexcept
|
||
{
|
||
iterator iter{};
|
||
iter.impl_iterator = impl::nbt_list_function::nbt_list_iterator_end(std::addressof(impl_list));
|
||
return iter;
|
||
}
|
||
[[nodiscard]] inline std::size_t size() const noexcept
|
||
{
|
||
return impl_list.length;
|
||
}
|
||
[[nodiscard]] inline auto operator[](std::int32_t index) const noexcept
|
||
{
|
||
iterator iter{};
|
||
if constexpr (list_element_type == nbt_type::tag_end)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_end(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_byte(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_short)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_short(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_int(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_long)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_long(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_float)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_float(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_double)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_double(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte_array)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_byte_array(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_string)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_string(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_list)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_list(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_compound)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_compound(std::addressof(impl_list), index));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int_array)
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_int_array(std::addressof(impl_list), index));
|
||
}
|
||
else
|
||
{
|
||
iter.impl_iterator = (impl::nbt_list_function::nbt_list_find_value_long_array(std::addressof(impl_list), index));
|
||
}
|
||
return iter;
|
||
}
|
||
};
|
||
|
||
class nbt_compound
|
||
{
|
||
private:
|
||
impl::nbt_compound impl_compound;
|
||
|
||
template<nbt_type tag_type, nbt_type list_element_type>
|
||
friend class nbt_any_tag;
|
||
|
||
public:
|
||
class iterator
|
||
{
|
||
private:
|
||
impl::nbt_compound::iterator impl_iterator;
|
||
|
||
public:
|
||
inline iterator& operator++() noexcept
|
||
{
|
||
impl::nbt_compound_function::nbt_compound_iterator_next(std::addressof(impl_iterator));
|
||
return *this;
|
||
}
|
||
inline const iterator operator++(int) noexcept
|
||
{
|
||
auto old = *this;
|
||
++(*this);
|
||
return old;
|
||
}
|
||
[[nodiscard]] inline bool operator==(const iterator& x) const noexcept
|
||
{
|
||
return impl::nbt_compound_function::nbt_compound_iter_equal(std::addressof(impl_iterator), std::addressof(x.impl_iterator));
|
||
}
|
||
[[nodiscard]] inline bool operator!=(const iterator& x) const noexcept
|
||
{
|
||
return !impl::nbt_compound_function::nbt_compound_iter_equal(std::addressof(impl_iterator), std::addressof(x.impl_iterator));
|
||
}
|
||
|
||
template<nbt_type tag_type, nbt_type list_element_type = nbt_type::tag_end>
|
||
[[nodiscard]] inline auto value() const
|
||
{
|
||
auto real_type{static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(impl_iterator.source))};
|
||
if (real_type != tag_type)
|
||
{
|
||
throw nbt_type_error{.is = real_type, .as = tag_type};
|
||
}
|
||
if constexpr (tag_type == nbt_type::tag_list)
|
||
{
|
||
auto list_type{
|
||
static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(
|
||
impl_iterator.source + sizeof(std::uint8_t) + sizeof(std::uint16_t) +
|
||
impl::swapper::byte_as_type<std::uint16_t>(
|
||
impl_iterator.source + sizeof(std::uint8_t))))};
|
||
if (list_type != list_element_type)
|
||
{
|
||
throw nbt_type_error{.is = list_type, .as = list_element_type};
|
||
}
|
||
}
|
||
nbt_any_tag<tag_type, list_element_type> tag{};
|
||
tag.impl_any_tag = impl::nbt_compound_function::nbt_compound_iter_value(std::addressof(impl_iterator));
|
||
return tag.get();
|
||
}
|
||
|
||
[[nodiscard]] inline std::u8string_view key() const noexcept
|
||
{
|
||
return impl::nbt_compound_function::nbt_compound_iter_key(std::addressof(impl_iterator));
|
||
}
|
||
|
||
[[nodiscard]] inline nbt_type type() const noexcept
|
||
{
|
||
return static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(impl_iterator.source));
|
||
}
|
||
|
||
[[nodiscard]] inline nbt_type element_type() const noexcept
|
||
{
|
||
return static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(
|
||
impl_iterator.source + sizeof(std::uint8_t) + sizeof(std::uint16_t) +
|
||
impl::swapper::byte_as_type<std::uint16_t>(
|
||
impl_iterator.source + sizeof(std::uint8_t))));
|
||
}
|
||
|
||
using difference_type = std::ptrdiff_t;
|
||
|
||
friend class nbt_compound;
|
||
};
|
||
|
||
[[nodiscard]] inline iterator begin() const noexcept
|
||
{
|
||
iterator iter{};
|
||
iter.impl_iterator = impl::nbt_compound_function::nbt_compound_iterator_begin(std::addressof(impl_compound));
|
||
return iter;
|
||
}
|
||
|
||
[[nodiscard]] inline iterator end() const noexcept
|
||
{
|
||
iterator iter{};
|
||
iter.impl_iterator = impl::nbt_compound_function::nbt_compound_iterator_end(std::addressof(impl_compound));
|
||
return iter;
|
||
}
|
||
|
||
[[nodiscard]] inline iterator at(std::u8string_view key) const
|
||
{
|
||
iterator iter{};
|
||
iter.impl_iterator = impl::nbt_compound_function::nbt_compound_find_value(std::addressof(impl_compound), key);
|
||
return iter;
|
||
}
|
||
};
|
||
|
||
template<nbt_type tag_type, nbt_type list_element_type = nbt_type::tag_end>
|
||
class nbt_any_tag
|
||
{
|
||
private:
|
||
impl::any_tag impl_any_tag;
|
||
|
||
friend class nbt_document;
|
||
template<nbt_type list_element_type_>
|
||
friend class nbt_list;
|
||
friend class nbt_compound;
|
||
|
||
public:
|
||
[[nodiscard]] inline consteval nbt_type type() noexcept
|
||
{
|
||
return tag_type;
|
||
}
|
||
|
||
[[nodiscard]] inline consteval nbt_type element_type() noexcept
|
||
{
|
||
return list_element_type;
|
||
}
|
||
|
||
[[nodiscard]] inline auto get() noexcept
|
||
{
|
||
if constexpr (tag_type == nbt_type::tag_end)
|
||
{
|
||
return;
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_byte)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_byte(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_short)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_short(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_int)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_int(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_long)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_long(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_float)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_float(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_double)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_double(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_byte_array)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_byte_array(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_string)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_string(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_list)
|
||
{
|
||
if constexpr (list_element_type == nbt_type::tag_end)
|
||
{
|
||
return;
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_byte(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_short)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_short(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_int(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_long)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_long(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_float)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_float(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_double)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_list_double(std::addressof(impl_any_tag));
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_byte_array)
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_byte_array(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_string)
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_string(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_list)
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_list(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_compound)
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_compound(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
else if constexpr (list_element_type == nbt_type::tag_int_array)
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_int_array(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
else
|
||
{
|
||
nbt_list<list_element_type> list{};
|
||
list.impl_list = impl::any_tag_function::any_tag_get_list_long_array(std::addressof(impl_any_tag));
|
||
return list;
|
||
}
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_compound)
|
||
{
|
||
nbt_compound comp{};
|
||
comp.impl_compound = impl::any_tag_function::any_tag_get_compound(std::addressof(impl_any_tag));
|
||
return comp;
|
||
}
|
||
else if constexpr (tag_type == nbt_type::tag_int_array)
|
||
{
|
||
return impl::any_tag_function::any_tag_get_int_array(std::addressof(impl_any_tag));
|
||
}
|
||
else
|
||
{
|
||
return impl::any_tag_function::any_tag_get_long_array(std::addressof(impl_any_tag));
|
||
}
|
||
}
|
||
};
|
||
|
||
class nbt_document
|
||
{
|
||
private:
|
||
impl::nbt_document impl_document;
|
||
|
||
template<bool in_place, bool bound_check, std::endian nbt_endian, impl::swapper::read_swapper rswap>
|
||
friend inline auto read(std::span<std::byte, std::dynamic_extent> source) -> nbt_document;
|
||
|
||
public:
|
||
nbt_document(const nbt_document&) = delete;
|
||
nbt_document& operator=(const nbt_document&) = delete;
|
||
|
||
inline nbt_document& operator=(nbt_document&& right) noexcept
|
||
{
|
||
impl::nbt_document_function::nbt_document_move(
|
||
std::addressof(right.impl_document),
|
||
std::addressof(this->impl_document));
|
||
return *this;
|
||
}
|
||
inline ~nbt_document() noexcept
|
||
{
|
||
impl::nbt_document_function::nbt_document_free(
|
||
std::addressof(this->impl_document));
|
||
}
|
||
inline nbt_document() noexcept = default;
|
||
inline nbt_document(nbt_document&& right) noexcept
|
||
{
|
||
impl::nbt_document_function::nbt_document_move(
|
||
std::addressof(right.impl_document),
|
||
std::addressof(this->impl_document));
|
||
}
|
||
|
||
public:
|
||
[[nodiscard]] inline nbt_type type() noexcept
|
||
{
|
||
return static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(this->impl_document.source));
|
||
}
|
||
[[nodiscard]] inline nbt_type element_type() noexcept
|
||
{
|
||
return static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(
|
||
this->impl_document.source + sizeof(std::uint8_t) + sizeof(std::uint16_t) +
|
||
impl::swapper::byte_as_type<std::uint16_t>(
|
||
this->impl_document.source + sizeof(std::uint8_t))));
|
||
}
|
||
[[nodiscard]] inline auto key() noexcept
|
||
{
|
||
return impl::nbt_document_function::nbt_document_root_key(std::addressof(this->impl_document));
|
||
}
|
||
template<nbt_type tag_type, nbt_type list_element_type = nbt_type::tag_end>
|
||
[[nodiscard]] inline auto value()
|
||
{
|
||
auto real_type{static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(this->impl_document.source))};
|
||
if (real_type != tag_type)
|
||
{
|
||
throw nbt_type_error{.is = real_type, .as = tag_type};
|
||
}
|
||
if constexpr (tag_type == nbt_type::tag_list)
|
||
{
|
||
auto list_type{
|
||
static_cast<nbt_type>(impl::swapper::byte_as_type<std::uint8_t>(
|
||
this->impl_document.source + sizeof(std::uint8_t) + sizeof(std::uint16_t) +
|
||
impl::swapper::byte_as_type<std::uint16_t>(
|
||
this->impl_document.source + sizeof(std::uint8_t))))};
|
||
if (list_type != list_element_type)
|
||
{
|
||
throw nbt_type_error{.is = list_type, .as = list_element_type};
|
||
}
|
||
}
|
||
nbt_any_tag<tag_type, list_element_type> tag{};
|
||
tag.impl_any_tag = impl::nbt_document_function::nbt_document_root_value(std::addressof(this->impl_document));
|
||
return tag.get();
|
||
}
|
||
};
|
||
|
||
template<bool in_place = true, bool bound_check = false, std::endian nbt_endian = std::endian::big, impl::swapper::read_swapper rswap = impl::swapper::default_read_swapper>
|
||
[[nodiscard]] auto read(std::span<std::byte, std::dynamic_extent> source) -> nbt_document
|
||
{
|
||
nbt_document doc{};
|
||
doc.impl_document = impl::read_write::read<in_place, bound_check, nbt_endian, rswap>(source.data(), source.size());
|
||
return doc;
|
||
}
|
||
} // namespace na::nbt
|