Add 'libnbtplusplus/' from commit '1a0ffe372f4da8408c5d08a36013536a3396b9e6'

git-subtree-dir: libnbtplusplus
git-subtree-mainline: 7fb132859fda54aa96bc9dd46d302b343eeb5a02
git-subtree-split: 1a0ffe372f4da8408c5d08a36013536a3396b9e6

21 files changed, 2636 insertions, 0 deletions

diff --git a/libnbtplusplus/include/crtp_tag.h b/libnbtplusplus/include/crtp_tag.h
new file mode 100644
index 0000000000..91c629732d
--- /dev/null
+++ b/libnbtplusplus/include/crtp_tag.h
@@ -0,0 +1,95 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef CRTP_TAG_H_INCLUDED
+#define CRTP_TAG_H_INCLUDED
+
+#include "tag.h"
+#include "nbt_visitor.h"
+#include "make_unique.h"
+
+namespace nbt
+{
+
+	namespace detail
+	{
+
+		template <class Sub> class crtp_tag : public tag
+		{
+		  public:
+			// Pure virtual destructor to make the class abstract
+			virtual ~crtp_tag() noexcept = 0;
+
+			tag_type get_type() const noexcept override final
+			{
+				return Sub::type;
+			};
+
+			std::unique_ptr<tag> clone() const& override final
+			{
+				return make_unique<Sub>(sub_this());
+			}
+			std::unique_ptr<tag> move_clone() && override final
+			{
+				return make_unique<Sub>(std::move(sub_this()));
+			}
+
+			tag& assign(tag&& rhs) override final
+			{
+				return sub_this() = dynamic_cast<Sub&&>(rhs);
+			}
+
+			void accept(nbt_visitor& visitor) override final
+			{
+				visitor.visit(sub_this());
+			}
+			void accept(const_nbt_visitor& visitor) const override final
+			{
+				visitor.visit(sub_this());
+			}
+
+		  private:
+			bool equals(const tag& rhs) const override final
+			{
+				return sub_this() == static_cast<const Sub&>(rhs);
+			}
+
+			Sub& sub_this()
+			{
+				return static_cast<Sub&>(*this);
+			}
+			const Sub& sub_this() const
+			{
+				return static_cast<const Sub&>(*this);
+			}
+		};
+
+		template <class Sub> crtp_tag<Sub>::~crtp_tag() noexcept {}
+
+	} // namespace detail
+
+} // namespace nbt
+
+#endif // CRTP_TAG_H_INCLUDED
diff --git a/libnbtplusplus/include/endian_str.h b/libnbtplusplus/include/endian_str.h
new file mode 100644
index 0000000000..a21a87f94b
--- /dev/null
+++ b/libnbtplusplus/include/endian_str.h
@@ -0,0 +1,114 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef ENDIAN_STR_H_INCLUDED
+#define ENDIAN_STR_H_INCLUDED
+
+#include <cstdint>
+#include <iosfwd>
+#include "nbt_export.h"
+
+/**
+ * @brief Reading and writing numbers from and to streams
+ * in binary format with different byte orders.
+ */
+namespace endian
+{
+
+	enum endian { little, big };
+
+	/// Reads number from stream in specified endian
+	template <class T> void read(std::istream& is, T& x, endian e);
+
+	/// Reads number from stream in little endian
+	NBT_EXPORT void read_little(std::istream& is, uint8_t& x);
+	NBT_EXPORT void read_little(std::istream& is, uint16_t& x);
+	NBT_EXPORT void read_little(std::istream& is, uint32_t& x);
+	NBT_EXPORT void read_little(std::istream& is, uint64_t& x);
+	NBT_EXPORT void read_little(std::istream& is, int8_t& x);
+	NBT_EXPORT void read_little(std::istream& is, int16_t& x);
+	NBT_EXPORT void read_little(std::istream& is, int32_t& x);
+	NBT_EXPORT void read_little(std::istream& is, int64_t& x);
+	NBT_EXPORT void read_little(std::istream& is, float& x);
+	NBT_EXPORT void read_little(std::istream& is, double& x);
+
+	/// Reads number from stream in big endian
+	NBT_EXPORT void read_big(std::istream& is, uint8_t& x);
+	NBT_EXPORT void read_big(std::istream& is, uint16_t& x);
+	NBT_EXPORT void read_big(std::istream& is, uint32_t& x);
+	NBT_EXPORT void read_big(std::istream& is, uint64_t& x);
+	NBT_EXPORT void read_big(std::istream& is, int8_t& x);
+	NBT_EXPORT void read_big(std::istream& is, int16_t& x);
+	NBT_EXPORT void read_big(std::istream& is, int32_t& x);
+	NBT_EXPORT void read_big(std::istream& is, int64_t& x);
+	NBT_EXPORT void read_big(std::istream& is, float& x);
+	NBT_EXPORT void read_big(std::istream& is, double& x);
+
+	/// Writes number to stream in specified endian
+	template <class T> void write(std::ostream& os, T x, endian e);
+
+	/// Writes number to stream in little endian
+	NBT_EXPORT void write_little(std::ostream& os, uint8_t x);
+	NBT_EXPORT void write_little(std::ostream& os, uint16_t x);
+	NBT_EXPORT void write_little(std::ostream& os, uint32_t x);
+	NBT_EXPORT void write_little(std::ostream& os, uint64_t x);
+	NBT_EXPORT void write_little(std::ostream& os, int8_t x);
+	NBT_EXPORT void write_little(std::ostream& os, int16_t x);
+	NBT_EXPORT void write_little(std::ostream& os, int32_t x);
+	NBT_EXPORT void write_little(std::ostream& os, int64_t x);
+	NBT_EXPORT void write_little(std::ostream& os, float x);
+	NBT_EXPORT void write_little(std::ostream& os, double x);
+
+	/// Writes number to stream in big endian
+	NBT_EXPORT void write_big(std::ostream& os, uint8_t x);
+	NBT_EXPORT void write_big(std::ostream& os, uint16_t x);
+	NBT_EXPORT void write_big(std::ostream& os, uint32_t x);
+	NBT_EXPORT void write_big(std::ostream& os, uint64_t x);
+	NBT_EXPORT void write_big(std::ostream& os, int8_t x);
+	NBT_EXPORT void write_big(std::ostream& os, int16_t x);
+	NBT_EXPORT void write_big(std::ostream& os, int32_t x);
+	NBT_EXPORT void write_big(std::ostream& os, int64_t x);
+	NBT_EXPORT void write_big(std::ostream& os, float x);
+	NBT_EXPORT void write_big(std::ostream& os, double x);
+
+	template <class T> void read(std::istream& is, T& x, endian e)
+	{
+		if (e == little)
+			read_little(is, x);
+		else
+			read_big(is, x);
+	}
+
+	template <class T> void write(std::ostream& os, T x, endian e)
+	{
+		if (e == little)
+			write_little(os, x);
+		else
+			write_big(os, x);
+	}
+
+} // namespace endian
+
+#endif // ENDIAN_STR_H_INCLUDED
diff --git a/libnbtplusplus/include/io/izlibstream.h b/libnbtplusplus/include/io/izlibstream.h
new file mode 100644
index 0000000000..c2a8e59b04
--- /dev/null
+++ b/libnbtplusplus/include/io/izlibstream.h
@@ -0,0 +1,107 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef IZLIBSTREAM_H_INCLUDED
+#define IZLIBSTREAM_H_INCLUDED
+
+#include "io/zlib_streambuf.h"
+#include <istream>
+#include <zlib.h>
+
+namespace zlib
+{
+
+	/**
+	 * @brief Stream buffer used by zlib::izlibstream
+	 * @sa izlibstream
+	 */
+	class NBT_EXPORT inflate_streambuf : public zlib_streambuf
+	{
+	  public:
+		/**
+		 * @param input the istream to wrap
+		 * @param bufsize the size of the internal buffers
+		 * @param window_bits the base two logarithm of the maximum window size
+		 * that zlib will use. This parameter also determines which type of
+		 * input to expect. The default argument will autodetect between zlib
+		 * and gzip data. Refer to the zlib documentation of inflateInit2 for
+		 * more details.
+		 *
+		 * @throw zlib_error if zlib encounters a problem during initialization
+		 */
+		explicit inflate_streambuf(std::istream& input, size_t bufsize = 32768,
+								   int window_bits = 32 + 15);
+		~inflate_streambuf() noexcept;
+
+		///@return the wrapped istream
+		std::istream& get_istr() const
+		{
+			return is;
+		}
+
+	  private:
+		std::istream& is;
+		bool stream_end;
+
+		int_type underflow() override;
+	};
+
+	/**
+	 * @brief An istream adapter that decompresses data using zlib
+	 *
+	 * This istream wraps another istream. The izlibstream will read compressed
+	 * data from the wrapped istream and inflate (decompress) it with zlib.
+	 *
+	 * @note If you want to read more data from the wrapped istream after the
+	 * end of the compressed data, then it must allow seeking. It is unavoidable
+	 * for the izlibstream to consume more data after the compressed data. It
+	 * will automatically attempt to seek the wrapped istream back to the point
+	 * after the end of the compressed data.
+	 * @sa inflate_streambuf
+	 */
+	class NBT_EXPORT izlibstream : public std::istream
+	{
+	  public:
+		/**
+		 * @param input the istream to wrap
+		 * @param bufsize the size of the internal buffers
+		 */
+		explicit izlibstream(std::istream& input, size_t bufsize = 32768)
+			: std::istream(&buf), buf(input, bufsize)
+		{
+		}
+		///@return the wrapped istream
+		std::istream& get_istr() const
+		{
+			return buf.get_istr();
+		}
+
+	  private:
+		inflate_streambuf buf;
+	};
+
+} // namespace zlib
+
+#endif // IZLIBSTREAM_H_INCLUDED
diff --git a/libnbtplusplus/include/io/ozlibstream.h b/libnbtplusplus/include/io/ozlibstream.h
new file mode 100644
index 0000000000..f04f33deef
--- /dev/null
+++ b/libnbtplusplus/include/io/ozlibstream.h
@@ -0,0 +1,120 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef OZLIBSTREAM_H_INCLUDED
+#define OZLIBSTREAM_H_INCLUDED
+
+#include "io/zlib_streambuf.h"
+#include <ostream>
+#include <zlib.h>
+
+namespace zlib
+{
+
+	/**
+	 * @brief Stream buffer used by zlib::ozlibstream
+	 * @sa ozlibstream
+	 */
+	class NBT_EXPORT deflate_streambuf : public zlib_streambuf
+	{
+	  public:
+		/**
+		 * @param output the ostream to wrap
+		 * @param bufsize the size of the internal buffers
+		 * @param level the compression level, ranges from 0 to 9, or -1 for
+		 * default
+		 *
+		 * Refer to the zlib documentation of deflateInit2 for details about the
+		 * arguments.
+		 *
+		 * @throw zlib_error if zlib encounters a problem during initialization
+		 */
+		explicit deflate_streambuf(std::ostream& output, size_t bufsize = 32768,
+								   int level = Z_DEFAULT_COMPRESSION,
+								   int window_bits = 15, int mem_level = 8,
+								   int strategy = Z_DEFAULT_STRATEGY);
+		~deflate_streambuf() noexcept;
+
+		///@return the wrapped ostream
+		std::ostream& get_ostr() const
+		{
+			return os;
+		}
+
+		/// Finishes compression and writes all pending data to the output
+		void close();
+
+	  private:
+		std::ostream& os;
+
+		void deflate_chunk(int flush = Z_NO_FLUSH);
+
+		int_type overflow(int_type ch) override;
+		int sync() override;
+	};
+
+	/**
+	 * @brief An ostream adapter that compresses data using zlib
+	 *
+	 * This ostream wraps another ostream. Data written to an ozlibstream will
+	 * be deflated (compressed) with zlib and written to the wrapped ostream.
+	 *
+	 * @sa deflate_streambuf
+	 */
+	class NBT_EXPORT ozlibstream : public std::ostream
+	{
+	  public:
+		/**
+		 * @param output the ostream to wrap
+		 * @param level the compression level, ranges from 0 to 9, or -1 for
+		 * default
+		 * @param gzip if true, the output will be in gzip format rather than
+		 * zlib
+		 * @param bufsize the size of the internal buffers
+		 */
+		explicit ozlibstream(std::ostream& output,
+							 int level = Z_DEFAULT_COMPRESSION,
+							 bool gzip = false, size_t bufsize = 32768)
+			: std::ostream(&buf),
+			  buf(output, bufsize, level, 15 + (gzip ? 16 : 0))
+		{
+		}
+
+		///@return the wrapped ostream
+		std::ostream& get_ostr() const
+		{
+			return buf.get_ostr();
+		}
+
+		/// Finishes compression and writes all pending data to the output
+		void close();
+
+	  private:
+		deflate_streambuf buf;
+	};
+
+} // namespace zlib
+
+#endif // OZLIBSTREAM_H_INCLUDED
diff --git a/libnbtplusplus/include/io/stream_reader.h b/libnbtplusplus/include/io/stream_reader.h
new file mode 100644
index 0000000000..05f8d99c92
--- /dev/null
+++ b/libnbtplusplus/include/io/stream_reader.h
@@ -0,0 +1,150 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef STREAM_READER_H_INCLUDED
+#define STREAM_READER_H_INCLUDED
+
+#include "endian_str.h"
+#include "tag.h"
+#include "tag_compound.h"
+#include <iosfwd>
+#include <memory>
+#include <stdexcept>
+#include <utility>
+
+namespace nbt
+{
+	namespace io
+	{
+
+		/// Exception that gets thrown when reading is not successful
+		class NBT_EXPORT input_error : public std::runtime_error
+		{
+			using std::runtime_error::runtime_error;
+		};
+
+		/**
+		 * @brief Reads a named tag from the stream, making sure that it is a
+		 * compound
+		 * @param is the stream to read from
+		 * @param e the byte order of the source data. The Java edition
+		 * of Minecraft uses Big Endian, the Pocket edition uses Little Endian
+		 * @throw input_error on failure, or if the tag in the stream is not a
+		 * compound
+		 */
+		NBT_EXPORT std::pair<std::string, std::unique_ptr<tag_compound>>
+		read_compound(std::istream& is, endian::endian e = endian::big);
+
+		/**
+		 * @brief Reads a named tag from the stream
+		 * @param is the stream to read from
+		 * @param e the byte order of the source data. The Java edition
+		 * of Minecraft uses Big Endian, the Pocket edition uses Little Endian
+		 * @throw input_error on failure
+		 */
+		NBT_EXPORT std::pair<std::string, std::unique_ptr<tag>>
+		read_tag(std::istream& is, endian::endian e = endian::big);
+
+		/**
+		 * @brief Helper class for reading NBT tags from input streams
+		 *
+		 * Can be reused to read multiple tags
+		 */
+		class NBT_EXPORT stream_reader
+		{
+		  public:
+			/**
+			 * @param is the stream to read from
+			 * @param e the byte order of the source data. The Java edition
+			 * of Minecraft uses Big Endian, the Pocket edition uses Little
+			 * Endian
+			 */
+			explicit stream_reader(std::istream& is,
+								   endian::endian e = endian::big) noexcept;
+
+			/// Returns the stream
+			std::istream& get_istr() const;
+			/// Returns the byte order
+			endian::endian get_endian() const;
+
+			/**
+			 * @brief Reads a named tag from the stream, making sure that it is
+			 * a compound
+			 * @throw input_error on failure, or if the tag in the stream is not
+			 * a compound
+			 */
+			std::pair<std::string, std::unique_ptr<tag_compound>>
+			read_compound();
+
+			/**
+			 * @brief Reads a named tag from the stream
+			 * @throw input_error on failure
+			 */
+			std::pair<std::string, std::unique_ptr<tag>> read_tag();
+
+			/**
+			 * @brief Reads a tag of the given type without name from the stream
+			 * @throw input_error on failure
+			 */
+			std::unique_ptr<tag> read_payload(tag_type type);
+
+			/**
+			 * @brief Reads a tag type from the stream
+			 * @param allow_end whether to consider tag_type::End valid
+			 * @throw input_error on failure
+			 */
+			tag_type read_type(bool allow_end = false);
+
+			/**
+			 * @brief Reads a binary number from the stream
+			 *
+			 * On failure, will set the failbit on the stream.
+			 */
+			template <class T> void read_num(T& x);
+
+			/**
+			 * @brief Reads an NBT string from the stream
+			 *
+			 * An NBT string consists of two bytes indicating the length,
+			 * followed by the characters encoded in modified UTF-8.
+			 * @throw input_error on failure
+			 */
+			std::string read_string();
+
+		  private:
+			std::istream& is;
+			int depth = 0;
+			const endian::endian endian;
+		};
+
+		template <class T> void stream_reader::read_num(T& x)
+		{
+			endian::read(is, x, endian);
+		}
+
+	} // namespace io
+} // namespace nbt
+
+#endif // STREAM_READER_H_INCLUDED
diff --git a/libnbtplusplus/include/io/stream_writer.h b/libnbtplusplus/include/io/stream_writer.h
new file mode 100644
index 0000000000..04f039948c
--- /dev/null
+++ b/libnbtplusplus/include/io/stream_writer.h
@@ -0,0 +1,142 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef STREAM_WRITER_H_INCLUDED
+#define STREAM_WRITER_H_INCLUDED
+
+#include "tag.h"
+#include "endian_str.h"
+#include <iosfwd>
+#include <string>
+
+namespace nbt
+{
+	namespace io
+	{
+
+		/* Not sure if that is even needed
+		///Exception that gets thrown when writing is not successful
+		class output_error : public std::runtime_error
+		{
+			using std::runtime_error::runtime_error;
+		};*/
+
+		/**
+		 * @brief Writes a named tag into the stream, including the tag type
+		 * @param key the name of the tag
+		 * @param t the tag
+		 * @param os the stream to write to
+		 * @param e the byte order of the written data. The Java edition
+		 * of Minecraft uses Big Endian, the Pocket edition uses Little Endian
+		 */
+		NBT_EXPORT void write_tag(const std::string& key, const tag& t,
+								  std::ostream& os,
+								  endian::endian e = endian::big);
+
+		/**
+		 * @brief Helper class for writing NBT tags to output streams
+		 *
+		 * Can be reused to write multiple tags
+		 */
+		class NBT_EXPORT stream_writer
+		{
+		  public:
+			/// Maximum length of an NBT string (16 bit unsigned)
+			static constexpr size_t max_string_len = UINT16_MAX;
+			/// Maximum length of an NBT list or array (32 bit signed)
+			static constexpr uint32_t max_array_len = INT32_MAX;
+
+			/**
+			 * @param os the stream to write to
+			 * @param e the byte order of the written data. The Java edition
+			 * of Minecraft uses Big Endian, the Pocket edition uses Little
+			 * Endian
+			 */
+			explicit stream_writer(std::ostream& os,
+								   endian::endian e = endian::big) noexcept
+				: os(os), endian(e)
+			{
+			}
+
+			/// Returns the stream
+			std::ostream& get_ostr() const
+			{
+				return os;
+			}
+			/// Returns the byte order
+			endian::endian get_endian() const
+			{
+				return endian;
+			}
+
+			/**
+			 * @brief Writes a named tag into the stream, including the tag type
+			 */
+			void write_tag(const std::string& key, const tag& t);
+
+			/**
+			 * @brief Writes the given tag's payload into the stream
+			 */
+			void write_payload(const tag& t)
+			{
+				t.write_payload(*this);
+			}
+
+			/**
+			 * @brief Writes a tag type to the stream
+			 */
+			void write_type(tag_type tt)
+			{
+				write_num(static_cast<int8_t>(tt));
+			}
+
+			/**
+			 * @brief Writes a binary number to the stream
+			 */
+			template <class T> void write_num(T x);
+
+			/**
+			 * @brief Writes an NBT string to the stream
+			 *
+			 * An NBT string consists of two bytes indicating the length,
+			 * followed by the characters encoded in modified UTF-8.
+			 * @throw std::length_error if the string is too long for NBT
+			 */
+			void write_string(const std::string& str);
+
+		  private:
+			std::ostream& os;
+			const endian::endian endian;
+		};
+
+		template <class T> void stream_writer::write_num(T x)
+		{
+			endian::write(os, x, endian);
+		}
+
+	} // namespace io
+} // namespace nbt
+
+#endif // STREAM_WRITER_H_INCLUDED
diff --git a/libnbtplusplus/include/io/zlib_streambuf.h b/libnbtplusplus/include/io/zlib_streambuf.h
new file mode 100644
index 0000000000..91a660b9f2
--- /dev/null
+++ b/libnbtplusplus/include/io/zlib_streambuf.h
@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+#ifndef ZLIB_STREAMBUF_H_INCLUDED
+#define ZLIB_STREAMBUF_H_INCLUDED
+
+#include <stdexcept>
+#include <streambuf>
+#include <vector>
+#include <zlib.h>
+#include "nbt_export.h"
+
+namespace zlib
+{
+
+	/// Exception thrown in case zlib encounters a problem
+	class NBT_EXPORT zlib_error : public std::runtime_error
+	{
+	  public:
+		const int errcode;
+
+		zlib_error(const char* msg, int errcode)
+			: std::runtime_error(msg ? std::string(zError(errcode)) + ": " + msg
+									 : zError(errcode)),
+			  errcode(errcode)
+		{
+		}
+	};
+
+	/// Base class for deflate_streambuf and inflate_streambuf
+	class zlib_streambuf : public std::streambuf
+	{
+	  protected:
+		std::vector<char> in;
+		std::vector<char> out;
+		z_stream zstr;
+
+		explicit zlib_streambuf(size_t bufsize) : in(bufsize), out(bufsize)
+		{
+			zstr.zalloc = Z_NULL;
+			zstr.zfree = Z_NULL;
+			zstr.opaque = Z_NULL;
+		}
+	};
+
+} // namespace zlib
+
+#endif // ZLIB_STREAMBUF_H_INCLUDED
diff --git a/libnbtplusplus/include/make_unique.h b/libnbtplusplus/include/make_unique.h
new file mode 100644
index 0000000000..513cbcf69f
--- /dev/null
+++ b/libnbtplusplus/include/make_unique.h
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef MAKE_UNIQUE_H_INCLUDED
+#define MAKE_UNIQUE_H_INCLUDED
+
+#include <memory>
+
+namespace nbt
+{
+
+	/// Creates a new object of type T and returns a std::unique_ptr to it
+	template <class T, class... Args>
+	std::unique_ptr<T> make_unique(Args&&... args)
+	{
+		return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+	}
+
+} // namespace nbt
+
+#endif // MAKE_UNIQUE_H_INCLUDED
diff --git a/libnbtplusplus/include/nbt_tags.h b/libnbtplusplus/include/nbt_tags.h
new file mode 100644
index 0000000000..bcab332919
--- /dev/null
+++ b/libnbtplusplus/include/nbt_tags.h
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include "tag_primitive.h"
+#include "tag_string.h"
+#include "tag_array.h"
+#include "tag_list.h"
+#include "tag_compound.h"
diff --git a/libnbtplusplus/include/nbt_visitor.h b/libnbtplusplus/include/nbt_visitor.h
new file mode 100644
index 0000000000..e244162f83
--- /dev/null
+++ b/libnbtplusplus/include/nbt_visitor.h
@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef NBT_VISITOR_H_INCLUDED
+#define NBT_VISITOR_H_INCLUDED
+
+#include "tagfwd.h"
+
+namespace nbt
+{
+
+	/**
+	 * @brief Base class for visitors of tags
+	 *
+	 * Implementing the Visitor pattern
+	 */
+	class nbt_visitor
+	{
+	  public:
+		virtual ~nbt_visitor() noexcept = 0; // Abstract class
+
+		virtual void visit(tag_byte&) {}
+		virtual void visit(tag_short&) {}
+		virtual void visit(tag_int&) {}
+		virtual void visit(tag_long&) {}
+		virtual void visit(tag_float&) {}
+		virtual void visit(tag_double&) {}
+		virtual void visit(tag_byte_array&) {}
+		virtual void visit(tag_string&) {}
+		virtual void visit(tag_list&) {}
+		virtual void visit(tag_compound&) {}
+		virtual void visit(tag_int_array&) {}
+		virtual void visit(tag_long_array&) {}
+	};
+
+	/**
+	 * @brief Base class for visitors of constant tags
+	 *
+	 * Implementing the Visitor pattern
+	 */
+	class const_nbt_visitor
+	{
+	  public:
+		virtual ~const_nbt_visitor() noexcept = 0; // Abstract class
+
+		virtual void visit(const tag_byte&) {}
+		virtual void visit(const tag_short&) {}
+		virtual void visit(const tag_int&) {}
+		virtual void visit(const tag_long&) {}
+		virtual void visit(const tag_float&) {}
+		virtual void visit(const tag_double&) {}
+		virtual void visit(const tag_byte_array&) {}
+		virtual void visit(const tag_string&) {}
+		virtual void visit(const tag_list&) {}
+		virtual void visit(const tag_compound&) {}
+		virtual void visit(const tag_int_array&) {}
+		virtual void visit(const tag_long_array&) {}
+	};
+
+	inline nbt_visitor::~nbt_visitor() noexcept {}
+
+	inline const_nbt_visitor::~const_nbt_visitor() noexcept {}
+
+} // namespace nbt
+
+#endif // NBT_VISITOR_H_INCLUDED
diff --git a/libnbtplusplus/include/primitive_detail.h b/libnbtplusplus/include/primitive_detail.h
new file mode 100644
index 0000000000..c55cd18398
--- /dev/null
+++ b/libnbtplusplus/include/primitive_detail.h
@@ -0,0 +1,74 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef PRIMITIVE_DETAIL_H_INCLUDED
+#define PRIMITIVE_DETAIL_H_INCLUDED
+
+#include <type_traits>
+
+///@cond
+namespace nbt
+{
+
+	namespace detail
+	{
+		/// Meta-struct that holds the tag_type value for a specific primitive
+		/// type
+		template <class T> struct get_primitive_type {
+			static_assert(sizeof(T) != sizeof(T),
+						  "Invalid type paramter for tag_primitive, can only "
+						  "use types that NBT uses");
+		};
+
+		template <>
+		struct get_primitive_type<int8_t>
+			: public std::integral_constant<tag_type, tag_type::Byte> {
+		};
+		template <>
+		struct get_primitive_type<int16_t>
+			: public std::integral_constant<tag_type, tag_type::Short> {
+		};
+		template <>
+		struct get_primitive_type<int32_t>
+			: public std::integral_constant<tag_type, tag_type::Int> {
+		};
+		template <>
+		struct get_primitive_type<int64_t>
+			: public std::integral_constant<tag_type, tag_type::Long> {
+		};
+		template <>
+		struct get_primitive_type<float>
+			: public std::integral_constant<tag_type, tag_type::Float> {
+		};
+		template <>
+		struct get_primitive_type<double>
+			: public std::integral_constant<tag_type, tag_type::Double> {
+		};
+	} // namespace detail
+
+} // namespace nbt
+///@endcond
+
+#endif // PRIMITIVE_DETAIL_H_INCLUDED
diff --git a/libnbtplusplus/include/tag.h b/libnbtplusplus/include/tag.h
new file mode 100644
index 0000000000..92432cf55a
--- /dev/null
+++ b/libnbtplusplus/include/tag.h
@@ -0,0 +1,175 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_H_INCLUDED
+#define TAG_H_INCLUDED
+
+#include <cstdint>
+#include <iosfwd>
+#include <memory>
+#include "nbt_export.h"
+
+namespace nbt
+{
+
+	/// Tag type values used in the binary format
+	enum class tag_type : int8_t {
+		End = 0,
+		Byte = 1,
+		Short = 2,
+		Int = 3,
+		Long = 4,
+		Float = 5,
+		Double = 6,
+		Byte_Array = 7,
+		String = 8,
+		List = 9,
+		Compound = 10,
+		Int_Array = 11,
+		Long_Array = 12,
+		Null = -1 ///< Used to denote empty @ref value s
+	};
+
+	/**
+	 * @brief Returns whether the given number falls within the range of valid
+	 * tag types
+	 * @param allow_end whether to consider tag_type::End (0) valid
+	 */
+	NBT_EXPORT bool is_valid_type(int type, bool allow_end = false);
+
+	// Forward declarations
+	class nbt_visitor;
+	class const_nbt_visitor;
+	namespace io
+	{
+		class stream_reader;
+		class stream_writer;
+	} // namespace io
+
+	/// Base class for all NBT tag classes
+	class NBT_EXPORT tag
+	{
+	  public:
+		// Virtual destructor
+		virtual ~tag() noexcept {}
+
+		/// Returns the type of the tag
+		virtual tag_type get_type() const noexcept = 0;
+
+		// Polymorphic clone methods
+		virtual std::unique_ptr<tag> clone() const& = 0;
+		virtual std::unique_ptr<tag> move_clone() && = 0;
+		std::unique_ptr<tag> clone() &&;
+
+		/**
+		 * @brief Returns a reference to the tag as an instance of T
+		 * @throw std::bad_cast if the tag is not of type T
+		 */
+		template <class T> T& as();
+		template <class T> const T& as() const;
+
+		/**
+		 * @brief Move-assigns the given tag if the class is the same
+		 * @throw std::bad_cast if @c rhs is not the same type as @c *this
+		 */
+		virtual tag& assign(tag&& rhs) = 0;
+
+		/**
+		 * @brief Calls the appropriate overload of @c visit() on the visitor
+		 * with
+		 * @c *this as argument
+		 *
+		 * Implementing the Visitor pattern
+		 */
+		virtual void accept(nbt_visitor& visitor) = 0;
+		virtual void accept(const_nbt_visitor& visitor) const = 0;
+
+		/**
+		 * @brief Reads the tag's payload from the stream
+		 * @throw io::stream_reader::input_error on failure
+		 */
+		virtual void read_payload(io::stream_reader& reader) = 0;
+
+		/**
+		 * @brief Writes the tag's payload into the stream
+		 */
+		virtual void write_payload(io::stream_writer& writer) const = 0;
+
+		/**
+		 * @brief Default-constructs a new tag of the given type
+		 * @throw std::invalid_argument if the type is not valid (e.g. End or
+		 * Null)
+		 */
+		static std::unique_ptr<tag> create(tag_type type);
+		/**
+		 * @brief Constructs a numeric tag of the given type and value
+		 * @throw std::invalid_argument if the type is not numeric
+		 */
+		static std::unique_ptr<tag> create(tag_type type, int8_t val);
+		static std::unique_ptr<tag> create(tag_type type, int16_t val);
+		static std::unique_ptr<tag> create(tag_type type, int32_t val);
+		static std::unique_ptr<tag> create(tag_type type, int64_t val);
+		static std::unique_ptr<tag> create(tag_type type, float val);
+		static std::unique_ptr<tag> create(tag_type type, double val);
+
+		friend NBT_EXPORT bool operator==(const tag& lhs, const tag& rhs);
+		friend NBT_EXPORT bool operator!=(const tag& lhs, const tag& rhs);
+
+	  private:
+		/**
+		 * @brief Checks for equality to a tag of the same type
+		 * @param rhs an instance of the same class as @c *this
+		 */
+		virtual bool equals(const tag& rhs) const = 0;
+	};
+
+	/// Output operator for tag types
+	NBT_EXPORT std::ostream& operator<<(std::ostream& os, tag_type tt);
+
+	/**
+	 * @brief Output operator for tags
+	 *
+	 * Uses @ref text::json_formatter
+	 * @relates tag
+	 */
+	NBT_EXPORT std::ostream& operator<<(std::ostream& os, const tag& t);
+
+	template <class T> T& tag::as()
+	{
+		static_assert(std::is_base_of<tag, T>::value,
+					  "T must be a subclass of tag");
+		return dynamic_cast<T&>(*this);
+	}
+
+	template <class T> const T& tag::as() const
+	{
+		static_assert(std::is_base_of<tag, T>::value,
+					  "T must be a subclass of tag");
+		return dynamic_cast<const T&>(*this);
+	}
+
+} // namespace nbt
+
+#endif // TAG_H_INCLUDED
diff --git a/libnbtplusplus/include/tag_array.h b/libnbtplusplus/include/tag_array.h
new file mode 100644
index 0000000000..290680573f
--- /dev/null
+++ b/libnbtplusplus/include/tag_array.h
@@ -0,0 +1,306 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_ARRAY_H_INCLUDED
+#define TAG_ARRAY_H_INCLUDED
+
+#include "crtp_tag.h"
+#include "io/stream_reader.h"
+#include "io/stream_writer.h"
+#include <type_traits>
+#include <vector>
+#include <istream>
+
+namespace nbt
+{
+
+	///@cond
+	namespace detail
+	{
+		/// Meta-struct that holds the tag_type value for a specific array type
+		template <class T> struct get_array_type {
+			static_assert(sizeof(T) != sizeof(T),
+						  "Invalid type paramter for tag_array, can only use "
+						  "byte or int");
+		};
+
+		template <>
+		struct get_array_type<int8_t>
+			: public std::integral_constant<tag_type, tag_type::Byte_Array> {
+		};
+		template <>
+		struct get_array_type<int32_t>
+			: public std::integral_constant<tag_type, tag_type::Int_Array> {
+		};
+		template <>
+		struct get_array_type<int64_t>
+			: public std::integral_constant<tag_type, tag_type::Long_Array> {
+		};
+	} // namespace detail
+	///@cond
+
+	/**
+	 * @brief Tag that contains an array of byte or int values
+	 *
+	 * Common class for tag_byte_array, tag_int_array and tag_long_array.
+	 */
+	template <class T>
+	class tag_array final : public detail::crtp_tag<tag_array<T>>
+	{
+	  public:
+		// Iterator types
+		typedef typename std::vector<T>::iterator iterator;
+		typedef typename std::vector<T>::const_iterator const_iterator;
+
+		/// The type of the contained values
+		typedef T value_type;
+
+		/// The type of the tag
+		static constexpr tag_type type = detail::get_array_type<T>::value;
+
+		/// Constructs an empty array
+		tag_array() {}
+
+		/// Constructs an array with the given values
+		tag_array(std::initializer_list<T> init) : data(init) {}
+		tag_array(std::vector<T>&& vec) noexcept : data(std::move(vec)) {}
+
+		/// Returns a reference to the vector that contains the values
+		std::vector<T>& get()
+		{
+			return data;
+		}
+		const std::vector<T>& get() const
+		{
+			return data;
+		}
+
+		/**
+		 * @brief Accesses a value by index with bounds checking
+		 * @throw std::out_of_range if the index is out of range
+		 */
+		T& at(size_t i)
+		{
+			return data.at(i);
+		}
+		T at(size_t i) const
+		{
+			return data.at(i);
+		}
+
+		/**
+		 * @brief Accesses a value by index
+		 *
+		 * No bounds checking is performed.
+		 */
+		T& operator[](size_t i)
+		{
+			return data[i];
+		}
+		T operator[](size_t i) const
+		{
+			return data[i];
+		}
+
+		/// Appends a value at the end of the array
+		void push_back(T val)
+		{
+			data.push_back(val);
+		}
+
+		/// Removes the last element from the array
+		void pop_back()
+		{
+			data.pop_back();
+		}
+
+		/// Returns the number of values in the array
+		size_t size() const
+		{
+			return data.size();
+		}
+
+		/// Erases all values from the array.
+		void clear()
+		{
+			data.clear();
+		}
+
+		// Iterators
+		iterator begin()
+		{
+			return data.begin();
+		}
+		iterator end()
+		{
+			return data.end();
+		}
+		const_iterator begin() const
+		{
+			return data.begin();
+		}
+		const_iterator end() const
+		{
+			return data.end();
+		}
+		const_iterator cbegin() const
+		{
+			return data.cbegin();
+		}
+		const_iterator cend() const
+		{
+			return data.cend();
+		}
+
+		void read_payload(io::stream_reader& reader) override;
+		/**
+		 * @inheritdoc
+		 * @throw std::length_error if the array is too large for NBT
+		 */
+		void write_payload(io::stream_writer& writer) const override;
+
+	  private:
+		std::vector<T> data;
+	};
+
+	template <class T>
+	bool operator==(const tag_array<T>& lhs, const tag_array<T>& rhs)
+	{
+		return lhs.get() == rhs.get();
+	}
+	template <class T>
+	bool operator!=(const tag_array<T>& lhs, const tag_array<T>& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	// Slightly different between byte_array and int_array
+	// Reading
+	template <>
+	inline void tag_array<int8_t>::read_payload(io::stream_reader& reader)
+	{
+		int32_t length;
+		reader.read_num(length);
+		if (length < 0)
+			reader.get_istr().setstate(std::ios::failbit);
+		if (!reader.get_istr())
+			throw io::input_error("Error reading length of tag_byte_array");
+
+		data.resize(length);
+		reader.get_istr().read(reinterpret_cast<char*>(data.data()), length);
+		if (!reader.get_istr())
+			throw io::input_error("Error reading contents of tag_byte_array");
+	}
+
+	template <typename T>
+	inline void tag_array<T>::read_payload(io::stream_reader& reader)
+	{
+		int32_t length;
+		reader.read_num(length);
+		if (length < 0)
+			reader.get_istr().setstate(std::ios::failbit);
+		if (!reader.get_istr())
+			throw io::input_error("Error reading length of generic array tag");
+
+		data.clear();
+		data.reserve(length);
+		for (T i = 0; i < length; ++i) {
+			T val;
+			reader.read_num(val);
+			data.push_back(val);
+		}
+		if (!reader.get_istr())
+			throw io::input_error(
+				"Error reading contents of generic array tag");
+	}
+
+	template <>
+	inline void tag_array<int64_t>::read_payload(io::stream_reader& reader)
+	{
+		int32_t length;
+		reader.read_num(length);
+		if (length < 0)
+			reader.get_istr().setstate(std::ios::failbit);
+		if (!reader.get_istr())
+			throw io::input_error("Error reading length of tag_long_array");
+
+		data.clear();
+		data.reserve(length);
+		for (int32_t i = 0; i < length; ++i) {
+			int64_t val;
+			reader.read_num(val);
+			data.push_back(val);
+		}
+		if (!reader.get_istr())
+			throw io::input_error("Error reading contents of tag_long_array");
+	}
+
+	// Writing
+	template <>
+	inline void
+	tag_array<int8_t>::write_payload(io::stream_writer& writer) const
+	{
+		if (size() > io::stream_writer::max_array_len) {
+			writer.get_ostr().setstate(std::ios::failbit);
+			throw std::length_error("Byte array is too large for NBT");
+		}
+		writer.write_num(static_cast<int32_t>(size()));
+		writer.get_ostr().write(reinterpret_cast<const char*>(data.data()),
+								data.size());
+	}
+
+	template <typename T>
+	inline void tag_array<T>::write_payload(io::stream_writer& writer) const
+	{
+		if (size() > io::stream_writer::max_array_len) {
+			writer.get_ostr().setstate(std::ios::failbit);
+			throw std::length_error("Generic array is too large for NBT");
+		}
+		writer.write_num(static_cast<int32_t>(size()));
+		for (T i : data)
+			writer.write_num(i);
+	}
+
+	template <>
+	inline void
+	tag_array<int64_t>::write_payload(io::stream_writer& writer) const
+	{
+		if (size() > io::stream_writer::max_array_len) {
+			writer.get_ostr().setstate(std::ios::failbit);
+			throw std::length_error("Long array is too large for NBT");
+		}
+		writer.write_num(static_cast<int32_t>(size()));
+		for (int64_t i : data)
+			writer.write_num(i);
+	}
+
+	// Typedefs that should be used instead of the template tag_array.
+	typedef tag_array<int8_t> tag_byte_array;
+	typedef tag_array<int32_t> tag_int_array;
+	typedef tag_array<int64_t> tag_long_array;
+
+} // namespace nbt
+
+#endif // TAG_ARRAY_H_INCLUDED
diff --git a/libnbtplusplus/include/tag_compound.h b/libnbtplusplus/include/tag_compound.h
new file mode 100644
index 0000000000..3f342c6d2b
--- /dev/null
+++ b/libnbtplusplus/include/tag_compound.h
@@ -0,0 +1,185 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_COMPOUND_H_INCLUDED
+#define TAG_COMPOUND_H_INCLUDED
+
+#include "crtp_tag.h"
+#include "value_initializer.h"
+#include <map>
+#include <string>
+
+namespace nbt
+{
+
+	/// Tag that contains multiple unordered named tags of arbitrary types
+	class NBT_EXPORT tag_compound final : public detail::crtp_tag<tag_compound>
+	{
+		typedef std::map<std::string, value> map_t_;
+
+	  public:
+		// Iterator types
+		typedef map_t_::iterator iterator;
+		typedef map_t_::const_iterator const_iterator;
+
+		/// The type of the tag
+		static constexpr tag_type type = tag_type::Compound;
+
+		/// Constructs an empty compound
+		tag_compound() {}
+
+		/// Constructs a compound with the given key-value pairs
+		tag_compound(
+			std::initializer_list<std::pair<std::string, value_initializer>>
+				init);
+
+		/**
+		 * @brief Accesses a tag by key with bounds checking
+		 *
+		 * Returns a value to the tag with the specified key, or throws an
+		 * exception if it does not exist.
+		 * @throw std::out_of_range if given key does not exist
+		 */
+		value& at(const std::string& key);
+		const value& at(const std::string& key) const;
+
+		/**
+		 * @brief Accesses a tag by key
+		 *
+		 * Returns a value to the tag with the specified key. If it does not
+		 * exist, creates a new uninitialized entry under the key.
+		 */
+		value& operator[](const std::string& key)
+		{
+			return tags[key];
+		}
+
+		/**
+		 * @brief Inserts or assigns a tag
+		 *
+		 * If the given key already exists, assigns the tag to it.
+		 * Otherwise, it is inserted under the given key.
+		 * @return a pair of the iterator to the value and a bool indicating
+		 * whether the key did not exist
+		 */
+		std::pair<iterator, bool> put(const std::string& key,
+									  value_initializer&& val);
+
+		/**
+		 * @brief Inserts a tag if the key does not exist
+		 * @return a pair of the iterator to the value with the key and a bool
+		 * indicating whether the value was actually inserted
+		 */
+		std::pair<iterator, bool> insert(const std::string& key,
+										 value_initializer&& val);
+
+		/**
+		 * @brief Constructs and assigns or inserts a tag into the compound
+		 *
+		 * Constructs a new tag of type @c T with the given args and inserts
+		 * or assigns it to the given key.
+		 * @note Unlike std::map::emplace, this will overwrite existing values
+		 * @return a pair of the iterator to the value and a bool indicating
+		 * whether the key did not exist
+		 */
+		template <class T, class... Args>
+		std::pair<iterator, bool> emplace(const std::string& key,
+										  Args&&... args);
+
+		/**
+		 * @brief Erases a tag from the compound
+		 * @return true if a tag was erased
+		 */
+		bool erase(const std::string& key);
+
+		/// Returns true if the given key exists in the compound
+		bool has_key(const std::string& key) const;
+		/// Returns true if the given key exists and the tag has the given type
+		bool has_key(const std::string& key, tag_type type) const;
+
+		/// Returns the number of tags in the compound
+		size_t size() const
+		{
+			return tags.size();
+		}
+
+		/// Erases all tags from the compound
+		void clear()
+		{
+			tags.clear();
+		}
+
+		// Iterators
+		iterator begin()
+		{
+			return tags.begin();
+		}
+		iterator end()
+		{
+			return tags.end();
+		}
+		const_iterator begin() const
+		{
+			return tags.begin();
+		}
+		const_iterator end() const
+		{
+			return tags.end();
+		}
+		const_iterator cbegin() const
+		{
+			return tags.cbegin();
+		}
+		const_iterator cend() const
+		{
+			return tags.cend();
+		}
+
+		void read_payload(io::stream_reader& reader) override;
+		void write_payload(io::stream_writer& writer) const override;
+
+		friend bool operator==(const tag_compound& lhs, const tag_compound& rhs)
+		{
+			return lhs.tags == rhs.tags;
+		}
+		friend bool operator!=(const tag_compound& lhs, const tag_compound& rhs)
+		{
+			return !(lhs == rhs);
+		}
+
+	  private:
+		map_t_ tags;
+	};
+
+	template <class T, class... Args>
+	std::pair<tag_compound::iterator, bool>
+	tag_compound::emplace(const std::string& key, Args&&... args)
+	{
+		return put(key, value(make_unique<T>(std::forward<Args>(args)...)));
+	}
+
+} // namespace nbt
+
+#endif // TAG_COMPOUND_H_INCLUDED
diff --git a/libnbtplusplus/include/tag_list.h b/libnbtplusplus/include/tag_list.h
new file mode 100644
index 0000000000..eaa41bd65d
--- /dev/null
+++ b/libnbtplusplus/include/tag_list.h
@@ -0,0 +1,269 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_LIST_H_INCLUDED
+#define TAG_LIST_H_INCLUDED
+
+#include "crtp_tag.h"
+#include "tagfwd.h"
+#include "value_initializer.h"
+#include <stdexcept>
+#include <vector>
+
+namespace nbt
+{
+
+	/**
+	 * @brief Tag that contains multiple unnamed tags of the same type
+	 *
+	 * All the tags contained in the list have the same type, which can be
+	 * queried with el_type(). The types of the values contained in the list
+	 * should not be changed to mismatch the element type.
+	 *
+	 * If the list is empty, the type can be undetermined, in which case
+	 * el_type() will return tag_type::Null. The type will then be set when the
+	 * first tag is added to the list.
+	 */
+	class NBT_EXPORT tag_list final : public detail::crtp_tag<tag_list>
+	{
+	  public:
+		// Iterator types
+		typedef std::vector<value>::iterator iterator;
+		typedef std::vector<value>::const_iterator const_iterator;
+
+		/// The type of the tag
+		static constexpr tag_type type = tag_type::List;
+
+		/**
+		 * @brief Constructs a list of type T with the given values
+		 *
+		 * Example: @code tag_list::of<tag_byte>({3, 4, 5}) @endcode
+		 * @param init list of values from which the elements are constructed
+		 */
+		template <class T> static tag_list of(std::initializer_list<T> init);
+
+		/**
+		 * @brief Constructs an empty list
+		 *
+		 * The content type is determined when the first tag is added.
+		 */
+		tag_list() : tag_list(tag_type::Null) {}
+
+		/// Constructs an empty list with the given content type
+		explicit tag_list(tag_type content_type) : el_type_(content_type) {}
+
+		/// Constructs a list with the given contents
+		tag_list(std::initializer_list<int8_t> init);
+		tag_list(std::initializer_list<int16_t> init);
+		tag_list(std::initializer_list<int32_t> init);
+		tag_list(std::initializer_list<int64_t> init);
+		tag_list(std::initializer_list<float> init);
+		tag_list(std::initializer_list<double> init);
+		tag_list(std::initializer_list<std::string> init);
+		tag_list(std::initializer_list<tag_byte_array> init);
+		tag_list(std::initializer_list<tag_list> init);
+		tag_list(std::initializer_list<tag_compound> init);
+		tag_list(std::initializer_list<tag_int_array> init);
+		tag_list(std::initializer_list<tag_long_array> init);
+
+		/**
+		 * @brief Constructs a list with the given contents
+		 * @throw std::invalid_argument if the tags are not all of the same type
+		 */
+		tag_list(std::initializer_list<value> init);
+
+		/**
+		 * @brief Accesses a tag by index with bounds checking
+		 *
+		 * Returns a value to the tag at the specified index, or throws an
+		 * exception if it is out of range.
+		 * @throw std::out_of_range if the index is out of range
+		 */
+		value& at(size_t i);
+		const value& at(size_t i) const;
+
+		/**
+		 * @brief Accesses a tag by index
+		 *
+		 * Returns a value to the tag at the specified index. No bounds checking
+		 * is performed.
+		 */
+		value& operator[](size_t i)
+		{
+			return tags[i];
+		}
+		const value& operator[](size_t i) const
+		{
+			return tags[i];
+		}
+
+		/**
+		 * @brief Assigns a value at the given index
+		 * @throw std::invalid_argument if the type of the value does not match
+		 * the list's content type
+		 * @throw std::out_of_range if the index is out of range
+		 */
+		void set(size_t i, value&& val);
+
+		/**
+		 * @brief Appends the tag to the end of the list
+		 * @throw std::invalid_argument if the type of the tag does not match
+		 * the list's content type
+		 */
+		void push_back(value_initializer&& val);
+
+		/**
+		 * @brief Constructs and appends a tag to the end of the list
+		 * @throw std::invalid_argument if the type of the tag does not match
+		 * the list's content type
+		 */
+		template <class T, class... Args> void emplace_back(Args&&... args);
+
+		/// Removes the last element of the list
+		void pop_back()
+		{
+			tags.pop_back();
+		}
+
+		/// Returns the content type of the list, or tag_type::Null if
+		/// undetermined
+		tag_type el_type() const
+		{
+			return el_type_;
+		}
+
+		/// Returns the number of tags in the list
+		size_t size() const
+		{
+			return tags.size();
+		}
+
+		/// Erases all tags from the list. Preserves the content type.
+		void clear()
+		{
+			tags.clear();
+		}
+
+		/**
+		 * @brief Erases all tags from the list and changes the content type.
+		 * @param type the new content type. Can be tag_type::Null to leave it
+		 * undetermined.
+		 */
+		void reset(tag_type type = tag_type::Null);
+
+		// Iterators
+		iterator begin()
+		{
+			return tags.begin();
+		}
+		iterator end()
+		{
+			return tags.end();
+		}
+		const_iterator begin() const
+		{
+			return tags.begin();
+		}
+		const_iterator end() const
+		{
+			return tags.end();
+		}
+		const_iterator cbegin() const
+		{
+			return tags.cbegin();
+		}
+		const_iterator cend() const
+		{
+			return tags.cend();
+		}
+
+		/**
+		 * @inheritdoc
+		 * In case of a list of tag_end, the content type will be undetermined.
+		 */
+		void read_payload(io::stream_reader& reader) override;
+		/**
+		 * @inheritdoc
+		 * In case of a list of undetermined content type, the written type will
+		 * be tag_end.
+		 * @throw std::length_error if the list is too long for NBT
+		 */
+		void write_payload(io::stream_writer& writer) const override;
+
+		/**
+		 * @brief Equality comparison for lists
+		 *
+		 * Lists are considered equal if their content types and the contained
+		 * tags are equal.
+		 */
+		friend NBT_EXPORT bool operator==(const tag_list& lhs,
+										  const tag_list& rhs);
+		friend NBT_EXPORT bool operator!=(const tag_list& lhs,
+										  const tag_list& rhs);
+
+	  private:
+		std::vector<value> tags;
+		tag_type el_type_;
+
+		/**
+		 * Internally used initialization function that initializes the list
+		 * with tags of type T, with the constructor arguments of each T given
+		 * by il.
+		 * @param il list of values that are, one by one, given to a constructor
+		 * of T
+		 */
+		template <class T, class Arg> void init(std::initializer_list<Arg> il);
+	};
+
+	template <class T> tag_list tag_list::of(std::initializer_list<T> il)
+	{
+		tag_list result;
+		result.init<T, T>(il);
+		return result;
+	}
+
+	template <class T, class... Args>
+	void tag_list::emplace_back(Args&&... args)
+	{
+		if (el_type_ == tag_type::Null) // set content type if undetermined
+			el_type_ = T::type;
+		else if (el_type_ != T::type)
+			throw std::invalid_argument(
+				"The tag type does not match the list's content type");
+		tags.emplace_back(make_unique<T>(std::forward<Args>(args)...));
+	}
+
+	template <class T, class Arg>
+	void tag_list::init(std::initializer_list<Arg> init)
+	{
+		el_type_ = T::type;
+		tags.reserve(init.size());
+		for (const Arg& arg : init)
+			tags.emplace_back(nbt::make_unique<T>(arg));
+	}
+
+} // namespace nbt
+
+#endif // TAG_LIST_H_INCLUDED
diff --git a/libnbtplusplus/include/tag_primitive.h b/libnbtplusplus/include/tag_primitive.h
new file mode 100644
index 0000000000..e1b3fd28ea
--- /dev/null
+++ b/libnbtplusplus/include/tag_primitive.h
@@ -0,0 +1,136 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_PRIMITIVE_H_INCLUDED
+#define TAG_PRIMITIVE_H_INCLUDED
+
+#include "crtp_tag.h"
+#include "primitive_detail.h"
+#include "io/stream_reader.h"
+#include "io/stream_writer.h"
+#include <istream>
+#include <sstream>
+
+namespace nbt
+{
+
+	/**
+	 * @brief Tag that contains an integral or floating-point value
+	 *
+	 * Common class for tag_byte, tag_short, tag_int, tag_long, tag_float and
+	 * tag_double.
+	 */
+	template <class T>
+	class tag_primitive final : public detail::crtp_tag<tag_primitive<T>>
+	{
+	  public:
+		/// The type of the value
+		typedef T value_type;
+
+		/// The type of the tag
+		static constexpr tag_type type = detail::get_primitive_type<T>::value;
+
+		// Constructor
+		constexpr tag_primitive(T val = 0) noexcept : value(val) {}
+
+		// Getters
+		operator T&()
+		{
+			return value;
+		}
+		constexpr operator T() const
+		{
+			return value;
+		}
+		constexpr T get() const
+		{
+			return value;
+		}
+
+		// Setters
+		tag_primitive& operator=(T val)
+		{
+			value = val;
+			return *this;
+		}
+		void set(T val)
+		{
+			value = val;
+		}
+
+		void read_payload(io::stream_reader& reader) override;
+		void write_payload(io::stream_writer& writer) const override;
+
+	  private:
+		T value;
+	};
+
+	template <class T>
+	bool operator==(const tag_primitive<T>& lhs, const tag_primitive<T>& rhs)
+	{
+		return lhs.get() == rhs.get();
+	}
+	template <class T>
+	bool operator!=(const tag_primitive<T>& lhs, const tag_primitive<T>& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+	// Typedefs that should be used instead of the template tag_primitive.
+	typedef tag_primitive<int8_t> tag_byte;
+	typedef tag_primitive<int16_t> tag_short;
+	typedef tag_primitive<int32_t> tag_int;
+	typedef tag_primitive<int64_t> tag_long;
+	typedef tag_primitive<float> tag_float;
+	typedef tag_primitive<double> tag_double;
+
+	// Explicit instantiation declarations
+	extern template class NBT_EXPORT tag_primitive<int8_t>;
+	extern template class NBT_EXPORT tag_primitive<int16_t>;
+	extern template class NBT_EXPORT tag_primitive<int32_t>;
+	extern template class NBT_EXPORT tag_primitive<int64_t>;
+	extern template class NBT_EXPORT tag_primitive<float>;
+	extern template class NBT_EXPORT tag_primitive<double>;
+
+	template <class T>
+	void tag_primitive<T>::read_payload(io::stream_reader& reader)
+	{
+		reader.read_num(value);
+		if (!reader.get_istr()) {
+			std::ostringstream str;
+			str << "Error reading tag_" << type;
+			throw io::input_error(str.str());
+		}
+	}
+
+	template <class T>
+	void tag_primitive<T>::write_payload(io::stream_writer& writer) const
+	{
+		writer.write_num(value);
+	}
+
+} // namespace nbt
+
+#endif // TAG_PRIMITIVE_H_INCLUDED
diff --git a/libnbtplusplus/include/tag_string.h b/libnbtplusplus/include/tag_string.h
new file mode 100644
index 0000000000..ec08e3d7d5
--- /dev/null
+++ b/libnbtplusplus/include/tag_string.h
@@ -0,0 +1,109 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_STRING_H_INCLUDED
+#define TAG_STRING_H_INCLUDED
+
+#include "crtp_tag.h"
+#include <string>
+
+namespace nbt
+{
+
+	/// Tag that contains a UTF-8 string
+	class NBT_EXPORT tag_string final : public detail::crtp_tag<tag_string>
+	{
+	  public:
+		/// The type of the tag
+		static constexpr tag_type type = tag_type::String;
+
+		// Constructors
+		tag_string() {}
+		tag_string(const std::string& str) : value(str) {}
+		tag_string(std::string&& str) noexcept : value(std::move(str)) {}
+		tag_string(const char* str) : value(str) {}
+
+		// Getters
+		operator std::string&()
+		{
+			return value;
+		}
+		operator const std::string&() const
+		{
+			return value;
+		}
+		const std::string& get() const
+		{
+			return value;
+		}
+
+		// Setters
+		tag_string& operator=(const std::string& str)
+		{
+			value = str;
+			return *this;
+		}
+		tag_string& operator=(std::string&& str)
+		{
+			value = std::move(str);
+			return *this;
+		}
+		tag_string& operator=(const char* str)
+		{
+			value = str;
+			return *this;
+		}
+		void set(const std::string& str)
+		{
+			value = str;
+		}
+		void set(std::string&& str)
+		{
+			value = std::move(str);
+		}
+
+		void read_payload(io::stream_reader& reader) override;
+		/**
+		 * @inheritdoc
+		 * @throw std::length_error if the string is too long for NBT
+		 */
+		void write_payload(io::stream_writer& writer) const override;
+
+	  private:
+		std::string value;
+	};
+
+	inline bool operator==(const tag_string& lhs, const tag_string& rhs)
+	{
+		return lhs.get() == rhs.get();
+	}
+	inline bool operator!=(const tag_string& lhs, const tag_string& rhs)
+	{
+		return !(lhs == rhs);
+	}
+
+} // namespace nbt
+
+#endif // TAG_STRING_H_INCLUDED
diff --git a/libnbtplusplus/include/tagfwd.h b/libnbtplusplus/include/tagfwd.h
new file mode 100644
index 0000000000..7459e7ba08
--- /dev/null
+++ b/libnbtplusplus/include/tagfwd.h
@@ -0,0 +1,58 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file
+ * @brief Provides forward declarations for all tag classes
+ */
+#ifndef TAGFWD_H_INCLUDED
+#define TAGFWD_H_INCLUDED
+#include <cstdint>
+
+namespace nbt
+{
+
+	class tag;
+
+	template <class T> class tag_primitive;
+	typedef tag_primitive<int8_t> tag_byte;
+	typedef tag_primitive<int16_t> tag_short;
+	typedef tag_primitive<int32_t> tag_int;
+	typedef tag_primitive<int64_t> tag_long;
+	typedef tag_primitive<float> tag_float;
+	typedef tag_primitive<double> tag_double;
+
+	class tag_string;
+
+	template <class T> class tag_array;
+	typedef tag_array<int8_t> tag_byte_array;
+	typedef tag_array<int32_t> tag_int_array;
+	typedef tag_array<int64_t> tag_long_array;
+
+	class tag_list;
+	class tag_compound;
+
+} // namespace nbt
+
+#endif // TAGFWD_H_INCLUDED
diff --git a/libnbtplusplus/include/text/json_formatter.h b/libnbtplusplus/include/text/json_formatter.h
new file mode 100644
index 0000000000..923970f446
--- /dev/null
+++ b/libnbtplusplus/include/text/json_formatter.h
@@ -0,0 +1,54 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef JSON_FORMATTER_H_INCLUDED
+#define JSON_FORMATTER_H_INCLUDED
+
+#include "tagfwd.h"
+#include <ostream>
+#include "nbt_export.h"
+
+namespace nbt
+{
+	namespace text
+	{
+
+		/**
+		 * @brief Prints tags in a JSON-like syntax into a stream
+		 *
+		 * @todo Make it configurable and able to produce actual
+		 * standard-conformant JSON
+		 */
+		class NBT_EXPORT json_formatter
+		{
+		  public:
+			json_formatter() {}
+			void print(std::ostream& os, const tag& t) const;
+		};
+
+	} // namespace text
+} // namespace nbt
+
+#endif // JSON_FORMATTER_H_INCLUDED
diff --git a/libnbtplusplus/include/value.h b/libnbtplusplus/include/value.h
new file mode 100644
index 0000000000..08a23ab111
--- /dev/null
+++ b/libnbtplusplus/include/value.h
@@ -0,0 +1,255 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TAG_REF_PROXY_H_INCLUDED
+#define TAG_REF_PROXY_H_INCLUDED
+
+#include "tag.h"
+#include <string>
+#include <type_traits>
+
+namespace nbt
+{
+
+	/**
+	 * @brief Contains an NBT value of fixed type
+	 *
+	 * This class is a convenience wrapper for @c std::unique_ptr<tag>.
+	 * A value can contain any kind of tag or no tag (nullptr) and provides
+	 * operations for handling tags of which the type is not known at compile
+	 * time. Assignment or the set method on a value with no tag will fill in
+	 * the value.
+	 *
+	 * The rationale for the existance of this class is to provide a
+	 * type-erasured means of storing tags, especially when they are contained
+	 * in tag_compound or tag_list. The alternative would be directly using @c
+	 * std::unique_ptr<tag> and @c tag&, which is how it was done in libnbt++1.
+	 * The main drawback is that it becomes very cumbersome to deal with tags of
+	 * unknown type.
+	 *
+	 * For example, in this case it would not be possible to allow a syntax like
+	 * <tt>compound["foo"] = 42</tt>. If the key "foo" does not exist
+	 * beforehand, the left hand side could not have any sensible value if it
+	 * was of type
+	 * @c tag&.
+	 * Firstly, the compound tag would have to create a new tag_int there, but
+	 * it cannot know that the new tag is going to be assigned an integer. Also,
+	 * if the type was @c tag& and it allowed assignment of integers, that would
+	 * mean the tag base class has assignments and conversions like this. Which
+	 * means that all other tag classes would inherit them from the base class,
+	 * even though it does not make any sense to allow converting a tag_compound
+	 * into an integer. Attempts like this should be caught at compile time.
+	 *
+	 * This is why all the syntactic sugar for tags is contained in the value
+	 * class while the tag class only contains common operations for all tag
+	 * types.
+	 */
+	class NBT_EXPORT value
+	{
+	  public:
+		// Constructors
+		value() noexcept {}
+		explicit value(std::unique_ptr<tag>&& t) noexcept : tag_(std::move(t))
+		{
+		}
+		explicit value(tag&& t);
+
+		// Moving
+		value(value&&) noexcept = default;
+		value& operator=(value&&) noexcept = default;
+
+		// Copying
+		explicit value(const value& rhs);
+		value& operator=(const value& rhs);
+
+		/**
+		 * @brief Assigns the given value to the tag if the type matches
+		 * @throw std::bad_cast if the type of @c t is not the same as the type
+		 * of this value
+		 */
+		value& operator=(tag&& t);
+		void set(tag&& t);
+
+		// Conversion to tag
+		/**
+		 * @brief Returns the contained tag
+		 *
+		 * If the value is uninitialized, the behavior is undefined.
+		 */
+		operator tag&()
+		{
+			return get();
+		}
+		operator const tag&() const
+		{
+			return get();
+		}
+		tag& get()
+		{
+			return *tag_;
+		}
+		const tag& get() const
+		{
+			return *tag_;
+		}
+
+		/**
+		 * @brief Returns a reference to the contained tag as an instance of T
+		 * @throw std::bad_cast if the tag is not of type T
+		 */
+		template <class T> T& as();
+		template <class T> const T& as() const;
+
+		// Assignment of primitives and string
+		/**
+		 * @brief Assigns the given value to the tag if the type is compatible
+		 * @throw std::bad_cast if the value is not convertible to the tag type
+		 * via a widening conversion
+		 */
+		value& operator=(int8_t val);
+		value& operator=(int16_t val);
+		value& operator=(int32_t val);
+		value& operator=(int64_t val);
+		value& operator=(float val);
+		value& operator=(double val);
+
+		/**
+		 * @brief Assigns the given string to the tag if it is a tag_string
+		 * @throw std::bad_cast if the contained tag is not a tag_string
+		 */
+		value& operator=(const std::string& str);
+		value& operator=(std::string&& str);
+
+		// Conversions to primitives and string
+		/**
+		 * @brief Returns the contained value if the type is compatible
+		 * @throw std::bad_cast if the tag type is not convertible to the
+		 * desired type via a widening conversion
+		 */
+		explicit operator int8_t() const;
+		explicit operator int16_t() const;
+		explicit operator int32_t() const;
+		explicit operator int64_t() const;
+		explicit operator float() const;
+		explicit operator double() const;
+
+		/**
+		 * @brief Returns the contained string if the type is tag_string
+		 *
+		 * If the value is uninitialized, the behavior is undefined.
+		 * @throw std::bad_cast if the tag type is not tag_string
+		 */
+		explicit operator const std::string&() const;
+
+		/// Returns true if the value is not uninitialized
+		explicit operator bool() const
+		{
+			return tag_ != nullptr;
+		}
+
+		/**
+		 * @brief In case of a tag_compound, accesses a tag by key with bounds
+		 * checking
+		 *
+		 * If the value is uninitialized, the behavior is undefined.
+		 * @throw std::bad_cast if the tag type is not tag_compound
+		 * @throw std::out_of_range if given key does not exist
+		 * @sa tag_compound::at
+		 */
+		value& at(const std::string& key);
+		const value& at(const std::string& key) const;
+
+		/**
+		 * @brief In case of a tag_compound, accesses a tag by key
+		 *
+		 * If the value is uninitialized, the behavior is undefined.
+		 * @throw std::bad_cast if the tag type is not tag_compound
+		 * @sa tag_compound::operator[]
+		 */
+		value& operator[](const std::string& key);
+		value& operator[](const char* key); // need this overload because of
+											// conflict with built-in operator[]
+
+		/**
+		 * @brief In case of a tag_list, accesses a tag by index with bounds
+		 * checking
+		 *
+		 * If the value is uninitialized, the behavior is undefined.
+		 * @throw std::bad_cast if the tag type is not tag_list
+		 * @throw std::out_of_range if the index is out of range
+		 * @sa tag_list::at
+		 */
+		value& at(size_t i);
+		const value& at(size_t i) const;
+
+		/**
+		 * @brief In case of a tag_list, accesses a tag by index
+		 *
+		 * No bounds checking is performed. If the value is uninitialized, the
+		 * behavior is undefined.
+		 * @throw std::bad_cast if the tag type is not tag_list
+		 * @sa tag_list::operator[]
+		 */
+		value& operator[](size_t i);
+		const value& operator[](size_t i) const;
+
+		/// Returns a reference to the underlying std::unique_ptr<tag>
+		std::unique_ptr<tag>& get_ptr()
+		{
+			return tag_;
+		}
+		const std::unique_ptr<tag>& get_ptr() const
+		{
+			return tag_;
+		}
+		/// Resets the underlying std::unique_ptr<tag> to a different value
+		void set_ptr(std::unique_ptr<tag>&& t)
+		{
+			tag_ = std::move(t);
+		}
+
+		///@sa tag::get_type
+		tag_type get_type() const;
+
+		friend NBT_EXPORT bool operator==(const value& lhs, const value& rhs);
+		friend NBT_EXPORT bool operator!=(const value& lhs, const value& rhs);
+
+	  private:
+		std::unique_ptr<tag> tag_;
+	};
+
+	template <class T> T& value::as()
+	{
+		return tag_->as<T>();
+	}
+
+	template <class T> const T& value::as() const
+	{
+		return tag_->as<T>();
+	}
+
+} // namespace nbt
+
+#endif // TAG_REF_PROXY_H_INCLUDED
diff --git a/libnbtplusplus/include/value_initializer.h b/libnbtplusplus/include/value_initializer.h
new file mode 100644
index 0000000000..ad83dc16ee
--- /dev/null
+++ b/libnbtplusplus/include/value_initializer.h
@@ -0,0 +1,75 @@
+/*
+ * SPDX-FileCopyrightText: 2013, 2015 ljfa-ag <ljfa-ag@web.de>
+ *
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef VALUE_INITIALIZER_H_INCLUDED
+#define VALUE_INITIALIZER_H_INCLUDED
+
+#include "value.h"
+
+namespace nbt
+{
+
+	/**
+	 * @brief Helper class for implicitly constructing value objects
+	 *
+	 * This type is a subclass of @ref value. However the only difference to
+	 * value is that this class has additional constructors which allow implicit
+	 * conversion of various types to value objects. These constructors are not
+	 * part of the value class itself because implicit conversions like this
+	 * (especially from @c tag&& to @c value) can cause problems and ambiguities
+	 * in some cases.
+	 *
+	 * value_initializer is especially useful as function parameter type, it
+	 * will allow convenient conversion of various values to tags on function
+	 * call.
+	 *
+	 * As value_initializer objects are in no way different than value objects,
+	 * they can just be converted to value after construction.
+	 */
+	class NBT_EXPORT value_initializer : public value
+	{
+	  public:
+		value_initializer(std::unique_ptr<tag>&& t) noexcept
+			: value(std::move(t))
+		{
+		}
+		value_initializer(std::nullptr_t) noexcept : value(nullptr) {}
+		value_initializer(value&& val) noexcept : value(std::move(val)) {}
+		value_initializer(tag&& t) : value(std::move(t)) {}
+
+		value_initializer(int8_t val);
+		value_initializer(int16_t val);
+		value_initializer(int32_t val);
+		value_initializer(int64_t val);
+		value_initializer(float val);
+		value_initializer(double val);
+		value_initializer(const std::string& str);
+		value_initializer(std::string&& str);
+		value_initializer(const char* str);
+	};
+
+} // namespace nbt
+
+#endif // VALUE_INITIALIZER_H_INCLUDED