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

amulet/chunk_components/section_array_map.hpp

@@ -1,147 +0,0 @@
-#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/collections/eq.py.hpp

@@ -1,37 +0,0 @@
-#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

@@ -1,27 +0,0 @@
-#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

@@ -1,37 +0,0 @@
-#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

@@ -1,80 +0,0 @@
-#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);
-		}
-	};
-
-}
-}

amulet/collections/mapping.py.hpp

@@ -1,199 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include <pybind11/pybind11.h>
-#include <pybind11/typing.h>
-
-#include <amulet/pybind11/types.hpp>
-#include <amulet/pybind11/type_hints.hpp>
-#include <amulet/pybind11/collections.hpp>
-#include "iterator.py.hpp"
-
-namespace py = pybind11;
-
-namespace Amulet {
-namespace collections {
-	template <typename clsT>
-	void PyMapping_repr(clsT cls) {
-		cls.def(
-			"__repr__",
-			[](py::object self) {
-				std::string repr = "{";
-				bool is_first = true;
-				for (auto it = self.begin(); it != self.end(); it++) {
-					if (is_first) {
-						is_first = false;
-					}
-					else {
-						repr += ", ";
-					}
-					repr += py::repr(*it);
-					repr += ": ";
-					repr += py::repr(self.attr("__getitem__")(*it));
-				}
-				repr += "}";
-				return repr;
-			}
-		);
-	}
-
-	template <typename KT = py::object, typename clsT>
-	void PyMapping_contains(clsT cls) {
-		cls.def(
-			"__contains__",
-			[](py::object self, Amulet::pybind11::type_hints::PyObjectCpp<KT> key) {
-				try {
-					self.attr("__getitem__")(key);
-					return true;
-				}
-				catch (const py::error_already_set& e) {
-					if (e.matches(PyExc_KeyError)) {
-						return false;
-					}
-					else {
-						throw;
-					}
-				}
-			}
-		);
-	}
-
-	template <typename KT = py::object, typename clsT>
-	void PyMapping_keys(clsT cls) {
-		py::object KeysView = py::module::import("collections.abc").attr("KeysView");
-		cls.def(
-			"keys",
-			[KeysView](py::object self) -> Amulet::pybind11::collections::KeysView<KT> { return KeysView(self); }
-		);
-	}
-
-	template <typename VT = py::object, typename clsT>
-	void PyMapping_values(clsT cls) {
-		py::object ValuesView = py::module::import("collections.abc").attr("ValuesView");
-		cls.def(
-			"values",
-			[ValuesView](py::object self) -> Amulet::pybind11::collections::ValuesView<VT> { return ValuesView(self); }
-		);
-	}
-
-	template <typename KT = py::object, typename VT = py::object, typename clsT>
-	void PyMapping_items(clsT cls) {
-		py::object ItemsView = py::module::import("collections.abc").attr("ItemsView");
-		cls.def(
-			"items",
-			[ItemsView](py::object self) -> Amulet::pybind11::collections::ItemsView<KT, VT> { return ItemsView(self); }
-		);
-	}
-
-	template <typename KT = py::object, typename VT = py::object, typename clsT>
-	void PyMapping_get(clsT cls) {
-		cls.def(
-			"get",
-			[](
-				py::object self, 
-				Amulet::pybind11::type_hints::PyObjectCpp<KT> key, 
-				py::typing::Optional<VT> default_ = py::none()
-			) -> py::typing::Optional<VT> {
-				try {
-					return self.attr("__getitem__")(key);
-				}
-				catch (const py::error_already_set& e) {
-					if (e.matches(PyExc_KeyError)) {
-						return default_;
-					}
-					else {
-						throw;
-					}
-				}
-			}
-		);
-	}
-
-	template <typename clsT>
-	void PyMapping_eq(clsT cls) {
-		py::object dict = py::module::import("builtins").attr("dict");
-		py::object isinstance = py::module::import("builtins").attr("isinstance");
-		py::object NotImplemented = py::module::import("builtins").attr("NotImplemented");
-		py::object PyMapping = py::module::import("collections.abc").attr("Mapping");
-		cls.def(
-			"__eq__",
-			[
-				dict,
-				isinstance, 
-				NotImplemented,
-				PyMapping
-			](
-				py::object self, 
-				py::object other
-			) -> std::variant<bool, Amulet::pybind11::types::NotImplementedType> {
-				if (!isinstance(other, PyMapping)) {
-					return NotImplemented;
-				}
-				return dict(self.attr("items")()).equal(dict(other.attr("items")()).cast<py::dict>());
-			}
-		);
-	}
-
-	template <typename clsT>
-	void PyMapping_hash(clsT cls) {
-		cls.def(
-			"__hash__",
-			[](
-				py::object self
-			) -> size_t {
-				throw py::type_error("Mapping is not hashable");
-			}
-		);
-	}
-
-	template <typename clsT>
-	void PyMapping_register(clsT cls) {
-		py::module::import("collections.abc").attr("Mapping").attr("register")(cls);
-	}
-
-	class Mapping {
-	public:
-		virtual ~Mapping() {};
-		virtual py::object getitem(py::object py_key) const = 0;
-		virtual std::shared_ptr<Iterator> iter() const = 0;
-		virtual size_t size() const = 0;
-		virtual bool contains(py::object py_key) const = 0;
-	};
-
-	template <typename mapT>
-	class ConstMap : public Mapping {
-	private:
-		py::object _owner;
-		const mapT& _map;
-	public:
-		ConstMap(
-			const mapT& map,
-			py::object owner = py::none()
-		) : _owner(owner), _map(map) {}
-
-		py::object getitem(py::object py_key) const override {
-			return py::cast(_map.at(py_key.cast<typename mapT::key_type>()));
-		}
-		std::shared_ptr<Iterator> iter() const override {
-			return std::make_shared<MapIterator<mapT>>(_map, _owner);
-		}
-		size_t size() const override {
-			return _map.size();
-		}
-		bool contains(py::object py_key) const override {
-			return _map.contains(py_key.cast<typename mapT::key_type>());
-		}
-	};
-
-	template <typename mapT>
-	static py::object make_const_map(const mapT& value, py::object owner = py::none()) {
-		return py::cast(
-			static_cast<std::shared_ptr<Mapping>>(
-				std::make_shared<ConstMap<mapT>>(value, owner)
-			)
-		);
-	}
-
-}
-}