amulet-core 2.0a5__cp311-cp311-win_amd64.whl → 2.0a7__cp311-cp311-win_amd64.whl

amulet/chunk_components/section_array_map.cpp

@@ -0,0 +1,129 @@
+#include <string>
+
+#include <amulet/io/binary_writer.hpp>
+#include <amulet/io/binary_reader.hpp>
+
+#include "section_array_map.hpp"
+
+namespace Amulet {
+	void IndexArray3D::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		
+		// Write array shape
+		const auto& array_shape = get_shape();
+		writer.writeNumeric<std::uint16_t>(std::get<0>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<1>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<2>(array_shape));
+
+		// Write array
+		const auto& size = get_size();
+		const auto* buffer = get_buffer();
+		for (auto i = 0; i < size; i++) {
+			writer.writeNumeric<std::uint32_t>(buffer[i]);
+		}
+	}
+	std::shared_ptr<IndexArray3D> IndexArray3D::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			// Read array shape
+			auto array_shape = std::make_tuple(
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>()
+			);
+
+			// Construct instance
+			auto self = std::make_shared<IndexArray3D>(array_shape);
+
+			// Read array
+			const auto& size = self->get_size();
+			auto* buffer = self->get_buffer();
+			for (auto i = 0; i < size; i++) {
+				buffer[i] = reader.readNumeric<std::uint32_t>();
+			}
+
+			return self;
+		}
+		default:
+			throw std::invalid_argument("Unsupported IndexArray3D version " + std::to_string(version));
+		}
+	}
+
+	void SectionArrayMap::serialise(BinaryWriter& writer) const {
+		writer.writeNumeric<std::uint8_t>(1);
+		
+		// Write array shape
+		const auto& array_shape = get_array_shape();
+		writer.writeNumeric<std::uint16_t>(std::get<0>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<1>(array_shape));
+		writer.writeNumeric<std::uint16_t>(std::get<2>(array_shape));
+		
+		// Write default array
+		std::visit(
+			[&writer](auto&& arg) {
+				using T = std::decay_t<decltype(arg)>;
+				if constexpr (std::is_same_v<T, std::uint32_t>) {
+					writer.writeNumeric<std::uint8_t>(0);
+					writer.writeNumeric<std::uint32_t>(arg);
+				}
+				else {
+					writer.writeNumeric<std::uint8_t>(1);
+					arg->serialise(writer);
+				}
+			}, 
+			get_default_array()
+		);
+
+		// Write arrays
+		const auto& arrays = get_arrays();
+		writer.writeNumeric<std::uint64_t>(arrays.size());
+		for (const auto& [cy, arr] : arrays) {
+			writer.writeNumeric<std::int64_t>(cy);
+			arr->serialise(writer);
+		}
+	}
+	std::shared_ptr<SectionArrayMap> SectionArrayMap::deserialise(BinaryReader& reader) {
+		auto version = reader.readNumeric<std::uint8_t>();
+		switch (version) {
+		case 1:
+		{
+			// Read array shape
+			auto array_shape = std::make_tuple(
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>(),
+				reader.readNumeric<std::uint16_t>()
+			);
+
+			// Read default array
+			auto default_array_state = reader.readNumeric<std::uint8_t>();
+			std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> default_array;
+			switch (default_array_state) {
+			case 0:
+				default_array = reader.readNumeric<std::uint32_t>();
+				break;
+			case 1:
+				default_array = IndexArray3D::deserialise(reader);
+				break;
+			default:
+				throw std::invalid_argument("Invalid default array state value " + std::to_string(default_array_state));
+			}
+
+			// Construct instance
+			auto self = std::make_shared<SectionArrayMap>(array_shape, default_array);
+			
+			// Populate arrays
+			auto array_count = reader.readNumeric<std::uint64_t>();
+			for (auto i = 0; i < array_count; i++) {
+				auto cy = reader.readNumeric<std::int64_t>();
+				self->set_section(cy, IndexArray3D::deserialise(reader));
+			}
+			
+			return self;
+		}
+		default:
+			throw std::invalid_argument("Unsupported BlockComponentData version " + std::to_string(version));
+		}
+	}
+}

amulet/chunk_components/section_array_map.hpp

@@ -0,0 +1,147 @@
+#pragma once
+
+#include <tuple>
+#include <unordered_map>
+#include <variant>
+#include <cstdint>
+#include <vector>
+#include <span>
+#include <cstdlib>
+#include <type_traits>
+#include <memory>
+#include <stdexcept>
+
+#include <amulet/io/binary_writer.hpp>
+#include <amulet/io/binary_reader.hpp>
+
+
+namespace Amulet {
+	namespace detail {
+		template <typename T>
+		inline std::unique_ptr<T*> new_buffer(size_t count) {
+			T* buffer = (T*) std::malloc(sizeof(T) * count);
+			if (buffer == nullptr) {
+				throw std::runtime_error("Could not allocate buffer");
+			}
+			return std::make_unique<T*>(buffer);
+		}
+	}
+
+	typedef std::tuple<std::uint16_t, std::uint16_t, std::uint16_t> SectionShape;
+
+	class IndexArray3D {
+	private:
+		SectionShape _shape;
+		size_t _size;
+		std::unique_ptr<std::uint32_t*> _buffer;
+	public:
+		IndexArray3D(const SectionShape& shape) :
+			_shape(shape),
+			_size(std::get<0>(shape)* std::get<1>(shape)* std::get<2>(shape)),
+			_buffer(detail::new_buffer<std::uint32_t>(_size))
+		{}
+		IndexArray3D(const SectionShape& shape, std::uint32_t value) :
+			IndexArray3D(shape) {
+			std::fill_n(*_buffer, _size, value);
+		}
+		IndexArray3D(const IndexArray3D& other):
+			IndexArray3D(other.get_shape())
+		{
+			std::memcpy(*_buffer, *other._buffer, sizeof(std::uint32_t) * other.get_size());
+		}
+
+		void serialise(BinaryWriter&) const;
+		static std::shared_ptr<IndexArray3D> deserialise(BinaryReader&);
+
+		const SectionShape& get_shape() const {
+			return _shape;
+		}
+		const size_t& get_size() const { return _size; }
+		std::uint32_t* get_buffer() const { return *_buffer; }
+	};
+
+	namespace detail {
+		inline void validate_array_shape(
+			const std::shared_ptr<IndexArray3D>& default_array,
+			const SectionShape& array_shape
+		) {
+			if (default_array->get_shape() != array_shape) {
+				throw std::invalid_argument("Array shape does not match required shape.");
+			}
+		}
+
+		inline void validate_array_shape(
+			const std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>>& default_array,
+			const SectionShape& array_shape
+		) {
+			if (std::holds_alternative<std::shared_ptr<IndexArray3D>>(default_array)) {
+				validate_array_shape(std::get<std::shared_ptr<IndexArray3D>>(default_array), array_shape);
+			}
+		}
+	}
+
+	class SectionArrayMap {
+	private:
+		SectionShape _array_shape;
+		std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> _default_array;
+		std::unordered_map<std::int64_t, std::shared_ptr<IndexArray3D>> _arrays;
+	public:
+		SectionArrayMap(
+			const SectionShape& array_shape,
+			std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> default_array
+		) : _array_shape(array_shape), _default_array(default_array), _arrays() {
+			detail::validate_array_shape(_default_array, _array_shape);
+		}
+
+		void serialise(BinaryWriter&) const;
+		static std::shared_ptr<SectionArrayMap> deserialise(BinaryReader&);
+
+		const SectionShape& get_array_shape() const { return _array_shape; }
+		
+		std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> get_default_array() const { return _default_array; }
+		
+		void set_default_array(std::variant<std::uint32_t, std::shared_ptr<IndexArray3D>> default_array) {
+			detail::validate_array_shape(default_array, _array_shape);
+			_default_array = default_array;
+		}
+
+		const std::unordered_map<std::int64_t, std::shared_ptr<IndexArray3D>>& get_arrays() const {
+			return _arrays;
+		}
+
+		size_t get_size() const { return _arrays.size(); }
+
+		bool contains_section(std::int64_t cy) const {
+			return _arrays.contains(cy);
+		}
+
+		std::shared_ptr<IndexArray3D> get_section(std::int64_t cy) const {
+			return _arrays.at(cy);
+		}
+
+		void set_section(std::int64_t cy, std::shared_ptr<IndexArray3D> section) {
+			detail::validate_array_shape(section, _array_shape);
+			_arrays[cy] = section;
+		}
+
+		void populate_section(std::int64_t cy) {
+			if (_arrays.contains(cy)) {
+				return;
+			}
+			std::visit([this, &cy](auto&& arg) {
+				using T = std::decay_t<decltype(arg)>;
+				if constexpr (std::is_same_v<T, std::uint32_t>) {
+					_arrays[cy] = std::make_shared<IndexArray3D>(_array_shape, arg);
+				}
+				else {
+					_arrays[cy] = std::make_shared<IndexArray3D>(*arg);
+				}
+				}, _default_array);
+		}
+
+		void del_section(std::int64_t cy) {
+			_arrays.erase(cy);
+		}
+	};
+
+}

amulet/chunk_components.pyi

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import collections.abc
 import types
 import typing
 
@@ -8,6 +9,7 @@ import amulet.collections
 import amulet.palette.block_palette
 import amulet.version
 import numpy
+import numpy.typing
 import typing_extensions
 
 __all__ = ["BlockComponent", "BlockComponentData", "IndexArray3D", "SectionArrayMap"]
@@ -33,11 +35,6 @@ class IndexArray3D:
     A 3D index array.
     """
 
-    def __buffer__(self, flags):
-        """
-        Return a buffer object that exposes the underlying memory of the object.
-        """
-
     @typing.overload
     def __init__(self, shape: tuple[int, int, int]) -> None: ...
     @typing.overload
@@ -46,11 +43,6 @@ class IndexArray3D:
     def __init__(self, other: IndexArray3D) -> None: ...
     @typing.overload
     def __init__(self, arg0: typing_extensions.Buffer) -> None: ...
-    def __release_buffer__(self, buffer):
-        """
-        Release the buffer object that exposes the underlying memory of the object.
-        """
-
     @property
     def shape(self) -> tuple[int, int, int]: ...
     @property
@@ -64,7 +56,7 @@ class SectionArrayMap:
     def __contains__(self, arg0: int) -> bool: ...
     def __delitem__(self, arg0: int) -> None: ...
     def __eq__(self, arg0: typing.Any) -> bool | types.NotImplementedType: ...
-    def __getitem__(self, arg0: int) -> typing.Any: ...
+    def __getitem__(self, arg0: int) -> numpy.typing.NDArray[numpy.uint32]: ...
     def __hash__(self) -> int: ...
     def __init__(
         self,
@@ -76,15 +68,25 @@ class SectionArrayMap:
     def __setitem__(
         self, arg0: int, arg1: IndexArray3D | typing_extensions.Buffer
     ) -> None: ...
-    def get(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
-    def items(self) -> typing.Any: ...
-    def keys(self) -> typing.Any: ...
-    def pop(self, key: typing.Any, default: typing.Any = ...) -> typing.Any: ...
-    def popitem(self) -> tuple[typing.Any, typing.Any]: ...
+    def get(
+        self, arg0: int, arg1: numpy.typing.NDArray[numpy.uint32] | None
+    ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
+    def items(
+        self,
+    ) -> collections.abc.ItemsView[int, numpy.typing.NDArray[numpy.uint32]]: ...
+    def keys(self) -> collections.abc.KeysView[int]: ...
+    def pop(
+        self, key: int, default: numpy.typing.NDArray[numpy.uint32] = ...
+    ) -> numpy.typing.NDArray[numpy.uint32]: ...
+    def popitem(self) -> tuple[int, numpy.typing.NDArray[numpy.uint32]]: ...
     def populate(self, arg0: int) -> None: ...
-    def setdefault(self, arg0: typing.Any, arg1: typing.Any) -> typing.Any: ...
+    def setdefault(
+        self, arg0: int, arg1: numpy.typing.NDArray[numpy.uint32] | None
+    ) -> numpy.typing.NDArray[numpy.uint32] | None: ...
     def update(self, other: typing.Any = (), **kwargs) -> None: ...
-    def values(self) -> typing.Any: ...
+    def values(
+        self,
+    ) -> collections.abc.ValuesView[numpy.typing.NDArray[numpy.uint32]]: ...
     @property
     def array_shape(self) -> tuple[int, int, int]: ...
     @property

amulet/collections/eq.py.hpp

@@ -0,0 +1,37 @@
+#pragma once
+// Better type hinting for equality methods that pybind11 has natively
+
+#include <variant>
+#include <amulet/pybind11/types.hpp>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+template <typename R, typename clsT>
+void Eq(clsT cls) {
+    cls.def(
+        "__eq__",
+        [](const typename clsT::type& self, R other) {
+            return self == other;
+        }
+    );
+}
+
+
+template <typename clsT>
+void Eq(clsT cls) {
+    Eq<const typename clsT::type&>(cls);
+}
+
+
+template <typename clsT>
+void Eq_default(clsT cls) {
+    py::object NotImplemented = py::module::import("builtins").attr("NotImplemented");
+    cls.def(
+        "__eq__",
+        [NotImplemented](const typename clsT::type& self, py::object other) -> std::variant<bool, Amulet::pybind11::types::NotImplementedType> {
+            return NotImplemented;
+        }
+    );
+}

amulet/collections/hash.py.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+
+template <typename clsT>
+void hash_default(clsT cls) {
+    cls.def(
+        "__hash__",
+        [](py::object self) -> py::int_ {
+            return py::module::import("builtins").attr("id")(self);
+        }
+    );
+}
+
+
+template <typename clsT>
+void hash_disable(clsT cls) {
+    cls.def(
+        "__hash__",
+        [](py::object self) -> size_t {
+            throw py::type_error("This class is not hashable.");
+        }
+    );
+}

amulet/collections/holder.py.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace Amulet {
+namespace collections {
+
+	// A class to allow python to hold a reference to a smart pointer
+	class Holder {
+	public:
+		virtual ~Holder() {}
+	};
+
+	template <typename T>
+	class HolderTemplate: public Holder {
+	private:
+		T value;
+	public:
+		HolderTemplate(T&& value): value(std::move(value)){}
+	};
+
+	template <typename T>
+	static py::object make_holder(T&& value) {
+		return py::cast(
+			static_cast<std::unique_ptr<Holder>>(
+				std::make_unique<HolderTemplate<T>>(
+					std::move(value)
+				)
+			)
+		);
+	}
+
+}
+}

amulet/collections/iterator.py.hpp

@@ -0,0 +1,80 @@
+#pragma once
+#include <stdexcept>
+
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+namespace Amulet {
+namespace collections {
+	class Iterator {
+	public:
+		virtual ~Iterator() {};
+		virtual bool has_next() = 0;
+		virtual py::object next() = 0;
+	};
+
+	// An iterator for the collections.abc.Sequence protocol.
+	class PySequenceIterator: public Iterator {
+	private:
+		py::object obj;
+		size_t index;
+		std::ptrdiff_t step;
+	public:
+		PySequenceIterator(
+			py::object obj,
+			size_t start,
+			std::ptrdiff_t step
+		) : obj(obj), index(start), step(step) {};
+		bool has_next() override{ 
+			return 0 <= index && index < py::len(obj); 
+		};
+		py::object next() override {
+			py::object item = obj.attr("__getitem__")(index);
+			index += step;
+			return item;
+		};
+	};
+
+	// An iterator for a C++ map-like object.
+	template <typename mapT>
+	class MapIterator: public Iterator {
+	private:
+		py::object owner;
+		const mapT& map;
+		typename mapT::const_iterator begin;
+		typename mapT::const_iterator end;
+		typename mapT::const_iterator pos;
+		size_t size;
+
+	public:
+		MapIterator(const mapT& map, py::object owner = py::none()) :
+			owner(owner),
+			map(map),
+			begin(map.begin()),
+			end(map.end()),
+			pos(map.begin()),
+			size(map.size())
+		{}
+
+		bool has_next() override {
+			return pos != end;
+		}
+
+		bool is_valid() {
+			// This is not fool proof.
+			// There are cases where this is true but the iterator is invalid.
+			// The programmer should write good code and this will catch some of the bad cases.
+			return size == map.size() && begin == map.begin() && end == map.end();
+		}
+
+		py::object next() override {
+			if (!is_valid()) {
+				throw std::runtime_error("map changed size during iteration.");
+			}
+			return py::cast((pos++)->first);
+		}
+	};
+
+}
+}