amulet-core 2.0a7__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp312-cp312-win_amd64.whl

amulet/level/java/chunk_components/data_version_component.cpp

@@ -1,32 +0,0 @@
-#include <cstdint>
-#include <optional>
-
-#include <amulet/io/binary_writer.hpp>
-#include <amulet/io/binary_reader.hpp>
-
-#include <amulet/level/java/chunk_components/data_version_component.hpp>
-
-namespace Amulet {
-	const std::string DataVersionComponent::ComponentID = "Amulet::DataVersionComponent";
-
-	std::optional<std::string> DataVersionComponent::serialise() const {
-		if (_data_version) {
-			BinaryWriter writer;
-			writer.writeNumeric<std::int64_t>(_data_version.value());
-			return writer.getBuffer();
-		}
-		else {
-			return std::nullopt;
-		}
-	}
-	void DataVersionComponent::deserialise(std::optional<std::string> data) {
-		if (data) {
-			size_t position = 0;
-			BinaryReader reader(data.value(), position);
-			_data_version = reader.readNumeric<std::int64_t>();
-		}
-		else {
-			_data_version = std::nullopt;
-		}
-	}
-}

amulet/level/java/chunk_components/data_version_component.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <cstdint>
-#include <string>
-#include <stdexcept>
-
-
-namespace Amulet {
-	class DataVersionComponent {
-	private:
-		std::optional<std::int64_t> _data_version;
-	protected:
-		// Null constructor
-		DataVersionComponent() {};
-		// Default constructor
-		void init(std::int64_t data_version) { _data_version = data_version; }
-		// Serialise the component data
-		std::optional<std::string> serialise() const;
-		// Deserialise the component
-		void deserialise(std::optional<std::string>);
-	public:
-		static const std::string ComponentID;
-		std::int64_t get_data_version() {
-			if (_data_version) {
-				return *_data_version;
-			}
-			throw std::runtime_error("DataVersionComponent has not been loaded.");
-		};
-	};
-}

amulet/level/java/chunk_components/java_raw_chunk_component.cpp

@@ -1,56 +0,0 @@
-#include <optional>
-#include <stdexcept>
-
-#include <amulet/io/binary_writer.hpp>
-#include <amulet/io/binary_reader.hpp>
-
-#include <amulet_nbt/nbt_encoding/binary.hpp>
-
-#include <amulet/level/java/chunk_components/java_raw_chunk_component.hpp>
-
-namespace Amulet {
-	const std::string JavaRawChunkComponent::ComponentID = "Amulet::JavaRawChunkComponent";
-
-	std::optional<std::string> JavaRawChunkComponent::serialise() const {
-		if (_raw_data) {
-			BinaryWriter writer;
-			writer.writeNumeric<std::uint8_t>(1);
-			const auto& raw_data = _raw_data.value();
-			writer.writeNumeric<std::uint64_t>(raw_data->size());
-			for (const auto& [k, v] : *raw_data) {
-				writer.writeSizeAndBytes(k);
-				AmuletNBT::write_nbt(writer, *v);
-			}
-			return writer.getBuffer();
-		}
-		else {
-			return std::nullopt;
-		}
-	}
-	void JavaRawChunkComponent::deserialise(std::optional<std::string> data) {
-		if (data) {
-			size_t position = 0;
-			BinaryReader reader(data.value(), position);
-			auto version = reader.readNumeric<std::uint8_t>();
-			switch (version) {
-				case 1:
-					{
-						auto raw_data = std::make_shared<Amulet::JavaRawChunkType>();
-						auto count = reader.readNumeric<std::uint64_t>();
-						for (auto i = 0; i < count; i++) {
-							auto key = reader.readSizeAndBytes();
-							auto tag = std::make_shared<AmuletNBT::NamedTag>(AmuletNBT::read_nbt(reader));
-							raw_data->emplace(key, tag);
-						}
-						_raw_data = raw_data;
-					}
-					break;
-				default:
-					throw std::invalid_argument("Unsupported JavaRawChunkComponent version " + std::to_string(version));
-			}
-		}
-		else {
-			_raw_data = std::nullopt;
-		}
-	}
-}

amulet/level/java/chunk_components/java_raw_chunk_component.hpp

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <optional>
-#include <cstdint>
-#include <string>
-#include <stdexcept>
-#include <memory>
-#include <map>
-#include <amulet_nbt/tag/named_tag.hpp>
-
-
-namespace Amulet {
-	typedef std::map<std::string, std::shared_ptr<AmuletNBT::NamedTag>> JavaRawChunkType;
-
-	class JavaRawChunkComponent {
-	private:
-		std::optional<std::shared_ptr<JavaRawChunkType>> _raw_data;
-	protected:
-		// Null constructor
-		JavaRawChunkComponent() {};
-		// Default constructor
-		void init(std::shared_ptr<JavaRawChunkType> raw_data) { _raw_data = raw_data; }
-		void init() { _raw_data = std::make_shared<JavaRawChunkType>(); }
-		// Serialise the component data
-		std::optional<std::string> serialise() const;
-		// Deserialise the component
-		void deserialise(std::optional<std::string>);
-	public:
-		static const std::string ComponentID;
-		std::shared_ptr<JavaRawChunkType> get_raw_data() {
-			if (_raw_data) {
-				return *_raw_data;
-			}
-			throw std::runtime_error("JavaRawChunkComponent has not been loaded.");
-		};
-		void set_raw_data(std::shared_ptr<JavaRawChunkType> raw_data) {
-			if (_raw_data) {
-				_raw_data = raw_data;
-			}
-			else {
-				throw std::runtime_error("JavaRawChunkComponent has not been loaded.");
-			}
-		}
-	};
-}

amulet/level/java/chunk_components.pyi

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-import collections.abc
-import typing
-
-import amulet_nbt
-
-__all__ = ["DataVersionComponent", "JavaRawChunkComponent"]
-
-class DataVersionComponent:
-    ComponentID: typing.ClassVar[str] = "Amulet::DataVersionComponent"
-    @property
-    def data_version(self) -> int: ...
-
-class JavaRawChunkComponent:
-    ComponentID: typing.ClassVar[str] = "Amulet::JavaRawChunkComponent"
-    @property
-    def raw_data(self) -> collections.abc.MutableMapping[str, amulet_nbt.NamedTag]: ...
-    @raw_data.setter
-    def raw_data(
-        self, arg1: collections.abc.Mapping[str, amulet_nbt.NamedTag]
-    ) -> None: ...

amulet/level/java/java_chunk.cpp

@@ -1,170 +0,0 @@
-#include <string>
-#include <optional>
-#include <vector>
-#include <unordered_map>
-#include <cstdint>
-
-#include <amulet/chunk.hpp>
-#include <amulet/level/java/java_chunk.hpp>
-#include <amulet/chunk_components/block_component.hpp>
-
-namespace Amulet {
-	const std::string JavaChunkNA::ChunkID = "Amulet::JavaChunkNA";
-	const std::string JavaChunk0::ChunkID = "Amulet::JavaChunk0";
-	const std::string JavaChunk1444::ChunkID = "Amulet::JavaChunk1444";
-	const std::string JavaChunk1466::ChunkID = "Amulet::JavaChunk1466";
-	const std::string JavaChunk2203::ChunkID = "Amulet::JavaChunk2203";
-	
-	std::string JavaChunkNA::get_chunk_id() const { return ChunkID; }
-	std::string JavaChunk0::get_chunk_id() const { return ChunkID; }
-	std::string JavaChunk1444::get_chunk_id() const { return ChunkID; }
-	std::string JavaChunk1466::get_chunk_id() const { return ChunkID; }
-	std::string JavaChunk2203::get_chunk_id() const { return ChunkID; }
-	
-	JavaChunkNA::JavaChunkNA(
-		std::shared_ptr<BlockStack> default_block,
-		std::shared_ptr<Biome> default_biome
-	) : ChunkComponentHelper() {
-		auto version_number = std::make_shared<VersionNumber>(
-			std::initializer_list<std::int64_t>{ -1 }
-		);
-		auto version_range = std::make_shared<VersionRange>(
-			"java",
-			version_number,
-			version_number
-		);
-		JavaRawChunkComponent::init();
-		DataVersionComponent::init(-1);
-		BlockComponent::init(
-			version_range,
-			SectionShape(
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16)
-			),
-			default_block
-		);
-	}
-
-	JavaChunk0::JavaChunk0(
-		std::int64_t data_version,
-		std::shared_ptr<BlockStack> default_block,
-		std::shared_ptr<Biome> default_biome
-	) : ChunkComponentHelper() {
-		if (data_version < 0 || 1443 < data_version) {
-			throw std::invalid_argument("data version must be between 0 and 1443");
-		}
-		auto version_number = std::make_shared<VersionNumber>(
-			std::initializer_list<std::int64_t>{ data_version }
-		);
-		auto version_range = std::make_shared<VersionRange>(
-			"java",
-			version_number,
-			version_number
-			);
-		JavaRawChunkComponent::init();
-		DataVersionComponent::init(data_version);
-		BlockComponent::init(
-			version_range,
-			SectionShape(
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16)
-			),
-			default_block
-		);
-	}
-
-	JavaChunk1444::JavaChunk1444(
-		std::int64_t data_version,
-		std::shared_ptr<BlockStack> default_block,
-		std::shared_ptr<Biome> default_biome
-	) : ChunkComponentHelper() {
-		if (data_version < 1444 || 1465 < data_version) {
-			throw std::invalid_argument("data version must be between 1443 and 1465");
-		}
-		auto version_number = std::make_shared<VersionNumber>(
-			std::initializer_list<std::int64_t>{ data_version }
-		);
-		auto version_range = std::make_shared<VersionRange>(
-			"java",
-			version_number,
-			version_number
-			);
-		JavaRawChunkComponent::init();
-		DataVersionComponent::init(data_version);
-		BlockComponent::init(
-			version_range,
-			SectionShape(
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16)
-			),
-			default_block
-		);
-	}
-
-	JavaChunk1466::JavaChunk1466(
-		std::int64_t data_version,
-		std::shared_ptr<BlockStack> default_block,
-		std::shared_ptr<Biome> default_biome
-	) : ChunkComponentHelper() {
-		if (data_version < 1466 || 2202 < data_version) {
-			throw std::invalid_argument("data version must be between 1466 and 2202");
-		}
-		auto version_number = std::make_shared<VersionNumber>(
-			std::initializer_list<std::int64_t>{ data_version }
-		);
-		auto version_range = std::make_shared<VersionRange>(
-			"java",
-			version_number,
-			version_number
-			);
-		JavaRawChunkComponent::init();
-		DataVersionComponent::init(data_version);
-		BlockComponent::init(
-			version_range,
-			SectionShape(
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16)
-			),
-			default_block
-		);
-	}
-
-	JavaChunk2203::JavaChunk2203(
-		std::int64_t data_version,
-		std::shared_ptr<BlockStack> default_block,
-		std::shared_ptr<Biome> default_biome
-	) : ChunkComponentHelper() {
-		if (data_version < 2203) {
-			throw std::invalid_argument("data version must be at least 2203");
-		}
-		auto version_number = std::make_shared<VersionNumber>(
-			std::initializer_list<std::int64_t>{ data_version }
-		);
-		auto version_range = std::make_shared<VersionRange>(
-			"java",
-			version_number,
-			version_number
-			);
-		JavaRawChunkComponent::init();
-		DataVersionComponent::init(data_version);
-		BlockComponent::init(
-			version_range,
-			SectionShape(
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16),
-				static_cast<std::uint16_t>(16)
-			),
-			default_block
-		);
-	}
-
-	static const ChunkNullConstructor<JavaChunkNA> _jcna;
-	static const ChunkNullConstructor<JavaChunk0> _jc0;
-	static const ChunkNullConstructor<JavaChunk1444> _jc1444;
-	static const ChunkNullConstructor<JavaChunk1466> _jc1466;
-	static const ChunkNullConstructor<JavaChunk2203> _jc2203;
-}

amulet/level/java/java_chunk.hpp

@@ -1,141 +0,0 @@
-#pragma once
-
-#include <string>
-#include <optional>
-#include <stdexcept>
-#include <vector>
-#include <amulet/block.hpp>
-#include <amulet/biome.hpp>
-#include <amulet/chunk.hpp>
-#include <amulet/chunk_components/block_component.hpp>
-#include "chunk_components/java_raw_chunk_component.hpp"
-#include "chunk_components/data_version_component.hpp"
-
-namespace Amulet {
-	class JavaChunk : public Chunk {};
-
-	class JavaChunkNA : public ChunkComponentHelper<
-		JavaChunk,
-		JavaRawChunkComponent,
-		DataVersionComponent,
-		// LastUpdateComponent,
-		// JavaLegacyVersionComponent,
-		BlockComponent//,
-		// BlockEntityComponent,
-		// EntityComponent,
-		// Biome2DComponent,
-		// Height2DComponent,
-	> {
-	public:
-		static const std::string ChunkID;
-
-		std::string get_chunk_id() const override;
-
-		using ChunkComponentHelper::ChunkComponentHelper;
-		JavaChunkNA(
-			std::shared_ptr<BlockStack> default_block,
-			std::shared_ptr<Biome> default_biome
-		);
-	};
-
-	class JavaChunk0 : public ChunkComponentHelper<
-		JavaChunk,
-		JavaRawChunkComponent,
-		DataVersionComponent,
-		// LastUpdateComponent,
-		// TerrainPopulatedComponent,
-		// LightPopulatedComponent,
-		BlockComponent//,
-		// BlockEntityComponent,
-		// EntityComponent,
-		// Biome2DComponent,
-		// Height2DComponent,
-	> {
-	public:
-		static const std::string ChunkID;
-
-		std::string get_chunk_id() const override;
-
-		using ChunkComponentHelper::ChunkComponentHelper;
-		JavaChunk0(
-			std::int64_t data_version,
-			std::shared_ptr<BlockStack> default_block,
-			std::shared_ptr<Biome> default_biome
-		);
-	};
-
-	class JavaChunk1444 : public ChunkComponentHelper<
-		JavaChunk,
-		JavaRawChunkComponent,
-		DataVersionComponent,
-		// LastUpdateComponent,
-		// StatusStringComponent,
-		BlockComponent//,
-		// BlockEntityComponent,
-		// EntityComponent,
-		// Biome2DComponent,
-		// Height2DComponent,
-	> {
-	public:
-		static const std::string ChunkID;
-
-		std::string get_chunk_id() const override;
-
-		using ChunkComponentHelper::ChunkComponentHelper;
-		JavaChunk1444(
-			std::int64_t data_version,
-			std::shared_ptr<BlockStack> default_block,
-			std::shared_ptr<Biome> default_biome
-		);
-	};
-
-	class JavaChunk1466 : public ChunkComponentHelper<
-		JavaChunk,
-		JavaRawChunkComponent,
-		DataVersionComponent,
-		// LastUpdateComponent,
-		// StatusStringComponent,
-		BlockComponent//,
-		// BlockEntityComponent,
-		// EntityComponent,
-		// Biome2DComponent,
-		// NamedHeight2DComponent,
-	> {
-	public:
-		static const std::string ChunkID;
-
-		std::string get_chunk_id() const override;
-
-		using ChunkComponentHelper::ChunkComponentHelper;
-		JavaChunk1466(
-			std::int64_t data_version,
-			std::shared_ptr<BlockStack> default_block,
-			std::shared_ptr<Biome> default_biome
-		);
-	};
-
-	class JavaChunk2203 : public ChunkComponentHelper<
-		JavaChunk,
-		JavaRawChunkComponent,
-		DataVersionComponent,
-		// LastUpdateComponent,
-		// StatusStringComponent,
-		BlockComponent//,
-		// BlockEntityComponent,
-		// EntityComponent,
-		// Biome3DComponent,
-		// NamedHeight2DComponent,
-	> {
-	public:
-		static const std::string ChunkID;
-
-		std::string get_chunk_id() const override;
-
-		using ChunkComponentHelper::ChunkComponentHelper;
-		JavaChunk2203(
-			std::int64_t data_version,
-			std::shared_ptr<BlockStack> default_block,
-			std::shared_ptr<Biome> default_biome
-		);
-	};
-}

amulet/level/java/long_array.hpp

@@ -1,175 +0,0 @@
-#pragma once
-#include <span>
-#include <cstdint>
-#include <stdexcept>
-#include <string>
-#include <cmath>
-#include <algorithm>
-#include <bit>
-#include <type_traits>
-
-namespace Amulet {
-	/*
-	Minecraft Java edition stores the block and height arrays in a compacted long array format.
-	The format stores one or more entries per long, using the fewest number of bits required to store the data.
-	There are two storage methods, the compact version was used prior to 1.16 and the less compact version in 1.16 and above.
-	Apparently the less compact version is quicker to pack and unpack.
-	The compact version effectively stores the values as a bit array spanning one or more values in the long array.
-	There may be some padding if the bit array does not fill all the long values. (The letter "P" signifies an unused padding bit)
-	HGGGGGGGGGFFFFFFFFFEEEEEEEEEDDDDDDDDDCCCCCCCCCBBBBBBBBBAAAAAAAAA PPNNNNNNNNNMMMMMMMMMLLLLLLLLLKKKKKKKKKJJJJJJJJJIIIIIIIIIHHHHHHHH
-	The less compact version does not allow entries to straddle long values. Instead, if required, there is padding within each long.
-	PGGGGGGGGGFFFFFFFFFEEEEEEEEEDDDDDDDDDCCCCCCCCCBBBBBBBBBAAAAAAAAA PNNNNNNNNNMMMMMMMMMLLLLLLLLLKKKKKKKKKJJJJJJJJJIIIIIIIIIHHHHHHHHH
-	*/
-
-	template <typename decodedT>
-	void decode_long_array(
-		const std::span<std::uint64_t>& encoded,  // The long array to decode
-		std::span<decodedT>& decoded,  // The array to unpack values into
-		std::uint8_t bits_per_entry,  // The number of bits per entry
-		bool dense = true
-	) {
-		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
-		if (bits_per_entry < 1 || 64 < bits_per_entry) {
-			throw std::invalid_argument("bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(bits_per_entry));
-		}
-
-		size_t expected_len = std::ceil(
-			dense ? static_cast<float>(decoded.size()) * bits_per_entry / 64 : static_cast<float>(decoded.size()) / (64 / bits_per_entry)
-		);
-
-		if (encoded.size() != expected_len) {
-			throw std::invalid_argument(
-				dense ? "Dense encoded long array with " : "Encoded long array with " +
-				std::to_string(bits_per_entry) +
-				" bits per entry should contain " +
-				std::to_string(expected_len) +
-				" longs but got " +
-				std::to_string(encoded.size()) +
-				"."
-			);
-		}
-
-		const std::uint64_t mask = ~0ull >> (64 - bits_per_entry);
-		if (dense) {
-			for (size_t decoded_index = 0; decoded_index < decoded.size(); decoded_index++) {
-				size_t bit_start = decoded_index * bits_per_entry;
-				size_t bit_stop = (decoded_index + 1) * bits_per_entry;
-				size_t long_start = bit_start / 64;
-				decodedT& value = decoded[decoded_index];
-				value = (encoded[long_start] >> (bit_start % 64)) & mask;
-				if ((long_start + 1) * 64 < bit_stop) {
-					// Overflows into the next long
-					size_t overflow_bits = bit_stop - (long_start + 1) * 64;
-					size_t previous_bits = bits_per_entry - overflow_bits;
-					value |= (encoded[long_start + 1] & (mask >> previous_bits)) << previous_bits;
-				}
-			}
-		}
-		else {
-			size_t entries_per_long = 64 / bits_per_entry;
-			size_t decoded_index = 0;
-			for (const auto& encoded_value : encoded) {
-				for (
-					size_t offset = 0;
-					offset < entries_per_long && decoded_index < decoded.size();
-					offset++, decoded_index++
-				) {
-					decoded[decoded_index] = (encoded_value >> (bits_per_entry * offset)) & mask;
-				}
-			}
-		}
-	}
-
-	// Get the number of longs required to store the encoded long array.
-	inline size_t encoded_long_array_size(
-		size_t decoded_size,  // The number of elements to encode
-		std::uint8_t bits_per_entry,  // The number of bits of each number to use
-		bool dense = true
-	) {
-		if (dense) {
-			return std::ceil(static_cast<float>(decoded_size * bits_per_entry) / 64);
-		}
-		else {
-			size_t entries_per_long = 64 / bits_per_entry;
-			return std::ceil(static_cast<float>(decoded_size) / entries_per_long);
-		}
-	}
-
-	// Encode the array to a long array with the specified number of bits. Extra bits are ignored.
-	template <typename decodedT>
-	void encode_long_array(
-		const std::span<decodedT>& decoded,  // The array to encode
-		std::span<std::uint64_t> encoded,  // The array to encode into. This must be large enough.
-		std::uint8_t bits_per_entry,  // The number of bits of each number to use
-		bool dense = true
-	) {
-		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
-		if (bits_per_entry < 1 || 64 < bits_per_entry) {
-			throw std::invalid_argument("bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(bits_per_entry));
-		}
-
-		// Set all values to 0
-		std::fill(encoded.begin(), encoded.end(), 0);
-		const std::uint64_t mask = ~0ull >> (64 - bits_per_entry);
-		if (dense) {
-			for (size_t decoded_index = 0; decoded_index < decoded.size(); decoded_index++) {
-				// The bit in the array where the value starts
-				size_t bit_start = decoded_index * bits_per_entry;
-				// The bit in the array where the value stops
-				size_t bit_stop = bit_start + bits_per_entry;
-				// The long number that the value starts in
-				size_t long_start = bit_start / 64;
-				// The bit offset in the long where the value starts
-				size_t long_bit_offset = bit_start % 64;
-				// The bit in the array where the long stops
-				size_t long_bit_stop = (long_start + 1) * 64;
-				decodedT& value = decoded[decoded_index];
-				encoded[long_start] = (encoded[long_start] & ~(mask << long_bit_offset)) + ((value & mask) << long_bit_offset);
-				if (long_bit_stop < bit_stop) {
-					// Overflows into the next long
-					// The number of bits that overflow into the next long
-					size_t overflow_bits = bit_stop - long_bit_stop;
-					// The number of bits in the previous long
-					size_t previous_bits = bits_per_entry - overflow_bits;
-					encoded[long_start + 1] = (encoded[long_start + 1] & ~(mask >> previous_bits)) + ((value & mask) >> previous_bits);
-				}
-			}
-		}
-		else {
-			size_t entries_per_long = 64 / bits_per_entry;
-			size_t decoded_index = 0;
-			size_t long_count = std::ceil(static_cast<float>(decoded.size()) / entries_per_long);
-			for (size_t encoded_index = 0; encoded_index < long_count; encoded_index++) {
-				auto& encoded_value = encoded[encoded_index];
-				encoded_value = 0;
-				for (
-					size_t offset = 0;
-					offset < entries_per_long && decoded_index < decoded.size();
-					offset++, decoded_index++
-				) {
-					std::uint64_t value = decoded[decoded_index] & mask;
-					encoded_value += value << (bits_per_entry * offset);
-				}
-			}
-		}
-	}
-
-	// Encode the array to a long aray with at least this number of bits. The number of required bits is computed before encoding.
-	template <typename decodedT>
-	void encode_long_array_min(
-		const std::span<decodedT>& decoded,  // The array to encode
-		std::span<std::uint64_t> encoded,  // The array to encode into
-		std::uint8_t min_bits_per_entry,  // The minimum number of bits of each number to use
-		bool dense = true
-	) {
-		static_assert(std::is_unsigned_v<decodedT>, "decodedT must be unsigned");
-		if (min_bits_per_entry < 1 || 64 < min_bits_per_entry) {
-			throw std::invalid_argument("min_bits_per_entry must be between 1 and 64 inclusive. Got " + std::to_string(min_bits_per_entry));
-		}
-		std::uint8_t bits_per_entry = std::max(
-			min_bits_per_entry, 
-			std::bit_width(*std::max_element(decoded.begin(), decoded.end()))
-		);
-		encode_long_array(decoded, encoded, bits_per_entry, dense);
-	}
-}