amulet-core 2.0a5__cp312-cp312-win_amd64.whl → 2.0a6__cp312-cp312-win_amd64.whl

amulet/collections/mutable_mapping.py.hpp

@@ -0,0 +1,215 @@
+#pragma once
+
+#include <memory>
+
+#include <pybind11/pybind11.h>
+
+#include "mapping.py.hpp"
+
+namespace py = pybind11;
+
+namespace Amulet {
+namespace collections {
+	template <typename clsT>
+	void PyMutableMapping_pop(clsT cls) {
+		py::object marker = py::module::import("builtins").attr("Ellipsis");
+		cls.def(
+			"pop",
+			[marker](py::object self, py::object key, py::object default_) {
+				py::object value;
+				try {
+					value = self.attr("__getitem__")(key);
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						if (default_.is(marker)) {
+							throw;
+						}
+						return default_;
+					}
+					else {
+						throw;
+					}
+				}
+				self.attr("__delitem__")(key);
+				return value;
+			},
+			py::arg("key"),
+			py::arg("default") = marker
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_popitem(clsT cls) {
+		py::object iter = py::module::import("builtins").attr("iter");
+		py::object next = py::module::import("builtins").attr("next");
+		cls.def(
+			"popitem",
+			[iter, next](py::object self) {
+				py::object key;
+				try {
+					key = next(iter(self));
+				} 
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_StopIteration)) {
+						throw py::key_error();
+					}
+					else {
+						throw;
+					}
+				}
+				py::object value = self.attr("__getitem__")(key);
+				self.attr("__delitem__")(key);
+				return std::make_pair(key, value);
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_clear(clsT cls) {
+		cls.def(
+			"clear",
+			[](py::object self) {
+				try {
+					while (true) {
+						self.attr("popitem")();
+					}
+				}
+				catch (const py::error_already_set& e) {
+					if (!e.matches(PyExc_KeyError)) {
+						throw;
+					}
+				}
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_update(clsT cls) {
+		py::object isinstance = py::module::import("builtins").attr("isinstance");
+		py::object hasattr = py::module::import("builtins").attr("hasattr");
+		py::object PyMapping = py::module::import("collections.abc").attr("Mapping");
+		cls.def(
+			"update",
+			[
+				isinstance, 
+				hasattr, 
+				PyMapping
+			](
+				py::object self, 
+				py::object other, 
+				py::kwargs kwargs
+			) {
+				if (isinstance(other, PyMapping)) {
+					for (auto it = other.begin(); it != other.end(); it++) {
+						self.attr("__setitem__")(*it, other.attr("__getitem__")(*it));
+					}
+				}
+				else if (hasattr(other, "keys")) {
+					py::object keys = other.attr("keys")();
+					for (auto it = keys.begin(); it != keys.end(); it++) {
+						self.attr("__setitem__")(*it, other.attr("__getitem__")(*it));
+					}
+				}
+				else {
+					for (auto it = other.begin(); it != other.end(); it++) {
+						self.attr("__setitem__")(
+							*it->attr("__getitem__")(0),
+							*it->attr("__getitem__")(1)
+						);
+					}
+				}
+				py::object items = kwargs.attr("items")();
+				for (auto it = items.begin(); it != items.end(); it++) {
+					self.attr("__setitem__")(
+						*it->attr("__getitem__")(0),
+						*it->attr("__getitem__")(1)
+					);
+				}
+
+			},
+			py::arg("other") = py::tuple()
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_setdefault(clsT cls) {
+		cls.def(
+			"setdefault",
+			[](py::object self, py::object key, py::object default_ = py::none()) {
+				try {
+					return self.attr("__getitem__")(key);
+				}
+				catch (const py::error_already_set& e) {
+					if (e.matches(PyExc_KeyError)) {
+						self.attr("__setitem__")(key, default_);
+					}
+					else {
+						throw;
+					}
+				}
+				return default_;
+			}
+		);
+	}
+
+	template <typename clsT>
+	void PyMutableMapping_register(clsT cls) {
+		py::module::import("collections.abc").attr("MutableMapping").attr("register")(cls);
+	}
+
+	class MutableMapping : public Mapping {
+	public:
+		virtual ~MutableMapping() {};
+		virtual void setitem(py::object py_key, py::object py_value) = 0;
+		virtual void delitem(py::object py_key) = 0;
+		virtual void clear() = 0;
+	};
+
+	template <typename mapT>
+	class Map : public MutableMapping {
+	private:
+		py::object _owner;
+		mapT& _map;
+	public:
+		Map(
+			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>());
+		}
+		void setitem(py::object py_key, py::object py_value) override {
+			_map.insert_or_assign(
+				py_key.cast<typename mapT::key_type>(),
+				py_value.cast<typename mapT::mapped_type>()
+			);
+		}
+		void delitem(py::object py_key) override {
+			_map.erase(py_key.cast<typename mapT::key_type>());
+		}
+		void clear() override {
+			_map.clear();
+		}
+	};
+
+	template <typename mapT>
+	static py::object make_map(mapT& value, py::object owner = py::none()) {
+		return py::cast(
+			static_cast<std::shared_ptr<MutableMapping>>(
+				std::make_shared<Map<mapT>>(value, owner)
+			)
+		);
+	}
+}
+}

amulet/collections/sequence.py.hpp

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+
+#include <pybind11/pybind11.h>
+#include "iterator.py.hpp"
+#include <amulet/pybind11/collections.hpp>
+#include <amulet/pybind11/python.hpp>
+
+namespace py = pybind11;
+
+namespace Amulet {
+	namespace collections {
+
+		template <typename clsT>
+		void Sequence_getitem_slice(clsT cls) {
+			cls.def(
+				"__getitem__",
+				[](py::object self, const py::slice& slice) {
+					size_t start = 0, stop = 0, step = 0, slicelength = 0;
+					if (!slice.compute(py::len(self), &start, &stop, &step, &slicelength)) {
+						throw py::error_already_set();
+					}
+					py::list out(slicelength);
+					py::object getitem = self.attr("__getitem__");
+					for (size_t i = 0; i < slicelength; ++i) {
+						out[i] = getitem(start);
+						start += step;
+					}
+					return out;
+				}
+			);
+		}
+
+		template <typename clsT>
+		void Sequence_contains(clsT cls) {
+			cls.def(
+				"__contains__",
+				[](py::object self, py::object value) {
+					py::iterator it = py::iter(self);
+					while (it != py::iterator::sentinel()) {
+						if (py::equals(*it, value)) {
+							return true;
+						}
+						++it;
+					}
+					return false;
+				}
+			);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence_iter(clsT cls) {
+			cls.def(
+				"__iter__",
+				[](py::object self) -> py::collections::Iterator<elemT> {
+					return py::cast(
+						static_cast<std::shared_ptr<Amulet::collections::Iterator>>(
+							std::make_shared<PySequenceIterator>(self, 0, 1)
+						)
+					);
+				}
+			);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence_reversed(clsT cls) {
+			cls.def(
+				"__reversed__",
+				[](py::object self) -> py::collections::Iterator<elemT> {
+					return py::cast(
+						static_cast<std::shared_ptr<Amulet::collections::Iterator>>(
+							std::make_shared<PySequenceIterator>(self, py::len(self) - 1, -1)
+						)
+					);
+				}
+			);
+		}
+
+		template <typename clsT>
+		void Sequence_index(clsT cls) {
+			cls.def(
+				"index",
+				[](py::object self, py::object value, Py_ssize_t s_start, Py_ssize_t s_stop) {
+					size_t size = py::len(self);
+					size_t start;
+					size_t stop;
+					if (s_start < 0) {
+						start = std::max<Py_ssize_t>(0, size + s_start);
+					}
+					else {
+						start = s_start;
+					}
+					if (s_stop < 0) {
+						stop = size + s_stop;
+					}
+					else {
+						stop = s_stop;
+					}
+					py::object getitem = self.attr("__getitem__");
+					while (start < stop) {
+						py::object obj;
+						try {
+							obj = getitem(start);
+						}
+						catch (py::error_already_set& e) {
+							if (e.matches(PyExc_IndexError)) {
+								break;
+							}
+							else {
+								throw;
+							}
+						}
+
+						if (py::equals(value, obj)) {
+							return start;
+						}
+
+						start++;
+					}
+					throw py::value_error("");
+				},
+				py::arg("value"), py::arg("start") = 0, py::arg("stop") = std::numeric_limits<Py_ssize_t>::max()
+					);
+		}
+
+		template <typename clsT>
+		void Sequence_count(clsT cls) {
+			cls.def(
+				"count",
+				[](py::object self, py::object value) {
+					size_t count = 0;
+					size_t size = py::len(self);
+					py::object getitem = self.attr("__getitem__");
+					for (size_t i = 0; i < size; ++i) {
+						if (py::equals(value, getitem(i))) {
+							count++;
+						}
+					}
+					return count;
+				},
+				py::arg("value")
+					);
+		}
+
+		template <typename clsT>
+		void Sequence_register(clsT cls) {
+			py::module::import("collections.abc").attr("Sequence").attr("register")(cls);
+		}
+
+		template <typename elemT = py::object, typename clsT>
+		void Sequence(clsT cls) {
+			Sequence_getitem_slice(cls);
+			Sequence_contains(cls);
+			Sequence_iter<elemT>(cls);
+			Sequence_reversed<elemT>(cls);
+			Sequence_index(cls);
+			Sequence_count(cls);
+			Sequence_register(cls);
+		}
+	}
+}

amulet/io/binary_reader.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <bit>
+#include <functional>
+#include <stdexcept>
+#include <memory>
+
+#include <amulet_nbt/io/binary_reader.hpp>
+
+
+namespace Amulet {
+    class BinaryReader: public AmuletNBT::BinaryReader {
+    
+
+    public:
+        BinaryReader(
+            const std::string& input,
+            size_t& position
+        ) : AmuletNBT::BinaryReader(input, position, std::endian::little, [](const std::string& value) {return value; }) {}
+
+        std::string readSizeAndBytes() {
+            std::uint64_t length;
+            readNumericInto<std::uint64_t>(length);
+            // Ensure the buffer is long enough
+            if (position + length > data.size()) {
+                throw std::out_of_range("Cannot read string of length " + std::to_string(length) + " at position " + std::to_string(position));
+            }
+
+            std::string value = data.substr(position, length);
+            position += length;
+            return value;
+        }
+    };
+
+    template <class T>
+    std::shared_ptr<T> deserialise(const std::string& data){
+        size_t position = 0;
+        BinaryReader reader(data, position);
+        return T::deserialise(reader);
+    }
+}

amulet/io/binary_writer.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <bit>
+#include <functional>
+
+#include <amulet_nbt/io/binary_writer.hpp>
+
+
+namespace Amulet {
+    class BinaryWriter: public AmuletNBT::BinaryWriter {
+        public:
+            BinaryWriter(): AmuletNBT::BinaryWriter(std::endian::little, [](const std::string& value) {return value; }) {}
+
+            void writeSizeAndBytes(const std::string& value) {
+                writeNumeric<std::uint64_t>(value.size());
+                data.append(value);
+            }
+    };
+
+    template <typename T>
+    std::string serialise(const T& obj){
+        BinaryWriter writer;
+        obj.serialise(writer);
+        return writer.getBuffer();
+    }
+}