Prepare Tag 2.2.0

Fixes #59

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+
+custom: https://paypal.me/tr7zw

.github/workflows/maven.yml

@@ -0,0 +1,17 @@
+name: Java CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Set up JDK 1.8
+      uses: actions/setup-java@v1
+      with:
+        java-version: 1.8
+    - name: Build with Maven
+      run: mvn --file pom.xml

README.md

@@ -1,6 +1,9 @@
 # Item-NBT-API
-Add custom NBT tags to Items without NMS!
-http://www.spigotmc.org/resources/item-nbt-api.7939/
+Add custom NBT tags to Items without NMS!<br/>
+[Server Owner/Developer Wiki](https://github.com/tr7zw/Item-NBT-API/wiki)
 
-[![](https://travis-ci.org/tr7zw/Item-NBT-API.svg?branch=master)](https://travis-ci.org/tr7zw/Item-NBT-API)[![](https://jitpack.io/v/tr7zw/Item-NBT-API.svg)](https://jitpack.io/#tr7zw/Item-NBT-API)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=alert_status)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=ncloc)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=duplicated_lines_density)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)
+### Build/Maven/Sonar Status
+[![Build Status](https://ci.codemc.org/buildStatus/icon?job=Tr7zw%2FItem-NBT-API)](https://ci.codemc.org/job/Tr7zw/job/Item-NBT-API/)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=alert_status)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=ncloc)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=duplicated_lines_density)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)[![](https://sonarcloud.io/api/project_badges/measure?project=de.tr7zw%3Aitem-nbt-parent&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=de.tr7zw%3Aitem-nbt-parent)
 
+### SpigotMC Status
+[![Version](https://badges.spiget.org/resources/version/Version-yellow-7939.svg)](https://www.spigotmc.org/resources/item-entity-tile-nbt-api.7939/)[![Rating](https://badges.spiget.org/resources/rating/Rating-yellow-7939.svg)](https://www.spigotmc.org/resources/item-entity-tile-nbt-api.7939/)[![Rating](https://badges.spiget.org/resources/downloads/SpigotDownloads-yellow-7939.svg)](https://www.spigotmc.org/resources/item-entity-tile-nbt-api.7939/)[![bStats Servers](https://img.shields.io/bstats/servers/1058.svg?color=green&label=OnlineServers&style=plastic)](https://bstats.org/plugin/bukkit/ItemNBTAPI)[![bStats Players](https://img.shields.io/bstats/players/1058.svg?color=green&label=OnlinePlayers&style=plastic)](https://bstats.org/plugin/bukkit/ItemNBTAPI)

item-nbt-api/pom.xml

@@ -1,20 +1,20 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>de.tr7zw</groupId>
-        <artifactId>item-nbt-parent</artifactId>
-        <version>1.8.3-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>item-nbt-api</artifactId>
-    <packaging>jar</packaging>
-
-    <build>
-        <defaultGoal>clean install javadoc:javadoc</defaultGoal>
-    </build>
-
-</project>
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>de.tr7zw</groupId>
+        <artifactId>item-nbt-parent</artifactId>
+        <version>2.2.0</version>
+    </parent>
+
+    <artifactId>item-nbt-api</artifactId>
+    <packaging>jar</packaging>
+
+    <build>
+        <defaultGoal>clean install javadoc:javadoc</defaultGoal>
+    </build>
+
+</project>

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTCompound.java

@@ -0,0 +1,474 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.io.Serializable;
+import java.util.Set;
+
+import org.bukkit.inventory.ItemStack;
+
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * Base class representing NMS Compounds. For a standalone implementation check
+ * {@link NBTContainer}
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTCompound {
+
+	private String compundName;
+	private NBTCompound parent;
+
+	protected NBTCompound(NBTCompound owner, String name) {
+		this.compundName = name;
+		this.parent = owner;
+	}
+
+	protected void saveCompound(){
+		if(parent != null)
+			parent.saveCompound();
+	}
+	
+	/**
+	 * @return The Compound name
+	 */
+	public String getName() {
+		return compundName;
+	}
+
+	/**
+	 * @return The NMS Compound behind this Object
+	 */
+	public Object getCompound() {
+		return parent.getCompound();
+	}
+
+	protected void setCompound(Object compound) {
+		parent.setCompound(compound);
+	}
+
+	/**
+	 * @return The parent Compound
+	 */
+	public NBTCompound getParent() {
+		return parent;
+	}
+
+	/**
+	 * Merges all data from comp into this compound. This is done in one action, so
+	 * it also works with Tiles/Entities
+	 * 
+	 * @param comp
+	 */
+	public void mergeCompound(NBTCompound comp) {
+		NBTReflectionUtil.mergeOtherNBTCompound(this, comp);
+		saveCompound();
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setString(String key, String value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_STRING, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public String getString(String key) {
+		return (String) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_STRING, key);
+	}
+
+	protected String getContent(String key) {
+		return NBTReflectionUtil.getContent(this, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setInteger(String key, Integer value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_INT, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Integer getInteger(String key) {
+		return (Integer) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_INT, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setDouble(String key, Double value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_DOUBLE, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Double getDouble(String key) {
+		return (Double) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_DOUBLE, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setByte(String key, Byte value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BYTE, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Byte getByte(String key) {
+		return (Byte) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BYTE, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setShort(String key, Short value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_SHORT, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Short getShort(String key) {
+		return (Short) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_SHORT, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setLong(String key, Long value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_LONG, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Long getLong(String key) {
+		return (Long) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_LONG, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setFloat(String key, Float value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_FLOAT, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Float getFloat(String key) {
+		return (Float) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_FLOAT, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setByteArray(String key, byte[] value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BYTEARRAY, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public byte[] getByteArray(String key) {
+		return (byte[]) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BYTEARRAY, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setIntArray(String key, int[] value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_INTARRAY, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public int[] getIntArray(String key) {
+		return (int[]) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_INTARRAY, key);
+	}
+
+	/**
+	 * Setter
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setBoolean(String key, Boolean value) {
+		NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BOOLEAN, key, value);
+		saveCompound();
+	}
+
+	protected void set(String key, Object val) {
+		NBTReflectionUtil.set(this, key, val);
+		saveCompound();
+	}
+
+	/**
+	 * Getter
+	 * 
+	 * @param key
+	 * @return The stored value or NMS fallback
+	 */
+	public Boolean getBoolean(String key) {
+		return (Boolean) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BOOLEAN, key);
+	}
+
+	/**
+	 * Uses Gson to store an {@link Serializable} Object
+	 * 
+	 * @param key
+	 * @param value
+	 */
+	public void setObject(String key, Object value) {
+		NBTReflectionUtil.setObject(this, key, value);
+		saveCompound();
+	}
+
+	/**
+	 * Uses Gson to retrieve a stored Object
+	 * 
+	 * @param key
+	 * @param type Class of the Object
+	 * @return The created Object or null if empty
+	 */
+	public <T> T getObject(String key, Class<T> type) {
+		return NBTReflectionUtil.getObject(this, key, type);
+	}
+	
+	/**
+	 * Save an ItemStack as a compound under a given key
+	 * 
+	 * @param key
+	 * @param item
+	 */
+	public void setItemStack(String key, ItemStack item){
+		removeKey(key);
+		addCompound(key).mergeCompound(NBTItem.convertItemtoNBT(item));
+	}
+	
+	/**
+	 * Get an ItemStack that was saved at the given key
+	 * 
+	 * @param key
+	 * @return
+	 */
+	public ItemStack getItemStack(String key){
+		NBTCompound comp = getCompound(key);
+		return NBTItem.convertNBTtoItem(comp);
+	}
+
+	/**
+	 * @param key
+	 * @return True if the key is set
+	 */
+	public Boolean hasKey(String key) {
+		Boolean b = (Boolean) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_HAS_KEY, key);
+		if (b == null)
+			return false;
+		return b;
+	}
+
+	/**
+	 * @param key Deletes the given Key
+	 */
+	public void removeKey(String key) {
+		NBTReflectionUtil.remove(this, key);
+		saveCompound();
+	}
+
+	/**
+	 * @return Set of all stored Keys
+	 */
+	public Set<String> getKeys() {
+		return NBTReflectionUtil.getKeys(this);
+	}
+
+	/**
+	 * Creates a subCompound
+	 * 
+	 * @param name Key to use
+	 * @return The subCompound Object
+	 */
+	public NBTCompound addCompound(String name) {
+		if (getType(name) == NBTType.NBTTagCompound)
+			return getCompound(name);
+		NBTReflectionUtil.addNBTTagCompound(this, name);
+		NBTCompound comp = getCompound(name);
+		if(comp == null)
+			throw new NbtApiException("Error while adding Compound, got null!");
+		saveCompound();
+		return comp;
+	}
+
+	/**
+	 * @param name
+	 * @return The Compound instance or null
+	 */
+	public NBTCompound getCompound(String name) {
+		if (getType(name) != NBTType.NBTTagCompound)
+			return null;
+		NBTCompound next = new NBTCompound(this, name);
+		if (NBTReflectionUtil.valideCompound(next))
+			return next;
+		return null;
+	}
+
+	/**
+	 * @param name
+	 * @return The retrieved String List
+	 */
+	public NBTList<String> getStringList(String name) {
+		NBTList<String> list = NBTReflectionUtil.getList(this, name, NBTType.NBTTagString, String.class);
+		saveCompound();
+		return list;
+	}
+
+	/**
+	 * @param name
+	 * @return The retrieved Integer List
+	 */
+	public NBTList<Integer> getIntegerList(String name) {
+		NBTList<Integer> list = NBTReflectionUtil.getList(this, name, NBTType.NBTTagInt, Integer.class);
+		saveCompound();
+		return list;
+	}
+
+	/**
+	 * @param name
+	 * @return The retrieved Compound List
+	 */
+	public NBTCompoundList getCompoundList(String name) {
+		NBTCompoundList list = (NBTCompoundList) NBTReflectionUtil.getList(this, name, NBTType.NBTTagCompound, NBTListCompound.class);
+		saveCompound();
+		return list;
+	}
+
+	/**
+	 * @param name
+	 * @return The type of the given stored key or null
+	 */
+	public NBTType getType(String name) {
+		if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_7_R4)
+			return null;
+		Object o = NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_TYPE, name);
+		if (o == null)
+			return null;
+		return NBTType.valueOf((byte) o);
+	}
+
+	@Override
+	public String toString() {
+		/*StringBuilder result = new StringBuilder();
+		for (String key : getKeys()) {
+			result.append(toString(key));
+		}
+		return result.toString();*/
+		return asNBTString();
+	}
+
+	/**
+	 * @deprecated Just use toString()
+	 * @param key
+	 * @return A string representation of the given key
+	 */
+	@Deprecated
+	public String toString(String key) {
+		/*StringBuilder result = new StringBuilder();
+		NBTCompound compound = this;
+		while (compound.getParent() != null) {
+			result.append("   ");
+			compound = compound.getParent();
+		}
+		if (this.getType(key) == NBTType.NBTTagCompound) {
+			return this.getCompound(key).toString();
+		} else {
+			return result + "-" + key + ": " + getContent(key) + System.lineSeparator();
+		}*/
+		return asNBTString();
+	}
+
+	/**
+	 * @deprecated Just use toString()
+	 * @return A json valid nbt string for this Compound
+	 */
+	@Deprecated
+	public String asNBTString() {
+		Object comp = NBTReflectionUtil.gettoCompount(getCompound(), this);
+		if (comp == null)
+			return "{}";
+		return comp.toString();
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTCompoundList.java

@@ -0,0 +1,108 @@
+package de.tr7zw.changeme.nbtapi;
+
+import org.apache.commons.lang.NotImplementedException;
+
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * {@link NBTListCompound} implementation for NBTLists
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTCompoundList extends NBTList<NBTListCompound> {
+
+	protected NBTCompoundList(NBTCompound owner, String name, NBTType type, Object list) {
+		super(owner, name, type, list);
+	}
+
+	/**
+	 * Adds a new Compound to the end of the List and returns it.
+	 * 
+	 * @return The added {@link NBTListCompound}
+	 */
+	public NBTListCompound addCompound() {
+		return (NBTListCompound) addCompound(null);
+	}
+	
+	/**
+	 * Adds a copy of the Compound to the end of the List and returns it.
+	 * When null is given, a new Compound will be created
+	 * 
+	 * @param comp
+	 * @return
+	 */
+	public NBTCompound addCompound(NBTCompound comp) {
+		try {
+			Object compound = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
+				ReflectionMethod.LIST_ADD.run(listObject, size(), compound);
+			} else {
+				ReflectionMethod.LEGACY_LIST_ADD.run(listObject, compound);
+			}
+			getParent().saveCompound();
+			NBTListCompound listcomp = new NBTListCompound(this, compound);
+			if(comp != null){
+				listcomp.mergeCompound(comp);
+			}
+			return listcomp;
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	/**
+	 * Adds a new Compound to the end of the List.
+	 * 
+	 * 
+	 * @deprecated Please use addCompound!
+	 * @param empty
+	 * @return True, if compound was added
+	 */
+	@Override
+	@Deprecated
+	public boolean add(NBTListCompound empty) {
+		return addCompound(empty) != null;
+	}
+
+	@Override
+	public void add(int index, NBTListCompound element) {
+		if (element != null) {
+			throw new NotImplementedException("You need to pass null! ListCompounds from other lists won't work.");
+		}
+		try {
+			Object compound = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
+				ReflectionMethod.LIST_ADD.run(listObject, index, compound);
+			} else {
+				ReflectionMethod.LEGACY_LIST_ADD.run(listObject, compound);
+			}
+			super.getParent().saveCompound();
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	@Override
+	public NBTListCompound get(int index) {
+		try {
+			Object compound = ReflectionMethod.LIST_GET_COMPOUND.run(listObject, index);
+			return new NBTListCompound(this, compound);
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	@Override
+	public NBTListCompound set(int index, NBTListCompound element) {
+		throw new NotImplementedException("This method doesn't work in the ListCompound context.");
+	}
+
+	@Override
+	protected Object asTag(NBTListCompound object) {
+		return null;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTContainer.java

@@ -0,0 +1,60 @@
+package de.tr7zw.changeme.nbtapi;
+
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ObjectCreator;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * A Standalone {@link NBTCompound} implementation. All data is just kept inside
+ * this Object.
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTContainer extends NBTCompound {
+
+	private Object nbt;
+
+	/**
+	 * Creates an empty, standalone NBTCompound
+	 */
+	public NBTContainer() {
+		super(null, null);
+		nbt = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+	}
+
+	/**
+	 * Takes in any NMS Compound to wrap it
+	 * 
+	 * @param nbt
+	 */
+	public NBTContainer(Object nbt) {
+		super(null, null);
+		this.nbt = nbt;
+	}
+
+	/**
+	 * Parses in a NBT String to a standalone {@link NBTCompound}. Can throw a
+	 * {@link NbtApiException} in case something goes wrong.
+	 * 
+	 * @param nbtString
+	 */
+	public NBTContainer(String nbtString) {
+		super(null, null);
+		try {
+			nbt = ReflectionMethod.PARSE_NBT.run(null, nbtString);
+		} catch (Exception ex) {
+			throw new NbtApiException("Unable to parse Malformed Json!", ex);
+		}
+	}
+
+	@Override
+	public Object getCompound() {
+		return nbt;
+	}
+
+	@Override
+	public void setCompound(Object tag) {
+		nbt = tag;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTEntity.java

@@ -0,0 +1,35 @@
+package de.tr7zw.changeme.nbtapi;
+
+import org.bukkit.entity.Entity;
+
+/**
+ * NBT class to access vanilla tags from Entities. Entities don't support custom
+ * tags. Use the NBTInjector for custom tags. Changes will be instantly applied
+ * to the Entity, use the merge method to do many things at once.
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTEntity extends NBTCompound {
+
+	private final Entity ent;
+
+	/**
+	 * @param entity Any valid Bukkit Entity
+	 */
+	public NBTEntity(Entity entity) {
+		super(null, null);
+		ent = entity;
+	}
+
+	@Override
+	public Object getCompound() {
+		return NBTReflectionUtil.getEntityNBTTagCompound(NBTReflectionUtil.getNMSEntity(ent));
+	}
+
+	@Override
+	protected void setCompound(Object compound) {
+		NBTReflectionUtil.setEntityNBTTag(compound, NBTReflectionUtil.getNMSEntity(ent));
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTFile.java

@@ -0,0 +1,72 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ObjectCreator;
+
+/**
+ * {@link NBTCompound} implementation backed by a {@link File}
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTFile extends NBTCompound {
+
+	private final File file;
+	private Object nbt;
+
+	/**
+	 * Creates a NBTFile that uses @param file to store it's data. If this file
+	 * exists, the data will be loaded.
+	 * 
+	 * @param file
+	 * @throws IOException
+	 */
+	public NBTFile(File file) throws IOException {
+		super(null, null);
+		this.file = file;
+		if (file.exists()) {
+			FileInputStream inputsteam = new FileInputStream(file);
+			nbt = NBTReflectionUtil.readNBTFile(inputsteam);
+		} else {
+			nbt = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+			save();
+		}
+	}
+
+	/**
+	 * Saves the data to the file
+	 * 
+	 * @throws IOException
+	 */
+	public void save() throws IOException {
+		if (!file.exists()) {
+			file.getParentFile().mkdirs();
+			if (!file.createNewFile())
+				throw new IOException("Unable to create file at " + file.getAbsolutePath());
+		}
+		FileOutputStream outStream = new FileOutputStream(file);
+		NBTReflectionUtil.saveNBTFile(nbt, outStream);
+	}
+
+	/**
+	 * @return The File used to store the data
+	 */
+	public File getFile() {
+		return file;
+	}
+
+	@Override
+	public Object getCompound() {
+		return nbt;
+	}
+
+	@Override
+	protected void setCompound(Object compound) {
+		nbt = compound;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTIntegerList.java

@@ -0,0 +1,45 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * Integer implementation for NBTLists
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTIntegerList extends NBTList<Integer> {
+
+	protected NBTIntegerList(NBTCompound owner, String name, NBTType type, Object list) {
+		super(owner, name, type, list);
+	}
+
+	@Override
+	protected Object asTag(Integer object) {
+		try {
+			Constructor<?> con = ClassWrapper.NMS_NBTTAGINT.getClazz().getDeclaredConstructor(int.class);
+			con.setAccessible(true);
+			return con.newInstance(object);
+		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
+				| NoSuchMethodException | SecurityException e) {
+			throw new NbtApiException("Error while wrapping the Object " + object + " to it's NMS object!", e);
+		}
+	}
+
+	@Override
+	public Integer get(int index) {
+		try {
+			Object obj = ReflectionMethod.LIST_GET.run(listObject, index);
+			return Integer.valueOf(obj.toString());
+		} catch (NumberFormatException nf) {
+			return 0;
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTItem.java

@@ -0,0 +1,86 @@
+package de.tr7zw.changeme.nbtapi;
+
+import org.bukkit.inventory.ItemStack;
+
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * NBT class to access vanilla/custom tags on ItemStacks. This class doesn't
+ * autosave to the Itemstack, use getItem to get the changed ItemStack
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTItem extends NBTCompound {
+
+	private ItemStack bukkitItem;
+
+	/**
+	 * Constructor for NBTItems. The ItemStack will be cloned!
+	 * 
+	 * @param item
+	 */
+	public NBTItem(ItemStack item) {
+		super(null, null);
+		if (item == null) {
+			throw new NullPointerException("ItemStack can't be null!");
+		}
+		bukkitItem = item.clone();
+	}
+
+	@Override
+	public Object getCompound() {
+		return NBTReflectionUtil.getItemRootNBTTagCompound(ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, bukkitItem));
+	}
+
+	@Override
+	protected void setCompound(Object compound) {
+		Object stack = ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, bukkitItem);
+		ReflectionMethod.ITEMSTACK_SET_TAG.run(stack, compound);
+		bukkitItem = (ItemStack) ReflectionMethod.ITEMSTACK_BUKKITMIRROR.run(null, stack);
+	}
+
+	/**
+	 * @return The modified ItemStack
+	 */
+	public ItemStack getItem() {
+		return bukkitItem;
+	}
+
+	protected void setItem(ItemStack item) {
+		bukkitItem = item;
+	}
+
+	/**
+	 * This may return true even when the NBT is empty.
+	 * 
+	 * @return Does the ItemStack have a NBTCompound.
+	 */
+	public boolean hasNBTData() {
+		return getCompound() != null;
+	}
+
+	/**
+	 * Helper method that converts {@link ItemStack} to {@link NBTContainer} with
+	 * all it's data like Material, Damage, Amount and Tags.
+	 * 
+	 * @param item
+	 * @return Standalone {@link NBTContainer} with the Item's data
+	 */
+	public static NBTContainer convertItemtoNBT(ItemStack item) {
+		return NBTReflectionUtil.convertNMSItemtoNBTCompound(ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, item));
+	}
+
+	/**
+	 * Helper method to do the inverse to "convertItemtoNBT". Creates an
+	 * {@link ItemStack} using the {@link NBTCompound}
+	 * 
+	 * @param comp
+	 * @return ItemStack using the {@link NBTCompound}'s data
+	 */
+	public static ItemStack convertNBTtoItem(NBTCompound comp) {
+		return (ItemStack) ReflectionMethod.ITEMSTACK_BUKKITMIRROR.run(null,
+				NBTReflectionUtil.convertNBTCompoundtoNMSItem(comp));
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTList.java

@@ -0,0 +1,343 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NoSuchElementException;
+
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * Abstract List implementation for ListCompounds
+ * 
+ * @author tr7zw
+ *
+ * @param <T>
+ */
+public abstract class NBTList<T> implements List<T> {
+
+	private String listName;
+	private NBTCompound parent;
+	private NBTType type;
+	protected Object listObject;
+
+	protected NBTList(NBTCompound owner, String name, NBTType type, Object list) {
+		parent = owner;
+		listName = name;
+		this.type = type;
+		this.listObject = list;
+	}
+	
+	/**
+	 * @return Name of this list-compound
+	 */
+	public String getName(){
+		return listName;
+	}
+	
+	/**
+	 * @return The Compound's parent Object
+	 */
+	public NBTCompound getParent() {
+		return parent;
+	}
+
+	protected void save() {
+		parent.set(listName, listObject);
+	}
+
+	protected abstract Object asTag(T object);
+
+	@Override
+	public boolean add(T element) {
+		try {
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
+				ReflectionMethod.LIST_ADD.run(listObject, size(), asTag(element));
+			} else {
+				ReflectionMethod.LEGACY_LIST_ADD.run(listObject, asTag(element));
+			}
+			save();
+			return true;
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	@Override
+	public void add(int index, T element) {
+		try {
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
+				ReflectionMethod.LIST_ADD.run(listObject, index, asTag(element));
+			} else {
+				ReflectionMethod.LEGACY_LIST_ADD.run(listObject, asTag(element));
+			}
+			save();
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	@Override
+	public T set(int index, T element) {
+		try {
+			T prev = get(index);
+			ReflectionMethod.LIST_SET.run(listObject, index, asTag(element));
+			save();
+			return prev;
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	public T remove(int i) {
+		try {
+			T old = get(i);
+			ReflectionMethod.LIST_REMOVE_KEY.run(listObject, i);
+			save();
+			return old;
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	public int size() {
+		try {
+			return (int) ReflectionMethod.LIST_SIZE.run(listObject);
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	/**
+	 * @return The type that this list contains
+	 */
+	public NBTType getType() {
+		return type;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return size() == 0;
+	}
+
+	@Override
+	public void clear() {
+		while (!isEmpty()) {
+			remove(0);
+		}
+	}
+
+	@Override
+	public boolean contains(Object o) {
+		for (int i = 0; i < size(); i++) {
+			if (o.equals(get(i)))
+				return true;
+		}
+		return false;
+	}
+
+	@Override
+	public int indexOf(Object o) {
+		for (int i = 0; i < size(); i++) {
+			if (o.equals(get(i)))
+				return i;
+		}
+		return -1;
+	}
+
+	@Override
+	public boolean addAll(Collection<? extends T> c) {
+		int size = size();
+		for (T ele : c) {
+			add(ele);
+		}
+		return size != size();
+	}
+
+	@Override
+	public boolean addAll(int index, Collection<? extends T> c) {
+		int size = size();
+		for (T ele : c) {
+			add(index++, ele);
+		}
+		return size != size();
+	}
+
+	@Override
+	public boolean containsAll(Collection<?> c) {
+		for (Object ele : c) {
+			if (!contains(ele))
+				return false;
+		}
+		return true;
+	}
+
+	@Override
+	public int lastIndexOf(Object o) {
+		int index = -1;
+		for (int i = 0; i < size(); i++) {
+			if (o.equals(get(i)))
+				index = i;
+		}
+		return index;
+	}
+
+	@Override
+	public boolean removeAll(Collection<?> c) {
+		int size = size();
+		for (Object obj : c) {
+			remove(obj);
+		}
+		return size != size();
+	}
+
+	@Override
+	public boolean retainAll(Collection<?> c) {
+		int size = size();
+		for (Object obj : c) {
+			for (int i = 0; i < size(); i++) {
+				if (!obj.equals(get(i))) {
+					remove(i--);
+				}
+			}
+		}
+		return size != size();
+	}
+
+	@Override
+	public boolean remove(Object o) {
+		int size = size();
+		int id = -1;
+		while ((id = indexOf(o)) != -1) {
+			remove(id);
+		}
+		return size != size();
+	}
+
+	@Override
+	public Iterator<T> iterator() {
+		return new Iterator<T>() {
+
+			private int index = -1;
+
+			@Override
+			public boolean hasNext() {
+				return size() > index + 1;
+			}
+
+			@Override
+			public T next() {
+				if (!hasNext())
+					throw new NoSuchElementException();
+				return get(++index);
+			}
+		};
+	}
+
+	@Override
+	public ListIterator<T> listIterator() {
+		return listIterator(0);
+	}
+
+	@Override
+	public ListIterator<T> listIterator(int startIndex) {
+		final NBTList<T> list = this;
+		return new ListIterator<T>() {
+
+			int index = startIndex - 1;
+
+			@Override
+			public void add(T e) {
+				list.add(index, e);
+			}
+
+			@Override
+			public boolean hasNext() {
+				return size() > index + 1;
+			}
+
+			@Override
+			public boolean hasPrevious() {
+				return index >= 0 && index <= size();
+			}
+
+			@Override
+			public T next() {
+				if (!hasNext())
+					throw new NoSuchElementException();
+				return get(++index);
+			}
+
+			@Override
+			public int nextIndex() {
+				return index + 1;
+			}
+
+			@Override
+			public T previous() {
+				if (!hasPrevious())
+					throw new NoSuchElementException("Id: " + (index - 1));
+				return get(index--);
+			}
+
+			@Override
+			public int previousIndex() {
+				return index - 1;
+			}
+
+			@Override
+			public void remove() {
+				list.remove(index);
+			}
+
+			@Override
+			public void set(T e) {
+				list.set(index, e);
+			}
+		};
+	}
+
+	@Override
+	public Object[] toArray() {
+		Object[] ar = new Object[size()];
+		for (int i = 0; i < size(); i++)
+			ar[i] = get(i);
+		return ar;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public <E> E[] toArray(E[] a) {
+		E[] ar = Arrays.copyOf(a, size());
+		Arrays.fill(ar, null);
+		Class<?> arrayclass = a.getClass().getComponentType();
+		for (int i = 0; i < size(); i++) {
+			T obj = get(i);
+			if (arrayclass.isInstance(obj)) {
+				ar[i] = (E) get(i);
+			} else {
+				throw new ArrayStoreException("The array does not match the objects stored in the List.");
+			}
+		}
+		return ar;
+	}
+
+	@Override
+	public List<T> subList(int fromIndex, int toIndex) {
+		ArrayList<T> list = new ArrayList<>();
+		for (int i = fromIndex; i < toIndex; i++)
+			list.add(get(i));
+		return list;
+	}
+
+	@Override
+	public String toString() {
+		return listObject.toString();
+	}
+
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTListCompound.java

@@ -0,0 +1,42 @@
+package de.tr7zw.changeme.nbtapi;
+
+/**
+ * Cut down version of the {@link NBTCompound} for inside
+ * {@link NBTCompoundList} This Compound implementation is missing the ability
+ * for further subCompounds and Lists. This class probably will change in the
+ * future
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTListCompound extends NBTCompound {
+
+	private NBTList<?> owner;
+	private Object compound;
+
+	protected NBTListCompound(NBTList<?> parent, Object obj) {
+		super(null, null);
+		owner = parent;
+		compound = obj;
+	}
+	
+	public NBTList<?> getListParent() {
+		return owner;
+	}
+
+	@Override
+	public Object getCompound() {
+		return compound;
+	}
+
+	@Override
+	protected void setCompound(Object compound) {
+		this.compound = compound;
+	}
+
+	@Override
+	protected void saveCompound() {
+		owner.save();
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTReflectionUtil.java

@@ -0,0 +1,499 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.Serializable;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Set;
+
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+
+import de.tr7zw.changeme.nbtapi.utils.GsonWrapper;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ObjectCreator;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * Utility class for translating NBTApi calls to reflections into NMS code All
+ * methods are allowed to throw {@link NbtApiException}
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTReflectionUtil {
+
+	/**
+	 * Hidden constructor
+	 */
+	private NBTReflectionUtil() {
+
+	}
+
+	/**
+	 * Gets the NMS Entity for a given Bukkit Entity
+	 * 
+	 * @param entity Bukkit Entity
+	 * @return NMS Entity
+	 */
+	public static Object getNMSEntity(Entity entity) {
+		try {
+			return ReflectionMethod.CRAFT_ENTITY_GET_HANDLE.run(ClassWrapper.CRAFT_ENTITY.getClazz().cast(entity));
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting the NMS Entity from a Bukkit Entity!", e);
+		}
+	}
+
+	/**
+	 * Reads in a FileInputStream as NMS Compound
+	 * 
+	 * @param stream InputStream of any NBT file
+	 * @return NMS Compound
+	 */
+	public static Object readNBTFile(FileInputStream stream) {
+		try {
+			return ReflectionMethod.NBTFILE_READ.run(null, stream);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while reading a NBT File!", e);
+		}
+	}
+
+	/**
+	 * Writes a NMS Compound to a FileOutputStream
+	 * 
+	 * @param nbt    NMS Compound
+	 * @param stream Stream to write to
+	 * @return ???
+	 */
+	public static Object saveNBTFile(Object nbt, FileOutputStream stream) {
+		try {
+			return ReflectionMethod.NBTFILE_WRITE.run(null, nbt, stream);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while saving a NBT File!", e);
+		}
+	}
+
+	/**
+	 * Simulates getOrCreateTag. If an Item doesn't yet have a Tag, it will return a
+	 * new empty tag.
+	 * 
+	 * @param nmsitem
+	 * @return NMS Compound
+	 */
+	public static Object getItemRootNBTTagCompound(Object nmsitem) {
+		try {
+			Object answer = ReflectionMethod.NMSITEM_GETTAG.run(nmsitem);
+			return answer != null ? answer : ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting an Itemstack's NBTCompound!", e);
+		}
+	}
+
+	/**
+	 * Converts {@link NBTCompound} to NMS ItemStacks
+	 * 
+	 * @param nbtcompound Any valid {@link NBTCompound}
+	 * @return NMS ItemStack
+	 */
+	public static Object convertNBTCompoundtoNMSItem(NBTCompound nbtcompound) {
+		try {
+			Object nmsComp = gettoCompount(nbtcompound.getCompound(), nbtcompound);
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_11_R1.getVersionId()) {
+				return ObjectCreator.NMS_COMPOUNDFROMITEM.getInstance(nmsComp);
+			} else {
+				return ReflectionMethod.NMSITEM_CREATESTACK.run(null, nmsComp);
+			}
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while converting NBTCompound to NMS ItemStack!", e);
+		}
+	}
+
+	/**
+	 * Converts NMS ItemStacks to {@link NBTContainer}
+	 * 
+	 * @param nmsitem NMS ItemStack
+	 * @return {@link NBTContainer} with all the data
+	 */
+	public static NBTContainer convertNMSItemtoNBTCompound(Object nmsitem) {
+		try {
+			Object answer = ReflectionMethod.NMSITEM_SAVE.run(nmsitem, ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance());
+			return new NBTContainer(answer);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while converting NMS ItemStack to NBTCompound!", e);
+		}
+	}
+
+	/**
+	 * Gets the Vanilla NBT Compound from a given NMS Entity
+	 * 
+	 * @param nmsEntity
+	 * @return NMS NBT Compound
+	 */
+	public static Object getEntityNBTTagCompound(Object nmsEntity) {
+		try {
+			Object nbt = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
+			Object answer = ReflectionMethod.NMS_ENTITY_GET_NBT.run(nmsEntity, nbt);
+			if (answer == null)
+				answer = nbt;
+			return answer;
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting NBTCompound from NMS Entity!", e);
+		}
+	}
+
+	/**
+	 * Loads all Vanilla tags from a NMS Compound into a NMS Entity
+	 * 
+	 * @param nbtTag
+	 * @param nmsEntity
+	 * @return The NMS Entity
+	 */
+	public static Object setEntityNBTTag(Object nbtTag, Object nmsEntity) {
+		try {
+			ReflectionMethod.NMS_ENTITY_SET_NBT.run(nmsEntity, nbtTag);
+			return nmsEntity;
+		} catch (Exception ex) {
+			throw new NbtApiException("Exception while setting the NBTCompound of an Entity", ex);
+		}
+	}
+
+	/**
+	 * Gets the NMS Compound from a given TileEntity
+	 * 
+	 * @param tile
+	 * @return NMS Compound with the Vanilla data
+	 */
+	public static Object getTileEntityNBTTagCompound(BlockState tile) {
+		try {
+			Object pos = ObjectCreator.NMS_BLOCKPOSITION.getInstance(tile.getX(), tile.getY(), tile.getZ());
+			Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(tile.getWorld());
+			Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
+			Object o = ReflectionMethod.NMS_WORLD_GET_TILEENTITY.run(nmsworld, pos);
+			Object tag = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
+			Object answer = ReflectionMethod.TILEENTITY_GET_NBT.run(o, tag);
+			if (answer == null)
+				answer = tag;
+			return answer;
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting NBTCompound from TileEntity!", e);
+		}
+	}
+
+	/**
+	 * Sets Vanilla tags from a NMS Compound to a TileEntity
+	 * 
+	 * @param tile
+	 * @param comp
+	 */
+	public static void setTileEntityNBTTagCompound(BlockState tile, Object comp) {
+		try {
+			Object pos = ObjectCreator.NMS_BLOCKPOSITION.getInstance(tile.getX(), tile.getY(), tile.getZ());
+			Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(tile.getWorld());
+			Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
+			Object o = ReflectionMethod.NMS_WORLD_GET_TILEENTITY.run(nmsworld, pos);
+			ReflectionMethod.TILEENTITY_SET_NBT.run(o, comp);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while setting NBTData for a TileEntity!", e);
+		}
+	}
+
+	/**
+	 * Gets the subCompound with a given name from a NMS Compound
+	 * 
+	 * @param compound
+	 * @param name
+	 * @return NMS Compound or null
+	 */
+	public static Object getSubNBTTagCompound(Object compound, String name) {
+		try {
+			if ((boolean) ReflectionMethod.COMPOUND_HAS_KEY.run(compound, name)) {
+				return ReflectionMethod.COMPOUND_GET_COMPOUND.run(compound, name);
+			} else {
+				throw new NbtApiException("Tried getting invalide compound '" + name + "' from '" + compound + "'!");
+			}
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting NBT subcompounds!", e);
+		}
+	}
+
+	/**
+	 * Creates a subCompound with a given name in the given NMS Compound
+	 * 
+	 * @param comp
+	 * @param name
+	 */
+	public static void addNBTTagCompound(NBTCompound comp, String name) {
+		if (name == null) {
+			remove(comp, name);
+			return;
+		}
+		Object nbttag = comp.getCompound();
+		if (nbttag == null) {
+			nbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			return;
+		Object workingtag = gettoCompount(nbttag, comp);
+		try {
+			ReflectionMethod.COMPOUND_SET.run(workingtag, name,
+					ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance());
+			comp.setCompound(nbttag);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while adding a Compound!", e);
+		}
+	}
+
+	/**
+	 * Checks if the Compound is correctly linked to it's roots
+	 * 
+	 * @param comp
+	 * @return true if this is a valide Compound, else false
+	 */
+	public static Boolean valideCompound(NBTCompound comp) {
+		Object root = comp.getCompound();
+		if (root == null) {
+			root = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		return (gettoCompount(root, comp)) != null;
+	}
+
+	protected static Object gettoCompount(Object nbttag, NBTCompound comp) {
+		Deque<String> structure = new ArrayDeque<>();
+		while (comp.getParent() != null) {
+			structure.add(comp.getName());
+			comp = comp.getParent();
+		}
+		while (!structure.isEmpty()) {
+			String target = structure.pollLast();
+			nbttag = getSubNBTTagCompound(nbttag, target);
+			if (nbttag == null) {
+				throw new NbtApiException("Unable to find tag '" + target + "' in " + nbttag);
+			}
+		}
+		return nbttag;
+	}
+
+	/**
+	 * Merges the second {@link NBTCompound} into the first one
+	 * 
+	 * @param comp        Target for the merge
+	 * @param nbtcompound Data to merge
+	 */
+	public static void mergeOtherNBTCompound(NBTCompound comp, NBTCompound nbtcompound) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		try {
+			ReflectionMethod.COMPOUND_MERGE.run(workingtag, nbtcompound.getCompound());
+			comp.setCompound(rootnbttag);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while merging two NBTCompounds!", e);
+		}
+	}
+
+	/**
+	 * Returns the content for a given key inside a Compound
+	 * 
+	 * @param comp
+	 * @param key
+	 * @return Content saved under this key
+	 */
+	public static String getContent(NBTCompound comp, String key) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		try {
+			return ReflectionMethod.COMPOUND_GET.run(workingtag, key).toString();
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while getting the Content for key '" + key + "'!", e);
+		}
+	}
+
+	/**
+	 * Sets a key in a {@link NBTCompound} to a given value
+	 * 
+	 * @param comp
+	 * @param key
+	 * @param val
+	 */
+	public static void set(NBTCompound comp, String key, Object val) {
+		if (val == null) {
+			remove(comp, key);
+			return;
+		}
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp)) {
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		}
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		try {
+			ReflectionMethod.COMPOUND_SET.run(workingtag, key, val);
+			comp.setCompound(rootnbttag);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while setting key '" + key + "' to '" + val + "'!", e);
+		}
+	}
+
+	/**
+	 * Returns the List saved with a given key.
+	 * 
+	 * @param comp
+	 * @param key
+	 * @param type
+	 * @param clazz
+	 * @return The list at that key. Null if it's an invalide type
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> NBTList<T> getList(NBTCompound comp, String key, NBTType type, Class<T> clazz) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			return null;
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		try {
+			Object nbt = ReflectionMethod.COMPOUND_GET_LIST.run(workingtag, key, type.getId());
+			if (clazz == String.class) {
+				return (NBTList<T>) new NBTStringList(comp, key, type, nbt);
+			} else if (clazz == NBTListCompound.class) {
+				return (NBTList<T>) new NBTCompoundList(comp, key, type, nbt);
+			} else if (clazz == Integer.class) {
+				return (NBTList<T>) new NBTIntegerList(comp, key, type, nbt);
+			} else {
+				return null;
+			}
+		} catch (Exception ex) {
+			throw new NbtApiException("Exception while getting a list with the type '" + type + "'!", ex);
+		}
+	}
+
+	/**
+	 * Uses Gson to set a {@link Serializable} value in a Compound
+	 * 
+	 * @param comp
+	 * @param key
+	 * @param value
+	 */
+	public static void setObject(NBTCompound comp, String key, Object value) {
+		if (!MinecraftVersion.hasGsonSupport())
+			return;
+		try {
+			String json = GsonWrapper.getString(value);
+			setData(comp, ReflectionMethod.COMPOUND_SET_STRING, key, json);
+		} catch (Exception e) {
+			throw new NbtApiException("Exception while setting the Object '" + value + "'!", e);
+		}
+	}
+
+	/**
+	 * Uses Gson to load back a {@link Serializable} object from the Compound
+	 * 
+	 * @param comp
+	 * @param key
+	 * @param type
+	 * @return The loaded Object or null, if not found
+	 */
+	public static <T> T getObject(NBTCompound comp, String key, Class<T> type) {
+		if (!MinecraftVersion.hasGsonSupport())
+			return null;
+		String json = (String) getData(comp, ReflectionMethod.COMPOUND_GET_STRING, key);
+		if (json == null) {
+			return null;
+		}
+		return GsonWrapper.deserializeJson(json, type);
+	}
+
+	/**
+	 * Deletes the given key
+	 * 
+	 * @param comp
+	 * @param key
+	 */
+	public static void remove(NBTCompound comp, String key) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			return;
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		ReflectionMethod.COMPOUND_REMOVE_KEY.run(workingtag, key);
+		comp.setCompound(rootnbttag);
+	}
+
+	/**
+	 * Gets the Keyset inside this Compound
+	 * 
+	 * @param comp
+	 * @return Set of all keys
+	 */
+	@SuppressWarnings("unchecked")
+	public static Set<String> getKeys(NBTCompound comp) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		return (Set<String>) ReflectionMethod.COMPOUND_GET_KEYS.run(workingtag);
+	}
+
+	/**
+	 * Sets data inside the Compound
+	 * 
+	 * @param comp
+	 * @param type
+	 * @param key
+	 * @param data
+	 */
+	public static void setData(NBTCompound comp, ReflectionMethod type, String key, Object data) {
+		if (data == null) {
+			remove(comp, key);
+			return;
+		}
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
+		}
+		if (!valideCompound(comp))
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		type.run(workingtag, key, data);
+		comp.setCompound(rootnbttag);
+	}
+
+	/**
+	 * Gets data from the Compound
+	 * 
+	 * @param comp
+	 * @param type
+	 * @param key
+	 * @return The value or default fallback from NMS
+	 */
+	public static Object getData(NBTCompound comp, ReflectionMethod type, String key) {
+		Object rootnbttag = comp.getCompound();
+		if (rootnbttag == null) {
+			return null;
+		}
+		if (!valideCompound(comp))
+			throw new NbtApiException("The Compound wasn't able to be linked back to the root!");
+		Object workingtag = gettoCompount(rootnbttag, comp);
+		return type.run(workingtag, key);
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTStringList.java

@@ -0,0 +1,42 @@
+package de.tr7zw.changeme.nbtapi;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+
+/**
+ * String implementation for NBTLists
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTStringList extends NBTList<String> {
+
+	protected NBTStringList(NBTCompound owner, String name, NBTType type, Object list) {
+		super(owner, name, type, list);
+	}
+
+	@Override
+	public String get(int index) {
+		try {
+			return (String) ReflectionMethod.LIST_GET_STRING.run(listObject, index);
+		} catch (Exception ex) {
+			throw new NbtApiException(ex);
+		}
+	}
+
+	@Override
+	protected Object asTag(String object) {
+		try {
+			Constructor<?> con = ClassWrapper.NMS_NBTTAGSTRING.getClazz().getDeclaredConstructor(String.class);
+			con.setAccessible(true);
+			return con.newInstance(object);
+		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
+				| NoSuchMethodException | SecurityException e) {
+			throw new NbtApiException("Error while wrapping the Object " + object + " to it's NMS object!", e);
+		}
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTTileEntity.java

@@ -0,0 +1,36 @@
+package de.tr7zw.changeme.nbtapi;
+
+import org.bukkit.block.BlockState;
+
+/**
+ * NBT class to access vanilla tags from TileEntities. TileEntities don't
+ * support custom tags. Use the NBTInjector for custom tags. Changes will be
+ * instantly applied to the Tile, use the merge method to do many things at
+ * once.
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTTileEntity extends NBTCompound {
+
+	private final BlockState tile;
+
+	/**
+	 * @param tile BlockState from any TileEntity
+	 */
+	public NBTTileEntity(BlockState tile) {
+		super(null, null);
+		this.tile = tile;
+	}
+
+	@Override
+	public Object getCompound() {
+		return NBTReflectionUtil.getTileEntityNBTTagCompound(tile);
+	}
+
+	@Override
+	protected void setCompound(Object compound) {
+		NBTReflectionUtil.setTileEntityNBTTagCompound(tile, compound);
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NBTType.java

@@ -0,0 +1,48 @@
+package de.tr7zw.changeme.nbtapi;
+
+/**
+ * Enum of all NBT Types Minecraft contains
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum NBTType {
+	NBTTagEnd(0),
+    NBTTagByte(1),
+	NBTTagShort(2), 
+	NBTTagInt(3), 
+	NBTTagLong(4), 
+	NBTTagFloat(5), 
+	NBTTagDouble(6),
+	NBTTagByteArray(7), 
+	NBTTagIntArray(11), 
+	NBTTagString(8), 
+	NBTTagList(9), 
+	NBTTagCompound(10);
+
+	NBTType(int i) {
+		id = i;
+	}
+
+	private final int id;
+
+	/**
+	 * @return Id used by Minecraft internally
+	 */
+	public int getId() {
+		return id;
+	}
+
+	/**
+	 * @param id Internal Minecraft id
+	 * @return Enum representing the id, NBTTagEnd for invalide ids
+	 */
+	public static NBTType valueOf(int id) {
+		for (NBTType t : values())
+			if (t.getId() == id)
+				return t;
+		return NBTType.NBTTagEnd;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/NbtApiException.java

@@ -0,0 +1,56 @@
+package de.tr7zw.changeme.nbtapi;
+
+/**
+ * A generic {@link RuntimeException} that can be thrown by most methods in the
+ * NBTAPI.
+ * 
+ * @author tr7zw
+ *
+ */
+public class NbtApiException extends RuntimeException {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -993309714559452334L;
+
+	/**
+	 * 
+	 */
+	public NbtApiException() {
+		super();
+	}
+
+	/**
+	 * @param message
+	 * @param cause
+	 * @param enableSuppression
+	 * @param writableStackTrace
+	 */
+	public NbtApiException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+		super(message, cause, enableSuppression, writableStackTrace);
+	}
+
+	/**
+	 * @param message
+	 * @param cause
+	 */
+	public NbtApiException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+	/**
+	 * @param message
+	 */
+	public NbtApiException(String message) {
+		super(message);
+	}
+
+	/**
+	 * @param cause
+	 */
+	public NbtApiException(Throwable cause) {
+		super(cause);
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/ApiMetricsLite.java

@@ -0,0 +1,387 @@
+package de.tr7zw.changeme.nbtapi.utils;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.ServicePriority;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.UUID;
+import java.util.logging.Level;
+import java.util.zip.GZIPOutputStream;
+import static de.tr7zw.changeme.nbtapi.utils.MinecraftVersion.logger;
+
+/**
+ * bStats collects some data for plugin authors.
+ * <p>
+ * Check out https://bStats.org/ to learn more about bStats!
+ * 
+ * This class is modified by tr7zw to work when the api is shaded into other peoples plugins.
+ */
+public class ApiMetricsLite {
+
+	private static final String PLUGINNAME = "ItemNBTAPI"; // DO NOT CHANGE THE NAME! else it won't link the data on bStats
+
+	// The version of this bStats class
+	public static final int B_STATS_VERSION = 1;
+
+	// The version of the NBT-Api bStats
+	public static final int NBT_BSTATS_VERSION = 1;
+
+	// The url to which the data is sent
+	private static final String URL = "https://bStats.org/submitData/bukkit";
+
+	// Is bStats enabled on this server?
+	private boolean enabled;
+
+	// Should failed requests be logged?
+	private static boolean logFailedRequests;
+
+	// Should the sent data be logged?
+	private static boolean logSentData;
+
+	// Should the response text be logged?
+	private static boolean logResponseStatusText;
+
+	// The uuid of the server
+	private static String serverUUID;
+
+	// The plugin
+	private Plugin plugin;
+
+	/**
+	 * Class constructor.
+	 *
+	 */
+	public ApiMetricsLite() {
+
+		// The register method just uses any enabled plugin it can find to register. This *shouldn't* cause any problems, since the plugin isn't used any other way.
+		// Register our service
+		for(Plugin plug : Bukkit.getPluginManager().getPlugins()) {
+				plugin = plug;
+				if(plugin != null)
+					break;
+		}
+		if(plugin == null) {
+			return;// Didn't find any plugin that could work
+		}
+
+		// Get the config file
+		File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+		File configFile = new File(bStatsFolder, "config.yml");
+		YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+
+		// Check if the config file exists
+		if (!config.isSet("serverUuid")) {
+
+			// Add default values
+			config.addDefault("enabled", true);
+			// Every server gets it's unique random id.
+			config.addDefault("serverUuid", UUID.randomUUID().toString());
+			// Should failed request be logged?
+			config.addDefault("logFailedRequests", false);
+			// Should the sent data be logged?
+			config.addDefault("logSentData", false);
+			// Should the response text be logged?
+			config.addDefault("logResponseStatusText", false);
+
+			// Inform the server owners about bStats
+			config.options().header(
+					"bStats collects some data for plugin authors like how many servers are using their plugins.\n" +
+							"To honor their work, you should not disable it.\n" +
+							"This has nearly no effect on the server performance!\n" +
+							"Check out https://bStats.org/ to learn more :)"
+					).copyDefaults(true);
+			try {
+				config.save(configFile);
+			} catch (IOException ignored) { }
+		}
+
+		// Load the data
+		serverUUID = config.getString("serverUuid");
+		logFailedRequests = config.getBoolean("logFailedRequests", false);
+		enabled = config.getBoolean("enabled", true);
+		logSentData = config.getBoolean("logSentData", false);
+		logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+		if (enabled) {
+			boolean found = false;
+			// Search for all other bStats Metrics classes to see if we are the first one
+			for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+				try {
+					service.getField("NBT_BSTATS_VERSION"); // Create only one instance of the nbt-api bstats.
+					return;
+				} catch (NoSuchFieldException ignored) { }
+				try {
+					service.getField("B_STATS_VERSION"); // Our identifier :)
+					found = true; // We aren't the first
+					break;
+				} catch (NoSuchFieldException ignored) { }
+			}
+			boolean fFound = found;
+			// Register our service
+			if(Bukkit.isPrimaryThread()){
+				Bukkit.getServicesManager().register(ApiMetricsLite.class, this, plugin, ServicePriority.Normal);
+				if (!fFound) {
+					logger.info("[NBTAPI] Using the plugin '" + plugin.getName() + "' to create a bStats instance!");
+					// We are the first!
+					startSubmitting();
+				}
+			}else{
+				Bukkit.getScheduler().runTask(plugin, () -> {
+					Bukkit.getServicesManager().register(ApiMetricsLite.class, this, plugin, ServicePriority.Normal);
+					if (!fFound) {
+						logger.info("[NBTAPI] Using the plugin '" + plugin.getName() + "' to create a bStats instance!");
+						// We are the first!
+						startSubmitting();
+					}
+				});
+			}
+		}
+	}
+
+	/**
+	 * Checks if bStats is enabled.
+	 *
+	 * @return Whether bStats is enabled or not.
+	 */
+	public boolean isEnabled() {
+		return enabled;
+	}
+
+	/**
+	 * Starts the Scheduler which submits our data every 30 minutes.
+	 */
+	private void startSubmitting() {
+		final Timer timer = new Timer(true); // We use a timer cause the Bukkit scheduler is affected by server lags
+		timer.scheduleAtFixedRate(new TimerTask() {
+			@Override
+			public void run() {
+				if (!plugin.isEnabled()) { // Plugin was disabled
+					timer.cancel();
+					return;
+				}
+				// Nevertheless we want our code to run in the Bukkit main thread, so we have to use the Bukkit scheduler
+				// Don't be afraid! The connection to the bStats server is still async, only the stats collection is sync ;)
+				Bukkit.getScheduler().runTask(plugin, () -> submitData());
+			}
+		}, 1000l * 60l * 5l, 1000l * 60l * 30l);
+		// Submit the data every 30 minutes, first time after 5 minutes to give other plugins enough time to start
+		// WARNING: Changing the frequency has no effect but your plugin WILL be blocked/deleted!
+		// WARNING: Just don't do it!
+	}
+
+	/**
+	 * Gets the plugin specific data.
+	 * This method is called using Reflection.
+	 *
+	 * @return The plugin specific data.
+	 */
+	public JsonObject getPluginData() {
+		JsonObject data = new JsonObject();
+
+		data.addProperty("pluginName", PLUGINNAME); // Append the name of the plugin
+		data.addProperty("pluginVersion", MinecraftVersion.VERSION); // Append the version of the plugin
+		data.add("customCharts", new JsonArray());
+
+		return data;
+	}
+
+	/**
+	 * Gets the server specific data.
+	 *
+	 * @return The server specific data.
+	 */
+	private JsonObject getServerData() {
+		// Minecraft specific data
+		int playerAmount;
+		try {
+			// Around MC 1.8 the return type was changed to a collection from an array,
+			// This fixes java.lang.NoSuchMethodError: org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+			Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+			playerAmount = onlinePlayersMethod.getReturnType().equals(Collection.class)
+					? ((Collection<?>) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+							: ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+		} catch (Exception e) {
+			playerAmount = Bukkit.getOnlinePlayers().size(); // Just use the new method if the Reflection failed
+		}
+		int onlineMode = Bukkit.getOnlineMode() ? 1 : 0;
+		String bukkitVersion = Bukkit.getVersion();
+		String bukkitName = Bukkit.getName();
+
+		// OS/Java specific data
+		String javaVersion = System.getProperty("java.version");
+		String osName = System.getProperty("os.name");
+		String osArch = System.getProperty("os.arch");
+		String osVersion = System.getProperty("os.version");
+		int coreCount = Runtime.getRuntime().availableProcessors();
+
+		JsonObject data = new JsonObject();
+
+		data.addProperty("serverUUID", serverUUID);
+
+		data.addProperty("playerAmount", playerAmount);
+		data.addProperty("onlineMode", onlineMode);
+		data.addProperty("bukkitVersion", bukkitVersion);
+		data.addProperty("bukkitName", bukkitName);
+
+		data.addProperty("javaVersion", javaVersion);
+		data.addProperty("osName", osName);
+		data.addProperty("osArch", osArch);
+		data.addProperty("osVersion", osVersion);
+		data.addProperty("coreCount", coreCount);
+
+		return data;
+	}
+
+	/**
+	 * Collects the data and sends it afterwards.
+	 */
+	private void submitData() {
+		final JsonObject data = getServerData();
+
+		JsonArray pluginData = new JsonArray();
+		// Search for all other bStats Metrics classes to get their plugin data
+		for (Class<?> service : Bukkit.getServicesManager().getKnownServices()) {
+			try {
+				service.getField("B_STATS_VERSION"); // Our identifier :)
+
+				for (RegisteredServiceProvider<?> provider : Bukkit.getServicesManager().getRegistrations(service)) {
+					try {
+						Object plugin = provider.getService().getMethod("getPluginData").invoke(provider.getProvider());
+						if (plugin instanceof JsonObject) {
+							pluginData.add((JsonObject) plugin);
+						} else { // old bstats version compatibility
+							try {
+								Class<?> jsonObjectJsonSimple = Class.forName("org.json.simple.JSONObject");
+								if (plugin.getClass().isAssignableFrom(jsonObjectJsonSimple)) {
+									Method jsonStringGetter = jsonObjectJsonSimple.getDeclaredMethod("toJSONString");
+									jsonStringGetter.setAccessible(true);
+									String jsonString = (String) jsonStringGetter.invoke(plugin);
+									JsonObject object = new JsonParser().parse(jsonString).getAsJsonObject();
+									pluginData.add(object);
+								}
+							} catch (ClassNotFoundException e) {
+								// minecraft version 1.14+
+								if (logFailedRequests) {
+									logger.log(Level.WARNING, "[NBTAPI][BSTATS] Encountered exception while posting request!", e);
+									// Not using the plugins logger since the plugin isn't the plugin containing the NBT-Api most of the time
+									//this.plugin.getLogger().log(Level.SEVERE, "Encountered unexpected exception ", e); 
+								}
+								continue; // continue looping since we cannot do any other thing.
+							}
+						}
+					} catch (NullPointerException | NoSuchMethodException | IllegalAccessException | InvocationTargetException ignored) {
+					}
+				}
+			} catch (NoSuchFieldException ignored) { }
+		}
+
+		data.add("plugins", pluginData);
+
+		// Create a new thread for the connection to the bStats server
+		new Thread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					// Send the data
+					sendData(plugin, data);
+				} catch (Exception e) {
+					// Something went wrong! :(
+					if (logFailedRequests) {
+						logger.log(Level.WARNING, "[NBTAPI][BSTATS] Could not submit plugin stats of " + plugin.getName(), e);
+						// Not using the plugins logger since the plugin isn't the plugin containing the NBT-Api most of the time
+						//plugin.getLogger().log(Level.WARNING, "Could not submit plugin stats of " + plugin.getName(), e);
+					}
+				}
+			}
+		}).start();
+	}
+
+	/**
+	 * Sends the data to the bStats server.
+	 *
+	 * @param plugin Any plugin. It's just used to get a logger instance.
+	 * @param data The data to send.
+	 * @throws Exception If the request failed.
+	 */
+	private static void sendData(Plugin plugin, JsonObject data) throws Exception {
+		if (data == null) {
+			throw new IllegalArgumentException("Data cannot be null!");
+		}
+		if (Bukkit.isPrimaryThread()) {
+			throw new IllegalAccessException("This method must not be called from the main thread!");
+		}
+		if (logSentData) {
+			System.out.println("[NBTAPI][BSTATS] Sending data to bStats: " + data.toString());
+			// Not using the plugins logger since the plugin isn't the plugin containing the NBT-Api most of the time
+			//plugin.getLogger().info("Sending data to bStats: " + data.toString());
+		}
+		HttpsURLConnection connection = (HttpsURLConnection) new URL(URL).openConnection();
+
+		// Compress the data to save bandwidth
+		byte[] compressedData = compress(data.toString());
+
+		// Add headers
+		connection.setRequestMethod("POST");
+		connection.addRequestProperty("Accept", "application/json");
+		connection.addRequestProperty("Connection", "close");
+		connection.addRequestProperty("Content-Encoding", "gzip"); // We gzip our request
+		connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+		connection.setRequestProperty("Content-Type", "application/json"); // We send our data in JSON format
+		connection.setRequestProperty("User-Agent", "MC-Server/" + B_STATS_VERSION);
+
+		// Send data
+		connection.setDoOutput(true);
+		DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream());
+		outputStream.write(compressedData);
+		outputStream.flush();
+		outputStream.close();
+
+		InputStream inputStream = connection.getInputStream();
+		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+
+		StringBuilder builder = new StringBuilder();
+		String line;
+		while ((line = bufferedReader.readLine()) != null) {
+			builder.append(line);
+		}
+		bufferedReader.close();
+		if (logResponseStatusText) {
+			logger.info("[NBTAPI][BSTATS] Sent data to bStats and received response: " + builder.toString());
+			// Not using the plugins logger since the plugin isn't the plugin containing the NBT-Api most of the time
+			//plugin.getLogger().info("Sent data to bStats and received response: " + builder.toString());
+		}
+	}
+
+	/**
+	 * Gzips the given String.
+	 *
+	 * @param str The string to gzip.
+	 * @return The gzipped String.
+	 * @throws IOException If the compression failed.
+	 */
+	private static byte[] compress(final String str) throws IOException {
+		if (str == null) {
+			return new byte[0];
+		}
+		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+		GZIPOutputStream gzip = new GZIPOutputStream(outputStream);
+		gzip.write(str.getBytes(StandardCharsets.UTF_8));
+		gzip.close();
+		return outputStream.toByteArray();
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/GsonWrapper.java

@@ -0,0 +1,54 @@
+package de.tr7zw.changeme.nbtapi.utils;
+
+import com.google.gson.Gson;
+
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+
+/**
+ * Helper class for 1.7 servers without Gson
+ * 
+ * @author tr7zw
+ *
+ */
+public class GsonWrapper {
+
+	/**
+	 * Private constructor
+	 */
+	private GsonWrapper() {
+
+	}
+
+	private static final Gson gson = new Gson();
+
+	/**
+	 * Turns Objects into Json Strings
+	 * 
+	 * @param obj
+	 * @return Json, representing the Object
+	 */
+	public static String getString(Object obj) {
+		return gson.toJson(obj);
+	}
+
+	/**
+	 * Creates an Object of the given type using the Json String
+	 * 
+	 * @param json
+	 * @param type
+	 * @return Object that got created, or null if the json is null
+	 */
+	public static <T> T deserializeJson(String json, Class<T> type) {
+		try {
+			if (json == null) {
+				return null;
+			}
+
+			T obj = gson.fromJson(json, type);
+			return type.cast(obj);
+		} catch (Exception ex) {
+			throw new NbtApiException("Error while converting json to " + type.getName(), ex);
+		}
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/MinecraftVersion.java

@@ -0,0 +1,159 @@
+package de.tr7zw.changeme.nbtapi.utils;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+
+/**
+ * This class acts as the "Brain" of the NBTApi. It contains the main logger for
+ * other classes,registers bStats and checks rather Maven shading was done
+ * correctly.
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum MinecraftVersion {
+	UNKNOWN(Integer.MAX_VALUE), // Use the newest known mappings
+	MC1_7_R4(174),
+	MC1_8_R3(183),
+	MC1_9_R1(191),
+	MC1_9_R2(192),
+	MC1_10_R1(1101),
+	MC1_11_R1(1111),
+	MC1_12_R1(1121),
+	MC1_13_R1(1131),
+	MC1_13_R2(1132),
+	MC1_14_R1(1141),
+	MC1_15_R1(1151);
+
+	private static MinecraftVersion version;
+	private static Boolean hasGsonSupport;
+	private static boolean bStatsDisabled = false;
+	private static boolean disablePackageWarning = false;
+	private static boolean updateCheckDisabled = false;
+	/**
+	 * Logger used by the api
+	 */
+	public static final Logger logger = Logger.getLogger("NBTAPI");
+	
+	// NBT-API Version
+	protected static final String VERSION = "2.2.0";
+
+	private final int versionId;
+
+	MinecraftVersion(int versionId) {
+		this.versionId = versionId;
+	}
+
+	/**
+	 * @return A simple comparable Integer, representing the version.
+	 */
+	public int getVersionId() {
+		return versionId;
+	}
+
+	/**
+	 * Getter for this servers MinecraftVersion. Also init's bStats and checks the
+	 * shading.
+	 * 
+	 * @return The enum for the MinecraftVersion this server is running
+	 */
+	public static MinecraftVersion getVersion() {
+		if (version != null) {
+			return version;
+		}
+		final String ver = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+		logger.info("[NBTAPI] Found Spigot: " + ver + "! Trying to find NMS support");
+		try {
+			version = MinecraftVersion.valueOf(ver.replace("v", "MC"));
+		} catch (IllegalArgumentException ex) {
+			version = MinecraftVersion.UNKNOWN;
+		}
+		if (version != UNKNOWN) {
+			logger.info("[NBTAPI] NMS support '" + version.name() + "' loaded!");
+		} else {
+			logger.warning("[NBTAPI] Wasn't able to find NMS Support! Some functions may not work!");
+		}
+		init();
+		return version;
+	}
+
+	private static void init() {
+		try {
+			if (!bStatsDisabled)
+				new ApiMetricsLite();
+		} catch (Exception ex) {
+			logger.log(Level.WARNING, "[NBTAPI] Error enabeling Metrics!", ex);
+		}
+		try {
+			if(!updateCheckDisabled)
+				VersionChecker.checkForUpdates();
+		} catch (Exception ex) {
+			logger.log(Level.WARNING, "[NBTAPI] Error while checking for updates!", ex);
+		}
+		// Maven's Relocate is clever and changes strings, too. So we have to use this
+		// little "trick" ... :D (from bStats)
+		final String defaultPackage = new String(new byte[] { 'd', 'e', '.', 't', 'r', '7', 'z', 'w', '.', 'c', 'h',
+				'a', 'n', 'g', 'e', 'm', 'e', '.', 'n', 'b', 't', 'a', 'p', 'i', '.', 'u', 't', 'i', 'l', 's' });
+		if (!disablePackageWarning && MinecraftVersion.class.getPackage().getName().equals(defaultPackage)) {
+			logger.warning(
+					"#########################################- NBTAPI -#########################################");
+			logger.warning(
+					"The NBT-API package has not been moved! This *will* cause problems with other plugins containing");
+			logger.warning(
+					"a different version of the api! Please read the guide on the plugin page on how to get the");
+			logger.warning(
+					"Maven Shade plugin to relocate the api to your personal location! If you are not the developer,");
+			logger.warning("please check your plugins and contact their developer, so he can fix this issue.");
+			logger.warning(
+					"#########################################- NBTAPI -#########################################");
+		}
+	}
+
+	/**
+	 * @return True, if Gson is usable
+	 */
+	public static boolean hasGsonSupport() {
+		if (hasGsonSupport != null) {
+			return hasGsonSupport;
+		}
+		try {
+			logger.info("[NBTAPI] Found Gson: " + Class.forName("com.google.gson.Gson"));
+			hasGsonSupport = true;
+		} catch (Exception ex) {
+			logger.info("[NBTAPI] Gson not found! This will not allow the usage of some methods!");
+			hasGsonSupport = false;
+		}
+		return hasGsonSupport;
+	}
+
+	/**
+	 * Calling this function before the NBT-Api is used will disable bStats stats
+	 * collection. Please consider not to do that, since it won't affect your plugin
+	 * and helps the NBT-Api developer to see api's demand.
+	 */
+	public static void disableBStats() {
+		bStatsDisabled = true;
+	}
+	
+	/**
+	 * Disables the update check. Uses Spiget to get the current version and
+	 * prints a warning when outdated.
+	 */
+	public static void disableUpdateCheck() {
+		updateCheckDisabled = true;
+	}
+
+	/**
+	 * Forcefully disables the log message for plugins not shading the API to
+	 * another location. This may be helpful for networks or development
+	 * environments, but please don't use it for plugins that are uploaded to
+	 * Spigotmc.
+	 */
+	public static void disablePackageWarning() {
+		disablePackageWarning = true;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/ReflectionUtil.java

@@ -0,0 +1,53 @@
+package de.tr7zw.changeme.nbtapi.utils;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+
+public final class ReflectionUtil {
+
+	private static Field field_modifiers;
+
+	static {
+		try {
+			field_modifiers = Field.class.getDeclaredField("modifiers");
+			field_modifiers.setAccessible(true);
+		} catch (NoSuchFieldException ex) {
+			try {
+				// This hacky workaround is for newer jdk versions 11+?
+				Method fieldGetter = Class.class.getDeclaredMethod("getDeclaredFields0", boolean.class);
+				fieldGetter.setAccessible(true);
+				Field[] fields = (Field[]) fieldGetter.invoke(Field.class, false);
+				for (Field f : fields)
+					if (f.getName().equals("modifiers")) {
+						field_modifiers = f;
+						field_modifiers.setAccessible(true);
+						break;
+					}
+			} catch (Exception e) {
+				throw new NbtApiException(e);
+			}
+		}
+		if (field_modifiers == null) {
+			throw new NbtApiException("Unable to init the modifiers Field.");
+		}
+	}
+
+	public static Field makeNonFinal(Field field) throws IllegalArgumentException, IllegalAccessException {
+		int mods = field.getModifiers();
+		if (Modifier.isFinal(mods)) {
+			field_modifiers.set(field, mods & ~Modifier.FINAL);
+		}
+		return field;
+	}
+
+	public static void setFinal(Object obj, Field field, Object newValue)
+			throws IllegalArgumentException, IllegalAccessException {
+		field.setAccessible(true);
+		field = makeNonFinal(field);
+		field.set(obj, newValue);
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/VersionChecker.java

@@ -0,0 +1,106 @@
+package de.tr7zw.changeme.nbtapi.utils;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.logging.Level;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import de.tr7zw.changeme.nbtapi.NBTItem;
+
+/**
+ * This class uses the Spiget API to check for updates
+ *
+ */
+public class VersionChecker {
+
+	private static final String USER_AGENT = "nbt-api Version check";
+	private static final String REQUEST_URL = "https://api.spiget.org/v2/resources/7939/versions?size=100";
+
+	protected static void checkForUpdates() throws Exception {
+		URL url = new URL(REQUEST_URL);
+		HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+		connection.addRequestProperty("User-Agent", USER_AGENT);// Set
+																// User-Agent
+
+		// If you're not sure if the request will be successful,
+		// you need to check the response code and use #getErrorStream if it
+		// returned an error code
+		InputStream inputStream = connection.getInputStream();
+		InputStreamReader reader = new InputStreamReader(inputStream);
+
+		// This could be either a JsonArray or JsonObject
+		JsonElement element = new JsonParser().parse(reader);
+		if (element.isJsonArray()) {
+			// Is JsonArray
+			JsonArray updates = (JsonArray) element;
+			JsonObject latest = (JsonObject) updates.get(updates.size() - 1);
+			int versionDifference = getVersionDifference(latest.get("name").getAsString());
+			if (versionDifference == -1) { // Outdated
+				MinecraftVersion.logger.log(Level.WARNING,
+						"[NBTAPI] The NBT-API at '" + NBTItem.class.getPackage() + "' seems to be outdated!");
+				MinecraftVersion.logger.log(Level.WARNING, "[NBTAPI] Current Version: '" + MinecraftVersion.VERSION
+						+ "' Newest Version: " + latest.get("name").getAsString() + "'");
+				MinecraftVersion.logger.log(Level.WARNING,
+						"[NBTAPI] Please update the nbt-api or the plugin that contains the api!");
+
+			} else if (versionDifference == 0) {
+				MinecraftVersion.logger.log(Level.INFO, "[NBTAPI] The NBT-API seems to be up-to-date!");
+			} else if (versionDifference == 1) {
+				MinecraftVersion.logger.log(Level.WARNING, "[NBTAPI] The NBT-API at '" + NBTItem.class.getPackage()
+						+ "' seems to be a future Version, not yet released on Spigot!");
+				MinecraftVersion.logger.log(Level.WARNING, "[NBTAPI] Current Version: '" + MinecraftVersion.VERSION
+						+ "' Newest Version: " + latest.get("name").getAsString() + "'");
+			}
+		} else {
+			// wut?!
+			MinecraftVersion.logger.log(Level.WARNING,
+					"[NBTAPI] Error when looking for Updates! Got non Json Array: '" + element.toString() + "'");
+		}
+	}
+
+	// -1 = we are outdated
+	// 0 = up to date
+	// 1 = using a future version
+	// This method is only able to compare the Format 0.0.0(-SNAPSHOT)
+	private static int getVersionDifference(String version) {
+		String current = MinecraftVersion.VERSION;
+		if (current.equals(version))
+			return 0;
+		String pattern = "\\.";
+		if (current.split(pattern).length != 3 || version.split(pattern).length != 3)
+			return -1;
+		int curMaj = Integer.parseInt(current.split(pattern)[0]);
+		int curMin = Integer.parseInt(current.split(pattern)[1]);
+		String curPatch = current.split(pattern)[2];
+		int relMaj = Integer.parseInt(version.split(pattern)[0]);
+		int relMin = Integer.parseInt(version.split(pattern)[1]);
+		String relPatch = version.split(pattern)[2];
+		if (curMaj < relMaj)
+			return -1;
+		if (curMaj > relMaj)
+			return 1;
+		if (curMin < relMin)
+			return -1;
+		if (curMin > relMin)
+			return 1;
+		int curPatchN = Integer.parseInt(curPatch.split("-")[0]);
+		int relPatchN = Integer.parseInt(relPatch.split("-")[0]);
+		if (curPatchN < relPatchN)
+			return -1;
+		if (curPatchN > relPatchN)
+			return 1;
+		if (!relPatch.contains("-") && curPatch.contains("-"))
+			return -1; // Release has no - but we do = We use a Snapshot of the
+						// release
+		if (relPatch.contains("-") && curPatch.contains("-"))
+			return 0; // Release and cur are Snapshots/alpha/beta
+		return 1;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/nmsmappings/ClassWrapper.java

@@ -0,0 +1,79 @@
+package de.tr7zw.changeme.nbtapi.utils.nmsmappings;
+
+import java.util.logging.Level;
+import org.bukkit.Bukkit;
+
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import static de.tr7zw.changeme.nbtapi.utils.MinecraftVersion.logger;
+
+/**
+ * Wraps NMS and CRAFT classes
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum ClassWrapper {
+CRAFT_ITEMSTACK(PackageWrapper.CRAFTBUKKIT, "inventory.CraftItemStack"),
+CRAFT_ENTITY(PackageWrapper.CRAFTBUKKIT, "entity.CraftEntity"),
+CRAFT_WORLD(PackageWrapper.CRAFTBUKKIT, "CraftWorld"),
+NMS_NBTBASE(PackageWrapper.NMS, "NBTBase"),
+NMS_NBTTAGSTRING(PackageWrapper.NMS, "NBTTagString"),
+NMS_NBTTAGINT(PackageWrapper.NMS, "NBTTagInt"),
+NMS_ITEMSTACK(PackageWrapper.NMS, "ItemStack"),
+NMS_NBTTAGCOMPOUND(PackageWrapper.NMS, "NBTTagCompound"),
+NMS_NBTTAGLIST(PackageWrapper.NMS, "NBTTagList"),
+NMS_NBTCOMPRESSEDSTREAMTOOLS(PackageWrapper.NMS, "NBTCompressedStreamTools"),
+NMS_MOJANGSONPARSER(PackageWrapper.NMS, "MojangsonParser"),
+NMS_TILEENTITY(PackageWrapper.NMS, "TileEntity"),
+NMS_BLOCKPOSITION(PackageWrapper.NMS, "BlockPosition"),
+NMS_WORLDSERVER(PackageWrapper.NMS, "WorldServer"),
+NMS_MINECRAFTSERVER(PackageWrapper.NMS, "MinecraftServer"),
+NMS_WORLD(PackageWrapper.NMS, "World"),
+NMS_ENTITY(PackageWrapper.NMS, "Entity"),
+NMS_ENTITYTYPES(PackageWrapper.NMS, "EntityTypes"),
+NMS_REGISTRYSIMPLE(PackageWrapper.NMS, "RegistrySimple", MinecraftVersion.MC1_11_R1, MinecraftVersion.MC1_12_R1),
+NMS_REGISTRYMATERIALS(PackageWrapper.NMS, "RegistryMaterials"),
+NMS_IREGISTRY(PackageWrapper.NMS, "IRegistry"),
+NMS_MINECRAFTKEY(PackageWrapper.NMS, "MinecraftKey"),
+
+;
+	
+    private Class<?> clazz;
+    private boolean enabled = false;
+    
+    ClassWrapper(PackageWrapper packageId, String suffix){
+    	this(packageId, suffix, null, null);
+    }
+    
+    ClassWrapper(PackageWrapper packageId, String suffix, MinecraftVersion from, MinecraftVersion to){
+    	if(from != null && MinecraftVersion.getVersion().getVersionId() < from.getVersionId()) {
+    		return;
+    	}
+    	if(to != null && MinecraftVersion.getVersion().getVersionId() > to.getVersionId()) {
+    		return;
+    	}
+    	enabled = true;
+        try{
+            String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
+            clazz = Class.forName(packageId.getUri() + "." + version + "." + suffix);
+        }catch(Exception ex){
+            logger.log(Level.WARNING, "[NBTAPI] Error while trying to resolve the class '" + suffix + "'!", ex);
+        }
+    }
+    
+    /**
+     * @return The wrapped class
+     */
+    public Class<?> getClazz(){
+        return clazz;
+    }
+    
+    /**
+     * @return Is this class available in this Version
+     */
+    public boolean isEnabled() {
+    	return enabled;
+    }
+    
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/nmsmappings/ObjectCreator.java

@@ -0,0 +1,55 @@
+package de.tr7zw.changeme.nbtapi.utils.nmsmappings;
+
+import java.lang.reflect.Constructor;
+import java.util.logging.Level;
+
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+
+import static de.tr7zw.changeme.nbtapi.utils.MinecraftVersion.logger;
+
+/**
+ * This Enum wraps Constructors for NMS classes
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum ObjectCreator {
+    NMS_NBTTAGCOMPOUND(null, null, ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()),
+    NMS_BLOCKPOSITION(null, null, ClassWrapper.NMS_BLOCKPOSITION.getClazz(), int.class, int.class, int.class),
+    NMS_COMPOUNDFROMITEM(MinecraftVersion.MC1_11_R1, null, ClassWrapper.NMS_ITEMSTACK.getClazz(), ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()),
+    ;
+
+    private Constructor<?> construct;
+    private Class<?> targetClass;
+
+    ObjectCreator(MinecraftVersion from, MinecraftVersion to, Class<?> clazz, Class<?>... args){
+       if(from != null && MinecraftVersion.getVersion().getVersionId() < from.getVersionId())
+    	   return;
+       if(to != null && MinecraftVersion.getVersion().getVersionId() > to.getVersionId())
+    	   return;
+    	try{
+        	this.targetClass = clazz;
+            construct = clazz.getDeclaredConstructor(args);
+            construct.setAccessible(true);
+        }catch(Exception ex){
+            logger.log(Level.SEVERE, "Unable to find the constructor for the class '" + clazz.getName() + "'", ex);
+        }
+    }
+    
+    /**
+     * Creates an Object instance with given args
+     * 
+     * @param args
+     * @return Object created
+     */
+    public Object getInstance(Object... args){
+        try{
+            return construct.newInstance(args);
+        }catch(Exception ex){
+        	throw new NbtApiException("Exception while creating a new instance of '" + targetClass + "'", ex);
+        }
+    }
+    
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/nmsmappings/PackageWrapper.java

@@ -0,0 +1,28 @@
+package de.tr7zw.changeme.nbtapi.utils.nmsmappings;
+
+/**
+ * Package enum
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum PackageWrapper {
+	NMS("net.minecraft.server"),
+	CRAFTBUKKIT("org.bukkit.craftbukkit"),
+	;
+	
+	private final String uri;
+
+	private PackageWrapper(String uri) {
+		this.uri = uri;
+	}
+
+	/**
+	 * @return The Uri for that package
+	 */
+	public String getUri() {
+		return uri;
+	}
+
+}

item-nbt-api/src/main/java/de/tr7zw/changeme/nbtapi/utils/nmsmappings/ReflectionMethod.java

@@ -1,128 +1,182 @@
-package de.tr7zw.itemnbtapi;
-
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.lang.reflect.Method;
-
-import org.bukkit.inventory.ItemStack;
-
-import de.tr7zw.itemnbtapi.utils.MinecraftVersion;
-
-public enum ReflectionMethod {
-
-    COMPOUND_SET_FLOAT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, float.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setFloat")),
-    COMPOUND_SET_STRING(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setString")),
-    COMPOUND_SET_INT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setInt")),
-    COMPOUND_SET_BYTEARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, byte[].class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setByteArray")),
-    COMPOUND_SET_INTARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, int[].class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setIntArray")),
-    COMPOUND_SET_LONG(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, long.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setLong")),
-    COMPOUND_SET_SHORT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, short.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setShort")),
-    COMPOUND_SET_BYTE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, byte.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setByte")),
-    COMPOUND_SET_DOUBLE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, double.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setDouble")),
-    COMPOUND_SET_BOOLEAN(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, boolean.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setBoolean")),
-    COMPOUND_ADD(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
-    
-    COMPOUND_GET_FLOAT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getFloat")),
-    COMPOUND_GET_STRING(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getString")),
-    COMPOUND_GET_INT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getInt")),
-    COMPOUND_GET_BYTEARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getByteArray")),
-    COMPOUND_GET_INTARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getIntArray")),
-    COMPOUND_GET_LONG(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getLong")),
-    COMPOUND_GET_SHORT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getShort")),
-    COMPOUND_GET_BYTE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getByte")),
-    COMPOUND_GET_DOUBLE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getDouble")),
-    COMPOUND_GET_BOOLEAN(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getBoolean")),
-
-    COMPOUND_REMOVE_KEY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "remove")),
-    COMPOUND_HAS_KEY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "hasKey")),
-    COMPOUND_GET_TYPE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "b"), new Since(MinecraftVersion.MC1_9_R1, "d")), //FIXME: No Spigot mapping!
-    COMPOUND_GET_KEYS(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "c"), new Since(MinecraftVersion.MC1_13_R1, "getKeys")),
-
-    LISTCOMPOUND_GET_KEYS(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "c"), new Since(MinecraftVersion.MC1_13_R1, "getKeys")),
-    LIST_REMOVE_KEY(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a"), new Since(MinecraftVersion.MC1_9_R1, "remove")),
-    LIST_SIZE(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "size")),
-    LIST_SET(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class, ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a"), new Since(MinecraftVersion.MC1_13_R1, "set")),
-    LEGACY_LIST_ADD(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_7_R4, MinecraftVersion.MC1_13_R2, new Since(MinecraftVersion.MC1_7_R4, "add")),
-    LIST_ADD(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class, ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_14_R1, new Since(MinecraftVersion.MC1_14_R1, "add")),
-    LIST_GET_STRING(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getString")),
-    LIST_GET(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "get")),
-    
-    ITEMSTACK_SET_TAG(ClassWrapper.NMS_ITEMSTACK.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setTag")),
-    ITEMSTACK_NMSCOPY(ClassWrapper.CRAFT_ITEMSTACK.getClazz(), new Class[]{ItemStack.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "asNMSCopy")),
-    ITEMSTACK_BUKKITMIRROR(ClassWrapper.CRAFT_ITEMSTACK.getClazz(), new Class[]{ClassWrapper.NMS_ITEMSTACK.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "asCraftMirror")),
-
-    CRAFT_WORLD_GET_HANDLE(ClassWrapper.CRAFT_WORLD.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getHandle")),
-    NMS_WORLD_GET_TILEENTITY(ClassWrapper.NMS_WORLD.getClazz(), new Class[]{ClassWrapper.NMS_BLOCKPOSITION.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getTileEntity")),
-    
-    TILEENTITY_GET_NBT(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "b"), new Since(MinecraftVersion.MC1_9_R1, "save")),
-    TILEENTITY_SET_NBT(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "a"), new Since(MinecraftVersion.MC1_12_R1, "load")),
-
-    CRAFT_ENTITY_GET_HANDLE(ClassWrapper.CRAFT_ENTITY.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getHandle")),
-    NMS_ENTITY_SET_NBT(ClassWrapper.NMS_ENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "f")), //FIXME: No Spigot mapping!
-    NMS_ENTITY_GET_NBT(ClassWrapper.NMS_ENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "e"), new Since(MinecraftVersion.MC1_12_R1, "save")),
-
-    NBTFILE_READ(ClassWrapper.NMS_NBTCOMPRESSEDSTREAMTOOLS.getClazz(), new Class[]{InputStream.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
-    NBTFILE_WRITE(ClassWrapper.NMS_NBTCOMPRESSEDSTREAMTOOLS.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), OutputStream.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
-    
-    
-    PARSE_NBT(ClassWrapper.NMS_MOJANGSONPARSER.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "parse")),
-
-   ;
-    
-    private MinecraftVersion removedAfter;
-    private Since targetVersion;
-    private Method method;
-    private boolean loaded = false;
-    private boolean compatible = false;
-    
-    ReflectionMethod(Class<?> targetClass, Class<?>[] args, MinecraftVersion addedSince, MinecraftVersion removedAfter, Since... methodnames){
-        this.removedAfter = removedAfter;
-    	MinecraftVersion server = MinecraftVersion.getVersion();
-        if(server.compareTo(addedSince) < 0 || (this.removedAfter != null && server.getVersionId() > this.removedAfter.getVersionId()))return;
-        compatible = true;
-        Since target = methodnames[0];
-        for(Since s : methodnames){
-            if(s.version.getVersionId() <= server.getVersionId() && target.version.getVersionId() < s.version.getVersionId())
-                target = s;
-        }
-        targetVersion = target;
-        try{
-            method = targetClass.getMethod(targetVersion.name, args);
-            method.setAccessible(true);
-            loaded = true;
-        }catch(NullPointerException | NoSuchMethodException | SecurityException ex){
-            ex.printStackTrace();
-        }
-    }
-    
-    ReflectionMethod(Class<?> targetClass, Class<?>[] args, MinecraftVersion addedSince, Since... methodnames){
-    	this(targetClass, args, addedSince, null, methodnames);
-    }
-    
-    public Object run(Object target, Object... args){
-        try{
-            return method.invoke(target, args);
-        }catch(Exception ex){
-            ex.printStackTrace();
-        }
-        return null;
-    }
-    
-    public boolean isLoaded() {
-        return loaded;
-    }
-
-    public boolean isCompatible() {
-        return compatible;
-    }
-
-    public static class Since{
-        public final MinecraftVersion version;
-        public final String name;
-        public Since(MinecraftVersion version, String name) {
-            this.version = version;
-            this.name = name;
-        }
-    }
-    
-}
+package de.tr7zw.changeme.nbtapi.utils.nmsmappings;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import org.bukkit.inventory.ItemStack;
+
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+
+/**
+ * This class caches method reflections, keeps track of method name changes between versions and allows early checking for problems
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("javadoc")
+public enum ReflectionMethod {
+
+    COMPOUND_SET_FLOAT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, float.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setFloat")),
+    COMPOUND_SET_STRING(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setString")),
+    COMPOUND_SET_INT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setInt")),
+    COMPOUND_SET_BYTEARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, byte[].class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setByteArray")),
+    COMPOUND_SET_INTARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, int[].class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setIntArray")),
+    COMPOUND_SET_LONG(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, long.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setLong")),
+    COMPOUND_SET_SHORT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, short.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setShort")),
+    COMPOUND_SET_BYTE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, byte.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setByte")),
+    COMPOUND_SET_DOUBLE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, double.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setDouble")),
+    COMPOUND_SET_BOOLEAN(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, boolean.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setBoolean")),
+    COMPOUND_MERGE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
+    COMPOUND_SET(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "set")),
+    COMPOUND_GET(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "get")),
+    COMPOUND_GET_LIST(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class, int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getList")),
+    
+    COMPOUND_GET_FLOAT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getFloat")),
+    COMPOUND_GET_STRING(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getString")),
+    COMPOUND_GET_INT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getInt")),
+    COMPOUND_GET_BYTEARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getByteArray")),
+    COMPOUND_GET_INTARRAY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getIntArray")),
+    COMPOUND_GET_LONG(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getLong")),
+    COMPOUND_GET_SHORT(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getShort")),
+    COMPOUND_GET_BYTE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getByte")),
+    COMPOUND_GET_DOUBLE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getDouble")),
+    COMPOUND_GET_BOOLEAN(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getBoolean")),
+    COMPOUND_GET_COMPOUND(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getCompound")),
+    
+    NMSITEM_GETTAG(ClassWrapper.NMS_ITEMSTACK.getClazz(), new Class[] {}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getTag")),
+    NMSITEM_SAVE(ClassWrapper.NMS_ITEMSTACK.getClazz(), new Class[] {ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "save")),
+    NMSITEM_CREATESTACK(ClassWrapper.NMS_ITEMSTACK.getClazz(), new Class[] {ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, MinecraftVersion.MC1_10_R1, new Since(MinecraftVersion.MC1_7_R4, "createStack")),
+    
+    COMPOUND_REMOVE_KEY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "remove")),
+    COMPOUND_HAS_KEY(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "hasKey")),
+    COMPOUND_GET_TYPE(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "b"), new Since(MinecraftVersion.MC1_9_R1, "d"), new Since(MinecraftVersion.MC1_15_R1, "e")), //FIXME: No Spigot mapping!
+    COMPOUND_GET_KEYS(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "c"), new Since(MinecraftVersion.MC1_13_R1, "getKeys")),
+
+    LISTCOMPOUND_GET_KEYS(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "c"), new Since(MinecraftVersion.MC1_13_R1, "getKeys")),
+    LIST_REMOVE_KEY(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a"), new Since(MinecraftVersion.MC1_9_R1, "remove")),
+    LIST_SIZE(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "size")),
+    LIST_SET(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class, ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a"), new Since(MinecraftVersion.MC1_13_R1, "set")),
+    LEGACY_LIST_ADD(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_7_R4, MinecraftVersion.MC1_13_R2, new Since(MinecraftVersion.MC1_7_R4, "add")),
+    LIST_ADD(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class, ClassWrapper.NMS_NBTBASE.getClazz()}, MinecraftVersion.MC1_14_R1, new Since(MinecraftVersion.MC1_14_R1, "add")),
+    LIST_GET_STRING(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getString")),
+    LIST_GET_COMPOUND(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "get")),
+    LIST_GET(ClassWrapper.NMS_NBTTAGLIST.getClazz(), new Class[]{int.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "g"), new Since(MinecraftVersion.MC1_9_R1, "h"), new Since(MinecraftVersion.MC1_12_R1, "i"), new Since(MinecraftVersion.MC1_13_R1, "get")),
+    
+    ITEMSTACK_SET_TAG(ClassWrapper.NMS_ITEMSTACK.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setTag")),
+    ITEMSTACK_NMSCOPY(ClassWrapper.CRAFT_ITEMSTACK.getClazz(), new Class[]{ItemStack.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "asNMSCopy")),
+    ITEMSTACK_BUKKITMIRROR(ClassWrapper.CRAFT_ITEMSTACK.getClazz(), new Class[]{ClassWrapper.NMS_ITEMSTACK.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "asCraftMirror")),
+
+    CRAFT_WORLD_GET_HANDLE(ClassWrapper.CRAFT_WORLD.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getHandle")),
+    NMS_WORLD_GET_TILEENTITY(ClassWrapper.NMS_WORLDSERVER.getClazz(), new Class[]{ClassWrapper.NMS_BLOCKPOSITION.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getTileEntity")),
+    NMS_WORLD_SET_TILEENTITY(ClassWrapper.NMS_WORLDSERVER.getClazz(), new Class[]{ClassWrapper.NMS_BLOCKPOSITION.getClazz(), ClassWrapper.NMS_TILEENTITY.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "setTileEntity")),
+    NMS_WORLD_REMOVE_TILEENTITY(ClassWrapper.NMS_WORLDSERVER.getClazz(), new Class[]{ClassWrapper.NMS_BLOCKPOSITION.getClazz()}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "t"), new Since(MinecraftVersion.MC1_9_R1, "s"), new Since(MinecraftVersion.MC1_13_R1, "n"),  new Since(MinecraftVersion.MC1_14_R1, "removeTileEntity")),
+    
+    TILEENTITY_LOAD_LEGACY191(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_MINECRAFTSERVER.getClazz(), ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_9_R1, MinecraftVersion.MC1_9_R1, new Since(MinecraftVersion.MC1_9_R1, "a")), //FIXME: No Spigot mapping!
+    TILEENTITY_LOAD_LEGACY183(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, MinecraftVersion.MC1_9_R2, new Since(MinecraftVersion.MC1_8_R3, "c"), new Since(MinecraftVersion.MC1_9_R1, "a"), new Since(MinecraftVersion.MC1_9_R2, "c")), //FIXME: No Spigot mapping!
+    TILEENTITY_LOAD_LEGACY1121(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_WORLD.getClazz(), ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_10_R1, MinecraftVersion.MC1_12_R1, new Since(MinecraftVersion.MC1_10_R1, "a"), new Since(MinecraftVersion.MC1_12_R1, "create")),
+    TILEENTITY_LOAD(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_12_R1, "create")),
+    
+    TILEENTITY_GET_NBT(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "b"), new Since(MinecraftVersion.MC1_9_R1, "save")),
+    TILEENTITY_SET_NBT(ClassWrapper.NMS_TILEENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "a"), new Since(MinecraftVersion.MC1_12_R1, "load")),
+
+    CRAFT_ENTITY_GET_HANDLE(ClassWrapper.CRAFT_ENTITY.getClazz(), new Class[]{}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "getHandle")),
+    NMS_ENTITY_SET_NBT(ClassWrapper.NMS_ENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "f")), //FIXME: No Spigot mapping!
+    NMS_ENTITY_GET_NBT(ClassWrapper.NMS_ENTITY.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()}, MinecraftVersion.MC1_8_R3, new Since(MinecraftVersion.MC1_8_R3, "e"), new Since(MinecraftVersion.MC1_12_R1, "save")),
+    NMS_ENTITY_GETSAVEID(ClassWrapper.NMS_ENTITY.getClazz(), new Class[]{}, MinecraftVersion.MC1_14_R1,new Since(MinecraftVersion.MC1_14_R1, "getSaveID")),
+
+    NBTFILE_READ(ClassWrapper.NMS_NBTCOMPRESSEDSTREAMTOOLS.getClazz(), new Class[]{InputStream.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
+    NBTFILE_WRITE(ClassWrapper.NMS_NBTCOMPRESSEDSTREAMTOOLS.getClazz(), new Class[]{ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), OutputStream.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "a")), //FIXME: No Spigot mapping!
+    
+    
+    PARSE_NBT(ClassWrapper.NMS_MOJANGSONPARSER.getClazz(), new Class[]{String.class}, MinecraftVersion.MC1_7_R4, new Since(MinecraftVersion.MC1_7_R4, "parse")),
+    REGISTRY_KEYSET (ClassWrapper.NMS_REGISTRYSIMPLE.getClazz(), new Class[]{}, MinecraftVersion.MC1_11_R1, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_11_R1, "keySet")),
+    REGISTRY_GET (ClassWrapper.NMS_REGISTRYSIMPLE.getClazz(), new Class[]{Object.class}, MinecraftVersion.MC1_11_R1, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_11_R1, "get")),
+    REGISTRY_SET (ClassWrapper.NMS_REGISTRYSIMPLE.getClazz(), new Class[]{Object.class, Object.class}, MinecraftVersion.MC1_11_R1, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_11_R1, "a")), //FIXME: No Spigot mapping!
+    REGISTRY_GET_INVERSE (ClassWrapper.NMS_REGISTRYMATERIALS.getClazz(), new Class[]{Object.class}, MinecraftVersion.MC1_11_R1, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_11_R1, "b")), //FIXME: No Spigot mapping!
+    REGISTRYMATERIALS_KEYSET (ClassWrapper.NMS_REGISTRYMATERIALS.getClazz(), new Class[]{}, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_13_R1, "keySet")),
+    REGISTRYMATERIALS_GET (ClassWrapper.NMS_REGISTRYMATERIALS.getClazz(), new Class[]{ClassWrapper.NMS_MINECRAFTKEY.getClazz()}, MinecraftVersion.MC1_13_R1, new Since(MinecraftVersion.MC1_13_R1, "get")),
+
+    
+   ;
+    
+    private MinecraftVersion removedAfter;
+    private Since targetVersion;
+    private Method method;
+    private boolean loaded = false;
+    private boolean compatible = false;
+    private String methodName = null;
+    
+    ReflectionMethod(Class<?> targetClass, Class<?>[] args, MinecraftVersion addedSince, MinecraftVersion removedAfter, Since... methodnames){
+        this.removedAfter = removedAfter;
+    	MinecraftVersion server = MinecraftVersion.getVersion();
+        if(server.compareTo(addedSince) < 0 || (this.removedAfter != null && server.getVersionId() > this.removedAfter.getVersionId()))return;
+        compatible = true;
+        Since target = methodnames[0];
+        for(Since s : methodnames){
+            if(s.version.getVersionId() <= server.getVersionId() && target.version.getVersionId() < s.version.getVersionId())
+                target = s;
+        }
+        targetVersion = target;
+        try{
+            method = targetClass.getMethod(targetVersion.name, args);
+            method.setAccessible(true);
+            loaded = true;
+            methodName = targetVersion.name;
+        }catch(NullPointerException | NoSuchMethodException | SecurityException ex){
+            System.out.println("[NBTAPI] Unable to find the method '" + targetVersion.name + "' in '" + targetClass.getSimpleName() + "' Enum: " + this); //NOSONAR This gets loaded before the logger is loaded
+        }
+    }
+    
+    ReflectionMethod(Class<?> targetClass, Class<?>[] args, MinecraftVersion addedSince, Since... methodnames){
+    	this(targetClass, args, addedSince, null, methodnames);
+    }
+    
+    /**
+     * Runs the method on a given target object using the given args.
+     * 
+     * @param target
+     * @param args
+     * @return Value returned by the method
+     */
+    public Object run(Object target, Object... args){
+        if(method == null)
+        	throw new NbtApiException("Method not loaded! '" + this + "'");
+    	try{
+            return method.invoke(target, args);
+        }catch(Exception ex){
+            throw new NbtApiException("Error while calling the method '" + methodName + "', loaded: " + loaded + ", Enum: " + this, ex);
+        }
+    }
+    
+    /**
+     * @return The MethodName, used in this Minecraft Version
+     */
+    public String getMethodName() {
+    	return methodName;
+    }
+    
+    /**
+     * @return Has this method been linked
+     */
+    public boolean isLoaded() {
+        return loaded;
+    }
+
+    /**
+     * @return Is this method available in this Minecraft Version
+     */
+    public boolean isCompatible() {
+        return compatible;
+    }
+
+    protected static class Since{
+        public final MinecraftVersion version;
+        public final String name;
+        public Since(MinecraftVersion version, String name) {
+            this.version = version;
+            this.name = name;
+        }
+    }
+    
+}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/ClassWrapper.java

@@ -1,39 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import org.bukkit.Bukkit;
-
-public enum ClassWrapper {
-CRAFT_ITEMSTACK("org.bukkit.craftbukkit.", ".inventory.CraftItemStack"),
-CRAFT_ENTITY("org.bukkit.craftbukkit.", ".entity.CraftEntity"),
-CRAFT_WORLD("org.bukkit.craftbukkit.", ".CraftWorld"),
-NMS_NBTBASE("net.minecraft.server.", ".NBTBase"),
-NMS_NBTTAGSTRING("net.minecraft.server.", ".NBTTagString"),
-NMS_ITEMSTACK("net.minecraft.server.", ".ItemStack"),
-NMS_NBTTAGCOMPOUND("net.minecraft.server.", ".NBTTagCompound"),
-NMS_NBTTAGLIST("net.minecraft.server.", ".NBTTagList"),
-NMS_NBTCOMPRESSEDSTREAMTOOLS("net.minecraft.server.", ".NBTCompressedStreamTools"),
-NMS_MOJANGSONPARSER("net.minecraft.server.", ".MojangsonParser"),
-NMS_TILEENTITY("net.minecraft.server.", ".TileEntity"),
-NMS_BLOCKPOSITION("net.minecraft.server.", ".BlockPosition"),
-NMS_WORLD("net.minecraft.server.", ".WorldServer"),
-NMS_ENTITY("net.minecraft.server.", ".Entity"),
-;
-    
-    
-    
-    private Class<?> clazz;
-    
-    ClassWrapper(String pre, String suffix){
-        try{
-            String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
-            clazz = Class.forName(pre + version + suffix);
-        }catch(Exception ex){
-            ex.printStackTrace();
-        }
-    }
-    
-    public Class<?> getClazz(){
-        return clazz;
-    }
-    
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTCompound.java

@@ -1,200 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.util.Set;
-
-import de.tr7zw.itemnbtapi.utils.MinecraftVersion;
-
-
-public class NBTCompound {
-
-    private String compundName;
-    private NBTCompound parent;
-
-    protected NBTCompound(NBTCompound owner, String name) {
-        this.compundName = name;
-        this.parent = owner;
-    }
-
-    public String getName() {
-        return compundName;
-    }
-
-    protected Object getCompound() {
-        return parent.getCompound();
-    }
-
-    protected void setCompound(Object compound) {
-        parent.setCompound(compound);
-    }
-
-    public NBTCompound getParent() {
-        return parent;
-    }
-
-    public void mergeCompound(NBTCompound comp){
-        NBTReflectionUtil.addOtherNBTCompound(this, comp);
-    }
-    
-    public void setString(String key, String value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_STRING, key, value);
-    }
-
-    public String getString(String key) {
-        return (String) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_STRING, key);
-    }
-
-    protected String getContent(String key) {
-        return NBTReflectionUtil.getContent(this, key);
-    }
-
-    public void setInteger(String key, Integer value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_INT, key, value);
-    }
-
-    public Integer getInteger(String key) {
-        return (Integer) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_INT, key);
-    }
-
-    public void setDouble(String key, Double value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_DOUBLE, key, value);
-    }
-
-    public Double getDouble(String key) {
-        return (Double) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_DOUBLE, key);
-    }
-
-    public void setByte(String key, Byte value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BYTE, key, value);
-    }
-
-    public Byte getByte(String key) {
-        return (Byte) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BYTE, key);
-    }
-
-    public void setShort(String key, Short value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_SHORT, key, value);
-    }
-
-    public Short getShort(String key) {
-        return (Short) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_SHORT, key);
-    }
-
-    public void setLong(String key, Long value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_LONG, key, value);
-    }
-
-    public Long getLong(String key) {
-        return (Long) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_LONG, key);
-    }
-
-    public void setFloat(String key, Float value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_FLOAT, key, value);
-    }
-
-    public Float getFloat(String key) {
-        return (Float) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_FLOAT, key);
-    }
-
-    public void setByteArray(String key, byte[] value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BYTEARRAY, key, value);
-    }
-
-    public byte[] getByteArray(String key) {
-        return (byte[]) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BYTEARRAY, key);
-    }
-
-    public void setIntArray(String key, int[] value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_INTARRAY, key, value);
-    }
-
-    public int[] getIntArray(String key) {
-        return (int[]) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_INTARRAY, key);
-    }
-
-    public void setBoolean(String key, Boolean value) {
-        NBTReflectionUtil.setData(this, ReflectionMethod.COMPOUND_SET_BOOLEAN, key, value);
-    }
-
-    protected void set(String key, Object val) {
-        NBTReflectionUtil.set(this, key, val);
-    }
-
-    public Boolean getBoolean(String key) {
-        return (Boolean) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_BOOLEAN, key);
-    }
-
-    public void setObject(String key, Object value) {
-        NBTReflectionUtil.setObject(this, key, value);
-    }
-
-    public <T> T getObject(String key, Class<T> type) {
-        return NBTReflectionUtil.getObject(this, key, type);
-    }
-    
-    public Boolean hasKey(String key) {
-        Boolean b =  (Boolean) NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_HAS_KEY, key);
-        if(b == null)return false;
-        return b;
-    }
-
-    public void removeKey(String key) {
-        NBTReflectionUtil.remove(this, key);
-    }
-
-    public Set<String> getKeys() {
-        return NBTReflectionUtil.getKeys(this);
-    }
-
-    public NBTCompound addCompound(String name) {
-        if(getType(name) == NBTType.NBTTagCompound)return getCompound(name);
-        NBTReflectionUtil.addNBTTagCompound(this, name);
-        return getCompound(name);
-    }
-
-    public NBTCompound getCompound(String name) {
-        NBTCompound next = new NBTCompound(this, name);
-        if (NBTReflectionUtil.valideCompound(next)) return next;
-        return null;
-    }
-
-    public NBTList getList(String name, NBTType type) {
-        return NBTReflectionUtil.getList(this, name, type);
-    }
-
-    public NBTType getType(String name) {
-        if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_7_R4) return null;
-        Object o = NBTReflectionUtil.getData(this, ReflectionMethod.COMPOUND_GET_TYPE, name);
-        if(o == null)return null;
-        return NBTType.valueOf((byte) o);
-    }
-
-    @Override
-    public String toString() {
-        StringBuilder result = new StringBuilder();
-        for (String key : getKeys()) {
-            result.append(toString(key));
-        }
-        return result.toString();
-    }
-
-    public String toString(String key) {
-        StringBuilder result = new StringBuilder();
-        NBTCompound compound = this;
-        while (compound.getParent() != null) {
-            result.append("   ");
-            compound = compound.getParent();
-        }
-        if (this.getType(key) == NBTType.NBTTagCompound) {
-            return this.getCompound(key).toString();
-        } else {
-            return result + "-" + key + ": " + getContent(key) + System.lineSeparator();
-        }
-    }
-    
-    public String asNBTString(){
-        Object comp = NBTReflectionUtil.gettoCompount(getCompound(), this);
-        if(comp == null)return "{}";
-        return comp.toString();
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTContainer.java

@@ -1,35 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-public class NBTContainer extends NBTCompound{
-
-    private Object nbt;
-
-    public NBTContainer() {
-        super(null, null);
-        nbt = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-    }
-    
-    protected NBTContainer(Object nbt){
-        super(null, null);
-        this.nbt = nbt;
-    }
-
-    public NBTContainer(String nbtString) throws IllegalArgumentException {
-        super(null, null);
-        try{
-            nbt = ReflectionMethod.PARSE_NBT.run(null, nbtString);
-        }catch(Exception ex){
-            ex.printStackTrace();
-            throw new IllegalArgumentException("Malformed Json: " + ex.getMessage());
-        }
-    }
-
-    protected Object getCompound() {
-        return nbt;
-    }
-
-    protected void setCompound(Object tag) {
-        nbt = tag;
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTEntity.java

@@ -1,22 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import org.bukkit.entity.Entity;
-
-public class NBTEntity extends NBTCompound {
-
-    private final Entity ent;
-
-    public NBTEntity(Entity entity) {
-        super(null, null);
-        ent = entity;
-    }
-
-    protected Object getCompound() {
-        return NBTReflectionUtil.getEntityNBTTagCompound(NBTReflectionUtil.getNMSEntity(ent));
-    }
-
-    protected void setCompound(Object compound) {
-        NBTReflectionUtil.setEntityNBTTag(compound, NBTReflectionUtil.getNMSEntity(ent));
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTFile.java

@@ -1,46 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-public class NBTFile extends NBTCompound {
-
-    private final File file;
-    private Object nbt;
-
-    public NBTFile(File file) throws IOException {
-        super(null, null);
-        this.file = file;
-        if (file.exists()) {
-            FileInputStream inputsteam = new FileInputStream(file);
-            nbt = NBTReflectionUtil.readNBTFile(inputsteam);
-        } else {
-            nbt = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-            save();
-        }
-    }
-
-    public void save() throws IOException {
-        if (!file.exists()) {
-            file.getParentFile().mkdirs();
-            file.createNewFile();
-        }
-        FileOutputStream outStream = new FileOutputStream(file);
-        NBTReflectionUtil.saveNBTFile(nbt, outStream);
-    }
-
-    public File getFile() {
-        return file;
-    }
-
-    protected Object getCompound() {
-        return nbt;
-    }
-
-    protected void setCompound(Object compound) {
-        nbt = compound;
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTItem.java

@@ -1,53 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import org.bukkit.inventory.ItemStack;
-
-public class NBTItem extends NBTCompound {
-
-    private ItemStack bukkitItem;
-
-    public NBTItem(ItemStack item) {
-        super(null, null);
-        if(item == null){
-            throw new NullPointerException("ItemStack can't be null!");
-        }
-        bukkitItem = item.clone();
-    }
-
-    protected Object getCompound() {
-        return NBTReflectionUtil.getItemRootNBTTagCompound(ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, bukkitItem));
-    }
-
-    protected void setCompound(Object compound) {
-        Object stack = ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, bukkitItem);
-        ReflectionMethod.ITEMSTACK_SET_TAG.run(stack, compound);
-        bukkitItem = (ItemStack) ReflectionMethod.ITEMSTACK_BUKKITMIRROR.run(null, stack);
-    }
-
-    public ItemStack getItem() {
-        return bukkitItem;
-    }
-
-    protected void setItem(ItemStack item) {
-        bukkitItem = item;
-    }
-    
-    
-    /**
-     * This may return true even when the NBT is empty.
-     * 
-     * @return Does the ItemStack have a NBTCompound.
-     */
-    public boolean hasNBTData(){
-        return getCompound() != null;
-    }
-    
-    public static NBTContainer convertItemtoNBT(ItemStack item){
-        return NBTReflectionUtil.convertNMSItemtoNBTCompound(ReflectionMethod.ITEMSTACK_NMSCOPY.run(null, item));
-    }
-    
-    public static ItemStack convertNBTtoItem(NBTCompound comp){
-        return (ItemStack) ReflectionMethod.ITEMSTACK_BUKKITMIRROR.run(null, NBTReflectionUtil.convertNBTCompoundtoNMSItem(comp));
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTList.java

@@ -1,127 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import de.tr7zw.itemnbtapi.utils.MinecraftVersion;
-
-public class NBTList {
-
-	private String listName;
-	private NBTCompound parent;
-	private NBTType type;
-	private Object listObject;
-
-	protected NBTList(NBTCompound owner, String name, NBTType type, Object list) {
-		parent = owner;
-		listName = name;
-		this.type = type;
-		this.listObject = list;
-		if (!(type == NBTType.NBTTagString || type == NBTType.NBTTagCompound)) {
-			System.err.println("List types != String/Compound are currently not implemented!");
-		}
-	}
-
-	protected void save() {
-		parent.set(listName, listObject);
-	}
-
-	public NBTListCompound addCompound() {
-		if (type != NBTType.NBTTagCompound) {
-			new Throwable("Using Compound method on a non Compound list!").printStackTrace();
-			return null;
-		}
-		try {
-			Object compound = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
-			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
-				ReflectionMethod.LIST_ADD.run(listObject, 0, compound);
-			} else {
-				ReflectionMethod.LEGACY_LIST_ADD.run(listObject, compound);
-			}
-			return new NBTListCompound(this, compound);
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-		return null;
-	}
-
-	public NBTListCompound getCompound(int id) {
-		if (type != NBTType.NBTTagCompound) {
-			new Throwable("Using Compound method on a non Compound list!").printStackTrace();
-			return null;
-		}
-		try {
-			Object compound = ReflectionMethod.LIST_GET.run(listObject, id);
-			return new NBTListCompound(this, compound);
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-		return null;
-	}
-
-	public String getString(int i) {
-		if (type != NBTType.NBTTagString) {
-			new Throwable("Using String method on a non String list!").printStackTrace();
-			return null;
-		}
-		try {
-			return (String) ReflectionMethod.LIST_GET_STRING.run(listObject, i);
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-		return null;
-	}
-
-	public void addString(String s) {
-		if (type != NBTType.NBTTagString) {
-			new Throwable("Using String method on a non String list!").printStackTrace();
-			return;
-		}
-		try {
-			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_14_R1.getVersionId()) {
-				ReflectionMethod.LIST_ADD.run(listObject, 0,
-						ClassWrapper.NMS_NBTTAGSTRING.getClazz().getConstructor(String.class).newInstance(s));
-			} else {
-				ReflectionMethod.LEGACY_LIST_ADD.run(listObject,
-						ClassWrapper.NMS_NBTTAGSTRING.getClazz().getConstructor(String.class).newInstance(s));
-			}
-			save();
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-	}
-
-	public void setString(int i, String s) {
-		if (type != NBTType.NBTTagString) {
-			new Throwable("Using String method on a non String list!").printStackTrace();
-			return;
-		}
-		try {
-			ReflectionMethod.LIST_SET.run(listObject, i,
-					ClassWrapper.NMS_NBTTAGSTRING.getClazz().getConstructor(String.class).newInstance(s));
-			save();
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-	}
-
-	public void remove(int i) {
-		try {
-			ReflectionMethod.LIST_REMOVE_KEY.run(listObject, i);
-			save();
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-	}
-
-	public int size() {
-		try {
-			return (int) ReflectionMethod.LIST_SIZE.run(listObject);
-		} catch (Exception ex) {
-			ex.printStackTrace();
-		}
-		return -1;
-	}
-
-	public NBTType getType() {
-		return type;
-	}
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTListCompound.java

@@ -1,102 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public class NBTListCompound {
-
-    private NBTList owner;
-    private Object compound;
-
-    protected NBTListCompound(NBTList parent, Object obj) {
-        owner = parent;
-        compound = obj;
-    }
-
-    public void setString(String key, String value) {
-        if (value == null) {
-            remove(key);
-            return;
-        }
-        try {
-            compound.getClass().getMethod("setString", String.class, String.class).invoke(compound, key, value);
-            owner.save();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public void setInteger(String key, int value) {
-        try {
-            compound.getClass().getMethod("setInt", String.class, int.class).invoke(compound, key, value);
-            owner.save();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public int getInteger(String value) {
-        try {
-            return (int) compound.getClass().getMethod("getInt", String.class).invoke(compound, value);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return 0;
-    }
-
-    public void setDouble(String key, double value) {
-        try {
-            compound.getClass().getMethod("setDouble", String.class, double.class).invoke(compound, key, value);
-            owner.save();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public double getDouble(String key) {
-        try {
-            return (double) compound.getClass().getMethod("getDouble", String.class).invoke(compound, key);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return 0;
-    }
-
-
-    public String getString(String key) {
-        try {
-            return (String) compound.getClass().getMethod("getString", String.class).invoke(compound, key);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return "";
-    }
-
-    public boolean hasKey(String key) {
-        try {
-            return (boolean) compound.getClass().getMethod("hasKey", String.class).invoke(compound, key);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return false;
-    }
-
-    @SuppressWarnings("unchecked")
-    public Set<String> getKeys() {
-        try {
-            return (Set<String>) ReflectionMethod.LISTCOMPOUND_GET_KEYS.run(compound);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return new HashSet<>();
-    }
-
-    public void remove(String key) {
-        try {
-            compound.getClass().getMethod("remove", String.class).invoke(compound, key);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTReflectionUtil.java

@@ -1,348 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.util.Set;
-import java.util.Stack;
-
-import org.bukkit.block.BlockState;
-import org.bukkit.entity.Entity;
-
-import de.tr7zw.itemnbtapi.utils.GsonWrapper;
-import de.tr7zw.itemnbtapi.utils.MinecraftVersion;
-
-public class NBTReflectionUtil {  
-
-    public static Object getNMSEntity(Entity entity) {
-        try {
-            return ReflectionMethod.CRAFT_ENTITY_GET_HANDLE.run(ClassWrapper.CRAFT_ENTITY.getClazz().cast(entity));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static Object readNBTFile(FileInputStream stream) {
-        try {
-            return ReflectionMethod.NBTFILE_READ.run(null, stream);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static Object saveNBTFile(Object nbt, FileOutputStream stream) {
-        try {
-            return ReflectionMethod.NBTFILE_WRITE.run(null, nbt, stream);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    @SuppressWarnings({"unchecked"})
-    public static Object getItemRootNBTTagCompound(Object nmsitem) {
-        @SuppressWarnings("rawtypes")
-        Class clazz = nmsitem.getClass();
-        Method method;
-        try {
-            method = clazz.getMethod("getTag");
-            Object answer = method.invoke(nmsitem);
-            return answer;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    @SuppressWarnings({"unchecked"})
-    public static Object convertNBTCompoundtoNMSItem(NBTCompound nbtcompound) {
-        @SuppressWarnings("rawtypes")
-        Class clazz = ClassWrapper.NMS_ITEMSTACK.getClazz();
-        try {
-            if(MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_12_R1.getVersionId()){
-                Constructor<?> constructor = clazz.getConstructor(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz());
-                constructor.setAccessible(true);
-                return constructor.newInstance(nbtcompound.getCompound());
-            }else{
-                Method method = clazz.getMethod("createStack", ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz());
-                method.setAccessible(true);
-                return method.invoke(null, nbtcompound.getCompound());
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    @SuppressWarnings({"unchecked"})
-    public static NBTContainer convertNMSItemtoNBTCompound(Object nmsitem) {
-        @SuppressWarnings("rawtypes")
-        Class clazz = nmsitem.getClass();
-        Method method;
-        try {
-            method = clazz.getMethod("save", ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz());
-            Object answer = method.invoke(nmsitem, ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance());
-            return new NBTContainer(answer);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static Object getEntityNBTTagCompound(Object NMSEntity) {
-        try {
-            Object nbt = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
-            Object answer = ReflectionMethod.NMS_ENTITY_GET_NBT.run(NMSEntity, nbt);
-            if (answer == null)
-                answer = nbt;
-            return answer;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static Object setEntityNBTTag(Object NBTTag, Object NMSEntity) {
-        try {
-            ReflectionMethod.NMS_ENTITY_SET_NBT.run(NMSEntity, NBTTag);
-            return NMSEntity;
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return null;
-    }
-
-    public static Object getTileEntityNBTTagCompound(BlockState tile) {
-        try {
-            Object pos = ObjectCreator.NMS_BLOCKPOSITION.getInstance(tile.getX(), tile.getY(), tile.getZ());
-            Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(tile.getWorld());
-            Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
-            Object o = ReflectionMethod.NMS_WORLD_GET_TILEENTITY.run(nmsworld, pos);
-            Object tag = ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance();
-            Object answer = ReflectionMethod.TILEENTITY_GET_NBT.run(o, tag);
-            if (answer == null)
-                answer = tag;
-            return answer;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static void setTileEntityNBTTagCompound(BlockState tile, Object comp) {
-        try {
-            Object pos = ObjectCreator.NMS_BLOCKPOSITION.getInstance(tile.getX(), tile.getY(), tile.getZ());
-            Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(tile.getWorld());
-            Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
-            Object o = ReflectionMethod.NMS_WORLD_GET_TILEENTITY.run(nmsworld, pos);
-            ReflectionMethod.TILEENTITY_SET_NBT.run(o, comp);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-
-    @SuppressWarnings("unchecked")
-    public static Object getSubNBTTagCompound(Object compound, String name) {
-        @SuppressWarnings("rawtypes")
-        Class c = compound.getClass();
-        Method method;
-        try {
-            method = c.getMethod("getCompound", String.class);
-            Object answer = method.invoke(compound, name);
-            return answer;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    public static void addNBTTagCompound(NBTCompound comp, String name) {
-        if (name == null) {
-            remove(comp, name);
-            return;
-        }
-        Object nbttag = comp.getCompound();
-        if (nbttag == null) {
-            nbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return;
-        Object workingtag = gettoCompount(nbttag, comp);
-        Method method;
-        try {
-            method = workingtag.getClass().getMethod("set", String.class, ClassWrapper.NMS_NBTBASE.getClazz());
-            method.invoke(workingtag, name, ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz().newInstance());
-            comp.setCompound(nbttag);
-            return;
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return;
-    }
-
-    public static Boolean valideCompound(NBTCompound comp) {
-        Object root = comp.getCompound();
-        if (root == null) {
-            root = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        return (gettoCompount(root, comp)) != null;
-    }
-
-    static Object gettoCompount(Object nbttag, NBTCompound comp) {
-        Stack<String> structure = new Stack<>();
-        while (comp.getParent() != null) {
-            structure.add(comp.getName());
-            comp = comp.getParent();
-        }
-        while (!structure.isEmpty()) {
-            nbttag = getSubNBTTagCompound(nbttag, structure.pop());
-            if (nbttag == null) {
-                return null;
-            }
-        }
-        return nbttag;
-    }
-
-    public static void addOtherNBTCompound(NBTCompound comp, NBTCompound nbtcompound) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        try {
-            ReflectionMethod.COMPOUND_ADD.run(workingtag, nbtcompound.getCompound());
-            comp.setCompound(rootnbttag);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public static String getContent(NBTCompound comp, String key) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return null;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        Method method;
-        try {
-            method = workingtag.getClass().getMethod("get", String.class);
-            return method.invoke(workingtag, key).toString();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return null;
-    }
-
-    public static void set(NBTCompound comp, String key, Object val) {
-        if (val == null) {
-            remove(comp, key);
-            return;
-        }
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) {
-            new Throwable("InvalideCompound").printStackTrace();
-            return;
-        }
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        Method method;
-        try {
-            method = workingtag.getClass().getMethod("set", String.class, ClassWrapper.NMS_NBTBASE.getClazz());
-            method.invoke(workingtag, key, val);
-            comp.setCompound(rootnbttag);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public static NBTList getList(NBTCompound comp, String key, NBTType type) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return null;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        Method method;
-        try {
-            method = workingtag.getClass().getMethod("getList", String.class, int.class);
-            return new NBTList(comp, key, type, method.invoke(workingtag, key, type.getId()));
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-        return null;
-    }
-
-    public static void setObject(NBTCompound comp, String key, Object value) {
-        if (!MinecraftVersion.hasGsonSupport()) return;
-        try {
-            String json = GsonWrapper.getString(value);
-            setData(comp, ReflectionMethod.COMPOUND_SET_STRING, key, json);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-    }
-
-    public static <T> T getObject(NBTCompound comp, String key, Class<T> type) {
-        if (!MinecraftVersion.hasGsonSupport()) return null;
-        String json = (String) getData(comp, ReflectionMethod.COMPOUND_GET_STRING, key);
-        if (json == null) {
-            return null;
-        }
-        return GsonWrapper.deserializeJson(json, type);
-    }
-
-    public static void remove(NBTCompound comp, String key) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        ReflectionMethod.COMPOUND_REMOVE_KEY.run(workingtag, key);
-        comp.setCompound(rootnbttag);
-    }
-
-    @SuppressWarnings("unchecked")
-    public static Set<String> getKeys(NBTCompound comp) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return null;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        return (Set<String>) ReflectionMethod.COMPOUND_GET_KEYS.run(workingtag);
-    }
-
-    public static void setData(NBTCompound comp, ReflectionMethod type, String key, Object data) {
-        if (data == null) {
-            remove(comp, key);
-            return;
-        }
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            rootnbttag = ObjectCreator.NMS_NBTTAGCOMPOUND.getInstance();
-        }
-        if (!valideCompound(comp)) return;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        type.run(workingtag, key, data);
-        comp.setCompound(rootnbttag);
-    }
-
-    public static Object getData(NBTCompound comp, ReflectionMethod type, String key) {
-        Object rootnbttag = comp.getCompound();
-        if (rootnbttag == null) {
-            return null;
-        }
-        if (!valideCompound(comp)) return null;
-        Object workingtag = gettoCompount(rootnbttag, comp);
-        return type.run(workingtag, key);
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTTileEntity.java

@@ -1,22 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import org.bukkit.block.BlockState;
-
-public class NBTTileEntity extends NBTCompound {
-
-    private final BlockState tile;
-
-    public NBTTileEntity(BlockState tile) {
-        super(null, null);
-        this.tile = tile;
-    }
-
-    protected Object getCompound() {
-        return NBTReflectionUtil.getTileEntityNBTTagCompound(tile);
-    }
-
-    protected void setCompound(Object compound) {
-        NBTReflectionUtil.setTileEntityNBTTagCompound(tile, compound);
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/NBTType.java

@@ -1,34 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-public enum NBTType {
-    NBTTagEnd(0),
-    NBTTagByte(1),
-    NBTTagShort(2),
-    NBTTagInt(3),
-    NBTTagLong(4),
-    NBTTagFloat(5),
-    NBTTagDouble(6),
-    NBTTagByteArray(7),
-    NBTTagIntArray(11),
-    NBTTagString(8),
-    NBTTagList(9),
-    NBTTagCompound(10);
-
-    NBTType(int i) {
-        id = i;
-    }
-
-    private final int id;
-
-    public int getId() {
-        return id;
-    }
-
-    public static NBTType valueOf(int id) {
-        for (NBTType t : values())
-            if (t.getId() == id)
-                return t;
-        return NBTType.NBTTagEnd;
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/ObjectCreator.java

@@ -1,28 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.lang.reflect.Constructor;
-
-public enum ObjectCreator {
-    NMS_NBTTAGCOMPOUND(ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz()),
-    NMS_BLOCKPOSITION(ClassWrapper.NMS_BLOCKPOSITION.getClazz(), int.class, int.class, int.class);
-
-    private Constructor<?> construct;
-
-    ObjectCreator(Class<?> clazz, Class<?>... args){
-        try{
-            construct = clazz.getConstructor(args);
-        }catch(Exception ex){
-            ex.printStackTrace();
-        }
-    }
-    
-    public Object getInstance(Object... args){
-        try{
-            return construct.newInstance(args);
-        }catch(Exception ex){
-            ex.printStackTrace();
-        }
-        return null;
-    }
-    
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/utils/GsonWrapper.java

@@ -1,27 +0,0 @@
-package de.tr7zw.itemnbtapi.utils;
-
-import com.google.gson.Gson;
-
-public class GsonWrapper {
-
-    private static final Gson gson = new Gson();
-
-    public static String getString(Object obj) {
-        return gson.toJson(obj);
-    }
-
-    public static <T> T deserializeJson(String json, Class<T> type) {
-        try {
-            if (json == null) {
-                return null;
-            }
-
-            T obj = gson.fromJson(json, type);
-            return type.cast(obj);
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            return null;
-        }
-    }
-
-}

item-nbt-api/src/main/java/de/tr7zw/itemnbtapi/utils/MinecraftVersion.java

@@ -1,63 +0,0 @@
-package de.tr7zw.itemnbtapi.utils;
-
-import org.bukkit.Bukkit;
-
-public enum MinecraftVersion {
-    Unknown(Integer.MAX_VALUE),//Use the newest known mappings
-    MC1_7_R4(174),
-    MC1_8_R3(183),
-    MC1_9_R1(191),
-    MC1_9_R2(192),
-    MC1_10_R1(1101),
-    MC1_11_R1(1111),
-    MC1_12_R1(1121),
-    MC1_13_R1(1131),
-    MC1_13_R2(1132),
-    MC1_14_R1(1141);
-
-    private static MinecraftVersion version;
-    private static Boolean hasGsonSupport;
-
-    private final int versionId;
-
-    MinecraftVersion(int versionId) {
-        this.versionId = versionId;
-    }
-
-    public int getVersionId() {
-        return versionId;
-    }
-
-    public static MinecraftVersion getVersion() {
-        if (version != null) {
-            return version;
-        }
-        final String ver = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
-        System.out.println("[NBTAPI] Found Spigot: " + ver + "! Trying to find NMS support");
-        try {
-            version = MinecraftVersion.valueOf(ver.replace("v", "MC"));
-        } catch (IllegalArgumentException ex) {
-            version = MinecraftVersion.Unknown;
-        }
-        if (version != Unknown) {
-            System.out.println("[NBTAPI] NMS support '" + version.name() + "' loaded!");
-        } else {
-            System.out.println("[NBTAPI] Wasn't able to find NMS Support! Some functions may not work!");
-        }
-        return version;
-    }
-
-    public static boolean hasGsonSupport() {
-        if (hasGsonSupport != null) {
-            return hasGsonSupport;
-        }
-        try {
-            System.out.println("Found Gson: " + Class.forName("com.google.gson.Gson"));
-            hasGsonSupport = true;
-        } catch (Exception ex) {
-            hasGsonSupport = false;
-        }
-        return hasGsonSupport;
-    }
-
-}

item-nbt-plugin/pom.xml

@@ -1,73 +1,86 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>de.tr7zw</groupId>
-        <artifactId>item-nbt-parent</artifactId>
-        <version>1.8.3-SNAPSHOT</version>
-    </parent>
-
-    <artifactId>item-nbt-api-plugin</artifactId>
-    <packaging>jar</packaging>
-
-    <build>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.1</version>
-                <configuration>
-                    <createDependencyReducedPom>false</createDependencyReducedPom>
-                    <relocations>
-                        <relocation>
-                            <pattern>org.bstats</pattern>
-                            <shadedPattern>de.tr7zw.itemnbtapi</shadedPattern>
-                        </relocation>
-                    </relocations>
-                </configuration>
-                <executions>
-                    <execution>
-                        <id>shade</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
-    <repositories>
-        <repository>
-            <id>bstats-repo</id>
-            <url>http://repo.bstats.org/content/repositories/releases/</url>
-        </repository>
-    </repositories>
-
-    <dependencies>
-        <dependency>
-            <groupId>de.tr7zw</groupId>
-            <artifactId>item-nbt-api</artifactId>
-            <version>1.8.3-SNAPSHOT</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.bstats</groupId>
-            <artifactId>bstats-bukkit-lite</artifactId>
-            <version>1.2</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>de.tr7zw</groupId>
+    <artifactId>item-nbt-parent</artifactId>
+    <version>2.2.0</version>
+  </parent>
+  <artifactId>item-nbt-api-plugin</artifactId>
+  <packaging>jar</packaging>
+  <dependencies>
+    <dependency>
+      <groupId>de.tr7zw</groupId>
+      <artifactId>item-nbt-api</artifactId>
+      <version>2.2.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>de.tr7zw</groupId>
+      <artifactId>nbt-injector</artifactId>
+      <version>2.2.0</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <resources>
+      <resource>
+        <filtering>true</filtering>
+        <directory>src/main/resources</directory>
+      </resource>
+    </resources>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.2.1</version>
+        <executions>
+          <execution>
+            <id>shade</id>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <createDependencyReducedPom>false</createDependencyReducedPom>
+          <relocations>
+            <relocation>
+              <pattern>de.tr7zw.changeme.nbtapi</pattern>
+              <shadedPattern>de.tr7zw.nbtapi</shadedPattern>
+            </relocation>
+          </relocations>
+        </configuration>
+      </plugin>
+      <!-- Start and Stop a SpigotMC server automatically before and after the integration-test phase. -->
+      <plugin>
+        <groupId>de.tr7zw.spigotmc.maven</groupId>
+        <artifactId>tr-spigotmc-maven-plugin</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <executions>
+          <execution>
+            <id>start-server</id>
+            <goals>
+              <goal>start</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>stop-server</id>
+            <goals>
+              <goal>stop</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <!-- 1.8.8-R0.1-SNAPSHOT-latest, 1.9.2-R0.1-SNAPSHOT-latest, 1.9.4-R0.1-SNAPSHOT-latest, 1.10.2-R0.1-SNAPSHOT-latest,1.11.2,1.12.2,1.13.2,1.14.4,1.15.1 -->
+          <versions>1.8.8-R0.1-SNAPSHOT-latest, 1.9.2-R0.1-SNAPSHOT-latest, 1.9.4-R0.1-SNAPSHOT-latest, 1.10.2-R0.1-SNAPSHOT-latest,1.11.2,1.12.2,1.13.2,1.14.4,1.15.1</versions>
+          <works>Success! This version of NBT-API</works>
+          <error>WARNING! This version of NBT-API</error>
+          <filename>item-nbt-api-plugin-${project.version}.jar</filename>
+          <foldername>item-nbt-plugin</foldername>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
 </project>

item-nbt-plugin/src/main/java/de/tr7zw/itemnbtapi/ItemNBTAPI.java

@@ -1,382 +0,0 @@
-package de.tr7zw.itemnbtapi;
-
-import java.io.File;
-import java.util.logging.Level;
-
-import org.bstats.bukkit.MetricsLite;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.entity.Animals;
-import org.bukkit.entity.Monster;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import de.tr7zw.itemnbtapi.utils.MinecraftVersion;
-
-public class ItemNBTAPI extends JavaPlugin {
-
-    private static boolean compatible = true;
-    private static boolean jsonCompatible = true;
-
-    @Deprecated
-    public static ItemNBTAPI instance;
-
-    public static ItemNBTAPI getInstance() {
-        return instance;
-    }
-
-    @Override
-    public void onEnable() {
-        instance = this;
-        new MetricsLite(this);
-        getLogger().info("Checking bindings...");
-        getLogger().info("Minecraft Version:");
-        MinecraftVersion.getVersion();
-        getLogger().info("Gson:");
-        MinecraftVersion.hasGsonSupport();
-        getLogger().info("Classes:");
-        for (ClassWrapper c : ClassWrapper.values()) {
-            if (c.getClazz() == null) {
-                getLogger().warning(c.name() + " did not find it's class!");
-                compatible = false;
-            }
-        }
-        getLogger().info("Methods:");
-        for (ReflectionMethod method : ReflectionMethod.values()) {
-            if (method.isCompatible() && !method.isLoaded()) {
-                getLogger().warning(method.name() + " did not find the method!");
-                compatible = false;
-            }
-        }
-        getLogger().info("Running NBT reflection test...");
-        try {
-            //Item
-            ItemStack item = new ItemStack(Material.STONE, 1);
-            NBTItem nbtItem = new NBTItem(item);
-
-            nbtItem.setString(STRING_TEST_KEY, STRING_TEST_VALUE);
-            nbtItem.setInteger(INT_TEST_KEY, INT_TEST_VALUE);
-            nbtItem.setDouble(DOUBLE_TEST_KEY, DOUBLE_TEST_VALUE);
-            nbtItem.setBoolean(BOOLEAN_TEST_KEY, BOOLEAN_TEST_VALUE);
-            nbtItem.setByte(BYTE_TEST_KEY, BYTE_TEST_VALUE);
-            nbtItem.setShort(SHORT_TEST_KEY, SHORT_TEST_VALUE);
-            nbtItem.setLong(LONG_TEST_KEY, LONG_TEST_VALUE);
-            nbtItem.setFloat(FLOAT_TEST_KEY, FLOAT_TEST_VALUE);
-            nbtItem.setIntArray(INTARRAY_TEST_KEY, INTARRAY_TEST_VALUE);
-            nbtItem.setByteArray(BYTEARRAY_TEST_KEY, BYTEARRAY_TEST_VALUE);
-            nbtItem.addCompound(COMP_TEST_KEY);
-            NBTCompound comp = nbtItem.getCompound(COMP_TEST_KEY);
-            comp.setString(STRING_TEST_KEY, STRING_TEST_VALUE + "2");
-            comp.setInteger(INT_TEST_KEY, INT_TEST_VALUE * 2);
-            comp.setDouble(DOUBLE_TEST_KEY, DOUBLE_TEST_VALUE * 2);
-            NBTList list = comp.getList("testlist", NBTType.NBTTagString);
-            if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_7_R4) {
-                getLogger().warning(
-                        "Skipped the NBTList check, because 1.7 doesn't fully support it! The Item-NBT-API may not work!");
-            } else {
-                list.addString("test1");
-                list.addString("test2");
-                list.addString("test3");
-                list.addString("test4");
-                list.setString(2, "test42");
-                list.remove(1);
-            }
-            NBTList taglist = comp.getList("complist", NBTType.NBTTagCompound);
-            NBTListCompound lcomp = taglist.addCompound();
-            lcomp.setDouble("double1", 0.3333);
-            lcomp.setInteger("int1", 42);
-            lcomp.setString("test1", "test1");
-            lcomp.setString("test2", "test2");
-            lcomp.remove("test1");
-
-            item = nbtItem.getItem();
-            nbtItem = new NBTItem(item);
-
-            if (!nbtItem.hasKey(STRING_TEST_KEY)) {
-                getLogger().warning("Wasn't able to check a key! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            if (!(STRING_TEST_VALUE).equals(nbtItem.getString(STRING_TEST_KEY))
-                    || nbtItem.getInteger(INT_TEST_KEY) != INT_TEST_VALUE
-                    || nbtItem.getDouble(DOUBLE_TEST_KEY) != DOUBLE_TEST_VALUE
-                    || nbtItem.getByte(BYTE_TEST_KEY) != BYTE_TEST_VALUE
-                    || nbtItem.getShort(SHORT_TEST_KEY) != SHORT_TEST_VALUE
-                    || nbtItem.getFloat(FLOAT_TEST_KEY) != FLOAT_TEST_VALUE
-                    || nbtItem.getLong(LONG_TEST_KEY) != LONG_TEST_VALUE
-                    || nbtItem.getIntArray(INTARRAY_TEST_KEY).length != (INTARRAY_TEST_VALUE).length
-                    || nbtItem.getByteArray(BYTEARRAY_TEST_KEY).length != (BYTEARRAY_TEST_VALUE).length
-                    || !nbtItem.getBoolean(BOOLEAN_TEST_KEY).equals(BOOLEAN_TEST_VALUE)) {
-                getLogger().warning("One key does not equal the original value! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            nbtItem.setString(STRING_TEST_KEY, null);
-            if (nbtItem.getKeys().size() != 10) {
-                getLogger().warning("Wasn't able to remove a key (Got " + nbtItem.getKeys().size()
-                        + " when expecting 10)! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            comp = nbtItem.getCompound(COMP_TEST_KEY);
-            if (comp == null) {
-                getLogger().warning("Wasn't able to get the NBTCompound! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            if (!comp.hasKey(STRING_TEST_KEY)) {
-                getLogger().warning("Wasn't able to check a compound key! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            if (!(STRING_TEST_VALUE + "2").equals(comp.getString(STRING_TEST_KEY))
-                    || comp.getInteger(INT_TEST_KEY) != INT_TEST_VALUE * 2
-                    || comp.getDouble(DOUBLE_TEST_KEY) != DOUBLE_TEST_VALUE * 2
-                    || comp.getBoolean(BOOLEAN_TEST_KEY) == BOOLEAN_TEST_VALUE) {
-                getLogger()
-                        .warning("One key does not equal the original compound value! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-
-            list = comp.getList("testlist", NBTType.NBTTagString);
-            if (comp.getType("testlist") != NBTType.NBTTagList) {
-                getLogger().warning("Wasn't able to get the correct Tag type! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            if (!list.getString(1).equals("test42") || list.size() != 3) {
-                getLogger().warning("The List support got an error, and may not work!");
-            }
-            taglist = comp.getList("complist", NBTType.NBTTagCompound);
-            if (taglist.size() == 1) {
-                lcomp = taglist.getCompound(0);
-                if (lcomp.getKeys().size() != 3) {
-                    getLogger().warning("Wrong key amount in Taglist (" + lcomp.getKeys().size()
-                            + ")! The Item-NBT-API may not work!");
-                    compatible = false;
-                } else if (!(lcomp.getDouble("double1") == 0.3333 && lcomp.getInteger("int1") == 42
-                        && lcomp.getString("test2").equals("test2") && !lcomp.hasKey("test1"))) {
-                    getLogger().warning("One key in the Taglist changed! The Item-NBT-API may not work!");
-                    compatible = false;
-                }
-            } else {
-                getLogger().warning("Taglist is empty! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-        } catch (Exception ex) {
-            getLogger().log(Level.SEVERE, null, ex);
-            compatible = false;
-        }
-
-        testJson();
-
-        try {
-            //File
-            NBTFile file = new NBTFile(new File(getDataFolder(), "test.nbt"));
-            file.addCompound("testcomp").setString("test1", "ok");
-            NBTCompound comp = file.getCompound("testcomp");
-            comp.setString("test2", "ok");
-            file.setLong("time", System.currentTimeMillis());
-            file.setString("test", "test");
-            file.save();
-            file = null;
-            file = new NBTFile(new File(getDataFolder(), "test.nbt"));
-            System.out.println(file.asNBTString());
-            file.getFile().delete();
-            //String
-            String str = file.asNBTString();
-            NBTContainer rebuild = new NBTContainer(str);
-            if (!str.equals(rebuild.asNBTString())) {
-                getLogger().warning("Wasn't able to parse NBT from a String! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-            //Item->NBT->String->NBT->Item
-            ItemStack preitem = new ItemStack(Material.STICK, 5);
-            ItemMeta premeta = preitem.getItemMeta();
-            premeta.setDisplayName("test");
-            preitem.setItemMeta(premeta);
-            // String itemasString = NBTItem.convertItemtoNBT(preitem).asNBTString();
-            //ItemStack afteritem = NBTItem.convertNBTtoItem(new NBTContainer(itemasString));
-            //if(!preitem.isSimilar(afteritem)){
-            //    getLogger().warning("Wasn't able to convert an Item to String and back to Item! The Item-NBT-API may not work!");
-            //   compatible = false;
-            //}
-            //mergingtags
-            NBTContainer test1 = new NBTContainer();
-            test1.setString("test1", "test");
-            NBTContainer test2 = new NBTContainer();
-            test2.setString("test2", "test");
-            test2.addCompound("test").setLong("time", System.currentTimeMillis());
-            test1.mergeCompound(test2);
-            if (!test1.getString("test1").equals(test1.getString("test2"))) {
-                getLogger().warning("Wasn't able to merge Compounds! The Item-NBT-API may not work!");
-                compatible = false;
-            }
-
-            if (!Bukkit.getWorlds().isEmpty()) {
-                World world = Bukkit.getWorlds().get(0);
-                try {
-                    if (!world.getEntitiesByClasses(Animals.class, Monster.class).isEmpty()) {
-                        getLogger().info("Testing Entity NBT!");
-                        NBTEntity nbte = new NBTEntity(
-                                world.getEntitiesByClasses(Animals.class, Monster.class).iterator().next());
-                        getLogger().info(nbte.asNBTString());
-                        nbte.setString("INVALIDEKEY", "test");
-                        getLogger().info("Entity NBT seems to work!");
-                    }
-                } catch (Exception ex) {
-                    getLogger().warning("Wasn't able to use NBTEntities! The Item-NBT-API may not work!");
-                    compatible = false;
-                    ex.printStackTrace();
-                }
-              /*  try {
-                    Block block = world.getBlockAt(world.getSpawnLocation().getBlockX(), 255, world.getSpawnLocation().getBlockZ());
-                    if (block.getType() == Material.AIR) {
-                        getLogger().info("Testing Tile NBT!");
-                        block.setType(Material.CHEST);
-                        NBTTileEntity tile = new NBTTileEntity(block.getState());
-                        getLogger().info(tile.asNBTString());
-                        tile.setString("Lock", "test");
-                        getLogger().info(tile.asNBTString());
-                        block.setType(Material.AIR);
-                        getLogger().info("Tile NBT seems to work!");
-                    }
-                } catch (Exception ex) {
-                    getLogger().warning("Wasn't able to use NBTTiles! The Item-NBT-API may not work!");
-                    compatible = false;
-                    ex.printStackTrace();
-                }*/
-            }
-
-        } catch (Exception ex) {
-            getLogger().log(Level.SEVERE, null, ex);
-            compatible = false;
-        }
-
-        String checkMessage = "Plugins that don't check properly may throw Exeptions, crash or have unexpected behaviors!";
-        if (compatible) {
-            if (jsonCompatible) {
-                getLogger().info("Success! This version of Item-NBT-API is compatible with your server.");
-            } else {
-                getLogger()
-                        .info("General Success! This version of Item-NBT-API is mostly compatible with your server. JSON serialization is not working properly. "
-                                + checkMessage);
-            }
-        } else {
-            getLogger().warning("WARNING! This version of Item-NBT-API seems to be broken with your Spigot version! "
-                    + checkMessage);
-        }
-
-    }
-
-    public void testJson() {
-        if (!MinecraftVersion.hasGsonSupport()) {
-            getLogger().warning(
-                    "Wasn't able to find Gson! The Item-NBT-API may not work with Json serialization/deserialization!");
-            return;
-        }
-        try {
-            ItemStack item = new ItemStack(Material.STONE, 1);
-            NBTItem nbtItem = new NBTItem(item);
-
-            nbtItem.setObject(JSON_TEST_KEY, new SimpleJsonTestObject());
-
-            if (!nbtItem.hasKey(JSON_TEST_KEY)) {
-                getLogger().warning(
-                        "Wasn't able to find JSON key! The Item-NBT-API may not work with Json serialization/deserialization!");
-                jsonCompatible = false;
-            } else {
-                SimpleJsonTestObject simpleObject = nbtItem.getObject(JSON_TEST_KEY, SimpleJsonTestObject.class);
-                if (simpleObject == null) {
-                    getLogger().warning(
-                            "Wasn't able to check JSON key! The Item-NBT-API may not work with Json serialization/deserialization!");
-                    jsonCompatible = false;
-                } else if (!(STRING_TEST_VALUE).equals(simpleObject.getTestString())
-                        || simpleObject.getTestInteger() != INT_TEST_VALUE
-                        || simpleObject.getTestDouble() != DOUBLE_TEST_VALUE
-                        || !simpleObject.isTestBoolean() == BOOLEAN_TEST_VALUE) {
-                    getLogger().warning(
-                            "One key does not equal the original value in JSON! The Item-NBT-API may not work with Json serialization/deserialization!");
-                    jsonCompatible = false;
-                }
-            }
-        } catch (Exception ex) {
-            getLogger().log(Level.SEVERE, null, ex);
-            getLogger().warning(ex.getMessage());
-            jsonCompatible = false;
-        }
-    }
-
-    public boolean isCompatible() {
-        return compatible;
-    }
-
-    public static NBTItem getNBTItem(ItemStack item) {
-        return new NBTItem(item);
-    }
-
-    //region STATIC FINAL VARIABLES
-    private static final String STRING_TEST_KEY = "stringTest";
-    private static final String INT_TEST_KEY = "intTest";
-    private static final String DOUBLE_TEST_KEY = "doubleTest";
-    private static final String BOOLEAN_TEST_KEY = "booleanTest";
-    private static final String JSON_TEST_KEY = "jsonTest";
-    private static final String COMP_TEST_KEY = "componentTest";
-    private static final String SHORT_TEST_KEY = "shortTest";
-    private static final String BYTE_TEST_KEY = "byteTest";
-    private static final String FLOAT_TEST_KEY = "floatTest";
-    private static final String LONG_TEST_KEY = "longTest";
-    private static final String INTARRAY_TEST_KEY = "intarrayTest";
-    private static final String BYTEARRAY_TEST_KEY = "bytearrayTest";
-
-    private static final String STRING_TEST_VALUE = "TestString";
-    private static final int INT_TEST_VALUE = 42;
-    private static final double DOUBLE_TEST_VALUE = 1.5d;
-    private static final boolean BOOLEAN_TEST_VALUE = true;
-    private static final short SHORT_TEST_VALUE = 64;
-    private static final byte BYTE_TEST_VALUE = 7;
-    private static final float FLOAT_TEST_VALUE = 13.37f;
-    private static final long LONG_TEST_VALUE = (long) Integer.MAX_VALUE + 42L;
-    private static final int[] INTARRAY_TEST_VALUE = new int[] { 1337, 42, 69 };
-    private static final byte[] BYTEARRAY_TEST_VALUE = new byte[] { 8, 7, 3, 2 };
-    //end region STATIC FINAL VARIABLES
-
-    public static class SimpleJsonTestObject {
-        private String testString = STRING_TEST_VALUE;
-        private int testInteger = INT_TEST_VALUE;
-        private double testDouble = DOUBLE_TEST_VALUE;
-        private boolean testBoolean = BOOLEAN_TEST_VALUE;
-
-        public SimpleJsonTestObject() {
-        }
-
-        public String getTestString() {
-            return testString;
-        }
-
-        public void setTestString(String testString) {
-            this.testString = testString;
-        }
-
-        public int getTestInteger() {
-            return testInteger;
-        }
-
-        public void setTestInteger(int testInteger) {
-            this.testInteger = testInteger;
-        }
-
-        public double getTestDouble() {
-            return testDouble;
-        }
-
-        public void setTestDouble(double testDouble) {
-            this.testDouble = testDouble;
-        }
-
-        public boolean isTestBoolean() {
-            return testBoolean;
-        }
-
-        public void setTestBoolean(boolean testBoolean) {
-            this.testBoolean = testBoolean;
-        }
-    }
-
-}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/NBTAPI.java

@@ -0,0 +1,155 @@
+package de.tr7zw.nbtapi.plugin;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+import de.tr7zw.nbtapi.plugin.tests.NBTFileTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.ForEachTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.GetterSetterTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.ListTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.MergeTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.RemovingKeys;
+import de.tr7zw.nbtapi.plugin.tests.compounds.SubCompoundsTest;
+import de.tr7zw.nbtapi.plugin.tests.compounds.TypeTest;
+import de.tr7zw.nbtapi.plugin.tests.entities.EntityCustomNbtTest;
+import de.tr7zw.nbtapi.plugin.tests.entities.EntityTest;
+import de.tr7zw.nbtapi.plugin.tests.items.EmptyItemTest;
+import de.tr7zw.nbtapi.plugin.tests.items.ItemConvertionTest;
+import de.tr7zw.nbtapi.plugin.tests.tiles.TilesCustomNBTTest;
+import de.tr7zw.nbtinjector.NBTInjector;
+
+public class NBTAPI extends JavaPlugin {
+
+	private boolean compatible = true;
+	private ArrayList<de.tr7zw.nbtapi.plugin.tests.Test> apiTests = new ArrayList<>();
+
+	private static NBTAPI instance;
+
+	public static NBTAPI getInstance() {
+		return instance;
+	}
+
+	@Override
+	public void onLoad() {
+		
+		//Disabled by default since 2.1. Enable it yourself by calling NBTInjector.inject(); during onLoad.
+		/*getLogger().info("Injecting custom NBT");
+		try {
+			NBTInjector.inject();
+			getLogger().info("Injected!");
+		} catch (Throwable ex) { // NOSONAR
+			getLogger().log(Level.SEVERE, "Error while Injecting custom Tile/Entity classes!", ex);
+			compatible = false;
+		}*/
+
+		// NBTCompounds
+		apiTests.add(new GetterSetterTest());
+		apiTests.add(new TypeTest());
+		apiTests.add(new RemovingKeys());
+		apiTests.add(new ListTest());
+		apiTests.add(new SubCompoundsTest());
+		apiTests.add(new MergeTest());
+		apiTests.add(new ForEachTest());
+
+		// Items
+		apiTests.add(new ItemConvertionTest());
+		apiTests.add(new EmptyItemTest());
+
+		// Entity
+		apiTests.add(new EntityTest());
+		apiTests.add(new EntityCustomNbtTest());
+
+		// Tiles
+		apiTests.add(new TilesCustomNBTTest());
+
+		// Files
+		apiTests.add(new NBTFileTest());
+
+	}
+
+	@Override
+	public void onEnable() {
+		instance = this; // NOSONAR
+		// new MetricsLite(this); The metrics moved into the API
+
+		getLogger().info("Adding listeners...");
+		Bukkit.getPluginManager().registerEvents(new ReloadListener(), this);
+		getLogger().info("Checking bindings...");
+		MinecraftVersion.getVersion();
+		getLogger().info("Gson:");
+		MinecraftVersion.hasGsonSupport();
+		getLogger().info("Classes:");
+		boolean classUnlinked = false;
+		for (ClassWrapper c : ClassWrapper.values()) {
+			if (c.isEnabled() && c.getClazz() == null) {
+				getLogger().warning(c.name() + " did not find it's class!");
+				compatible = false;
+				classUnlinked = true;
+			}
+		}
+		if (!classUnlinked)
+			getLogger().info("All Classes where able to link!");
+
+		getLogger().info("Methods:");
+		boolean methodUnlinked = false;
+		for (ReflectionMethod method : ReflectionMethod.values()) {
+			if (method.isCompatible() && !method.isLoaded()) {
+				getLogger().warning(method.name() + " did not find the method!");
+				compatible = false;
+				methodUnlinked = true;
+			}
+		}
+		if (!methodUnlinked)
+			getLogger().info("All Methods where able to link!");
+		getLogger().info("Running NBT reflection test...");
+
+		Map<de.tr7zw.nbtapi.plugin.tests.Test, Exception> results = new HashMap<>();
+		for (de.tr7zw.nbtapi.plugin.tests.Test test : apiTests) {
+			try {
+				test.test();
+				results.put(test, null);
+			} catch (Exception ex) {
+				results.put(test, ex);
+				getLogger().log(Level.WARNING, "Error during '" + test.getClass().getSimpleName() + "' test!", ex);
+			} catch (Throwable th) { // NOSONAR
+				getLogger().log(Level.SEVERE, "Servere error during '" + test.getClass().getSimpleName() + "' test!");
+				getLogger().warning(
+						"WARNING! This version of Item-NBT-API seems to be broken with your Spigot version! Canceled the other tests!");
+				throw th;
+			}
+		}
+
+		for (Entry<de.tr7zw.nbtapi.plugin.tests.Test, Exception> entry : results.entrySet()) {
+			if (entry.getValue() != null)
+				compatible = false;
+			getLogger().info(entry.getKey().getClass().getSimpleName() + ": "
+					+ (entry.getValue() == null ? "Ok" : entry.getValue().getMessage()));
+		}
+
+		String checkMessage = "Plugins that don't check properly may throw Exeptions, crash or have unexpected behaviors!";
+		if (compatible) {
+			getLogger().info("Success! This version of NBT-API is compatible with your server.");
+		} else {
+			getLogger().warning(
+					"WARNING! This version of NBT-API seems to be broken with your Spigot version! " + checkMessage);
+		}
+
+	}
+
+	/**
+	 * @return True if all selfchecks succeeded 
+	 */
+	public boolean isCompatible() {
+		return compatible;
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/ReloadListener.java

@@ -0,0 +1,42 @@
+package de.tr7zw.nbtapi.plugin;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+import de.tr7zw.nbtinjector.NBTInjector;
+
+/**
+ * This listener class tries to prevent people from reloading while the NBTInjector is enabled.
+ * 
+ * @author tr7zw
+ *
+ */
+public class ReloadListener implements Listener{
+
+	/**
+	 * Console handler
+	 * 
+	 * @param event
+	 */
+	@EventHandler
+	public void onCommand(org.bukkit.event.server.ServerCommandEvent event) {
+		if(event.getCommand().toLowerCase().startsWith("reload") && NBTInjector.isInjected()) {
+			event.setCancelled(true);
+			event.getSender().sendMessage("[NBTAPI] The NBTInjector is currently enabled. Reloading will turn the server into an unstable state and data-loss may accure. Please do a clean restart. Canceled reload!");
+		}
+	}
+	
+	/**
+	 * Player handler
+	 * 
+	 * @param event
+	 */
+	@EventHandler
+	public void onCommand(org.bukkit.event.player.PlayerCommandPreprocessEvent event) {
+		if(event.getMessage().toLowerCase().startsWith("/reload") && NBTInjector.isInjected()) {
+			event.setCancelled(true);
+			event.getPlayer().sendMessage("[NBTAPI] The NBTInjector is currently enabled. Reloading will turn the server into an unstable state and data-loss may accure. Please do a clean restart. Canceled reload!");
+		}
+	}
+	
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/NBTFileTest.java

@@ -0,0 +1,46 @@
+package de.tr7zw.nbtapi.plugin.tests;
+
+import java.io.File;
+import java.nio.file.Files;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTFile;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.NBTAPI;
+
+public class NBTFileTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		NBTAPI.getInstance().getDataFolder().mkdirs();
+		NBTFile file = new NBTFile(new File(NBTAPI.getInstance().getDataFolder(), "test.nbt"));
+		file.addCompound("testcomp").setString("test1", "ok");
+		NBTCompound comp = file.getCompound("testcomp");
+		comp.setString("test2", "ok");
+		file.setLong("time", System.currentTimeMillis());
+		file.setString("test", "test");
+		NBTCompound chunks = file.addCompound("chunks");
+		NBTCompound chunk = chunks.addCompound("somechunk");
+		NBTCompound block = chunk.addCompound("someblock");
+		block.setString("type", "wool");
+		file.save();
+		
+		if(!"wool".equals(block.getString("type"))) {
+			throw new NbtApiException("SubCompounds did not work!");
+		}
+
+		NBTFile fileLoaded = new NBTFile(new File(NBTAPI.getInstance().getDataFolder(), "test.nbt"));
+		if (!fileLoaded.getString("test").equals("test")) {
+			throw new NbtApiException("Wasn't able to load NBT File with the correct content!");
+		}
+		Files.deleteIfExists(fileLoaded.getFile().toPath());
+		// String
+		String str = fileLoaded.asNBTString();
+		NBTContainer rebuild = new NBTContainer(str);
+		if (!str.equals(rebuild.asNBTString())) {
+			throw new NbtApiException("Wasn't able to parse NBT from a String!");
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/Test.java

@@ -0,0 +1,7 @@
+package de.tr7zw.nbtapi.plugin.tests;
+
+public interface Test {
+
+	public void test() throws Exception; // NOSONAR
+	
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/ForEachTest.java

@@ -0,0 +1,50 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import java.util.ListIterator;
+
+import de.tr7zw.changeme.nbtapi.NBTCompoundList;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTListCompound;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+/**
+ * Test requested by TAU on Discord
+ *
+ */
+public class ForEachTest implements Test {
+
+	@SuppressWarnings("unused")
+	@Override
+	public void test() throws Exception {
+		NBTContainer comp = new NBTContainer();
+        NBTCompoundList compList = comp.getCompoundList("testkey");
+        if (compList != null) {
+        	compList.addCompound().setInteger("id", 1);
+        	compList.addCompound().setInteger("id", 2);
+        	compList.addCompound().setInteger("id", 3);
+            int count = 0;
+            for (NBTListCompound listComp : compList) {
+            	count++;  
+            }
+            if(count != compList.size())
+            	throw new NbtApiException("For loop did not get all Entries!");
+            count = 0;
+            ListIterator<NBTListCompound> lit = compList.listIterator();
+            while(lit.hasNext()){
+            	lit.next();
+            	count++;
+            }
+            if(count != compList.size())
+            	throw new NbtApiException("ListIterator did not get all Entries!");
+            count = 0;
+            while(lit.hasPrevious()){
+            	lit.previous();
+            	count++;
+            }
+            if(count != compList.size())
+            	throw new NbtApiException("ListIterator previous did not get all Entries!");
+        }
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/GetterSetterTest.java

@@ -0,0 +1,61 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class GetterSetterTest implements Test {
+
+	private static final String STRING_TEST_KEY = "stringTest";
+	private static final String INT_TEST_KEY = "intTest";
+	private static final String DOUBLE_TEST_KEY = "doubleTest";
+	private static final String BOOLEAN_TEST_KEY = "booleanTest";
+	private static final String SHORT_TEST_KEY = "shortTest";
+	private static final String BYTE_TEST_KEY = "byteTest";
+	private static final String FLOAT_TEST_KEY = "floatTest";
+	private static final String LONG_TEST_KEY = "longTest";
+	private static final String INTARRAY_TEST_KEY = "intarrayTest";
+	private static final String BYTEARRAY_TEST_KEY = "bytearrayTest";
+
+	private static final String STRING_TEST_VALUE = "TestString";
+	private static final int INT_TEST_VALUE = 42;
+	private static final double DOUBLE_TEST_VALUE = 1.5d;
+	private static final boolean BOOLEAN_TEST_VALUE = true;
+	private static final short SHORT_TEST_VALUE = 64;
+	private static final byte BYTE_TEST_VALUE = 7;
+	private static final float FLOAT_TEST_VALUE = 13.37f;
+	private static final long LONG_TEST_VALUE = (long) Integer.MAX_VALUE + 42L;
+	private static final int[] INTARRAY_TEST_VALUE = new int[] { 1337, 42, 69 };
+	private static final byte[] BYTEARRAY_TEST_VALUE = new byte[] { 8, 7, 3, 2 };
+
+	@Override
+	public void test() throws Exception {
+		NBTContainer comp = new NBTContainer();
+
+		comp.setString(STRING_TEST_KEY, STRING_TEST_VALUE);
+		comp.setInteger(INT_TEST_KEY, INT_TEST_VALUE);
+		comp.setDouble(DOUBLE_TEST_KEY, DOUBLE_TEST_VALUE);
+		comp.setBoolean(BOOLEAN_TEST_KEY, BOOLEAN_TEST_VALUE);
+		comp.setByte(BYTE_TEST_KEY, BYTE_TEST_VALUE);
+		comp.setShort(SHORT_TEST_KEY, SHORT_TEST_VALUE);
+		comp.setLong(LONG_TEST_KEY, LONG_TEST_VALUE);
+		comp.setFloat(FLOAT_TEST_KEY, FLOAT_TEST_VALUE);
+		comp.setIntArray(INTARRAY_TEST_KEY, INTARRAY_TEST_VALUE);
+		comp.setByteArray(BYTEARRAY_TEST_KEY, BYTEARRAY_TEST_VALUE);
+
+		if (!comp.hasKey(STRING_TEST_KEY)) {
+			throw new NbtApiException("Wasn't able to check a key! The Item-NBT-API may not work!");
+		}
+		if (!(STRING_TEST_VALUE).equals(comp.getString(STRING_TEST_KEY))
+				|| comp.getInteger(INT_TEST_KEY) != INT_TEST_VALUE
+				|| comp.getDouble(DOUBLE_TEST_KEY) != DOUBLE_TEST_VALUE
+				|| comp.getByte(BYTE_TEST_KEY) != BYTE_TEST_VALUE || comp.getShort(SHORT_TEST_KEY) != SHORT_TEST_VALUE
+				|| comp.getFloat(FLOAT_TEST_KEY) != FLOAT_TEST_VALUE || comp.getLong(LONG_TEST_KEY) != LONG_TEST_VALUE
+				|| comp.getIntArray(INTARRAY_TEST_KEY).length != (INTARRAY_TEST_VALUE).length
+				|| comp.getByteArray(BYTEARRAY_TEST_KEY).length != (BYTEARRAY_TEST_VALUE).length
+				|| !comp.getBoolean(BOOLEAN_TEST_KEY).equals(BOOLEAN_TEST_VALUE)) {
+			throw new NbtApiException("One key does not equal the original value! The Item-NBT-API may not work!");
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/GsonTest.java

@@ -0,0 +1,94 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import de.tr7zw.changeme.nbtapi.NBTItem;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class GsonTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		if (!MinecraftVersion.hasGsonSupport()) {
+			return;
+		}
+		try {
+			ItemStack item = new ItemStack(Material.STONE, 1);
+			NBTItem nbtItem = new NBTItem(item);
+
+			nbtItem.setObject(JSON_TEST_KEY, new SimpleJsonTestObject());
+
+			if (!nbtItem.hasKey(JSON_TEST_KEY)) {
+				throw new NbtApiException(
+						"Wasn't able to find JSON key! The Item-NBT-API may not work with Json serialization/deserialization!");
+			} else {
+				SimpleJsonTestObject simpleObject = nbtItem.getObject(JSON_TEST_KEY, SimpleJsonTestObject.class);
+				if (simpleObject == null) {
+					throw new NbtApiException(
+							"Wasn't able to check JSON key! The Item-NBT-API may not work with Json serialization/deserialization!");
+				} else if (!(STRING_TEST_VALUE).equals(simpleObject.getTestString())
+						|| simpleObject.getTestInteger() != INT_TEST_VALUE
+						|| simpleObject.getTestDouble() != DOUBLE_TEST_VALUE
+						|| !simpleObject.isTestBoolean() == BOOLEAN_TEST_VALUE) {
+					throw new NbtApiException(
+							"One key does not equal the original value in JSON! The Item-NBT-API may not work with Json serialization/deserialization!");
+				}
+			}
+		} catch (Exception ex) {
+			throw new NbtApiException("Exception during Gson check!", ex);
+		}
+	}
+
+	// region STATIC FINAL VARIABLES
+	private static final String JSON_TEST_KEY = "jsonTest";
+
+	private static final String STRING_TEST_VALUE = "TestString";
+	private static final int INT_TEST_VALUE = 42;
+	private static final double DOUBLE_TEST_VALUE = 1.5d;
+	private static final boolean BOOLEAN_TEST_VALUE = true;
+
+	// end region STATIC FINAL VARIABLES
+
+	public static class SimpleJsonTestObject {
+		private String testString = STRING_TEST_VALUE;
+		private int testInteger = INT_TEST_VALUE;
+		private double testDouble = DOUBLE_TEST_VALUE;
+		private boolean testBoolean = BOOLEAN_TEST_VALUE;
+
+		public String getTestString() {
+			return testString;
+		}
+
+		public void setTestString(String testString) {
+			this.testString = testString;
+		}
+
+		public int getTestInteger() {
+			return testInteger;
+		}
+
+		public void setTestInteger(int testInteger) {
+			this.testInteger = testInteger;
+		}
+
+		public double getTestDouble() {
+			return testDouble;
+		}
+
+		public void setTestDouble(double testDouble) {
+			this.testDouble = testDouble;
+		}
+
+		public boolean isTestBoolean() {
+			return testBoolean;
+		}
+
+		public void setTestBoolean(boolean testBoolean) {
+			this.testBoolean = testBoolean;
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/ListTest.java

@@ -0,0 +1,80 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import java.util.Arrays;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTCompoundList;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTList;
+import de.tr7zw.changeme.nbtapi.NBTListCompound;
+import de.tr7zw.changeme.nbtapi.NBTType;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class ListTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		NBTContainer comp = new NBTContainer();
+
+		// Strings
+		NBTList<String> list = comp.getStringList("testlist");
+		list.add("test1");
+		list.add("test2");
+		list.add("test3");
+		list.add("test4");
+		list.set(2, "test42");
+		list.remove(1);
+		if (!list.get(1).equals("test42") || list.size() != 3) {
+			throw new NbtApiException("The String-list did not match what it should have looked like.");
+		}
+
+		// Compound
+		NBTCompoundList taglist = comp.getCompoundList("complist");
+		NBTListCompound lcomp = taglist.addCompound();
+		lcomp.setDouble("double1", 0.3333);
+		lcomp.setInteger("int1", 42);
+		lcomp.setString("test1", "test1");
+		lcomp.setString("test2", "test2");
+		lcomp.removeKey("test1");
+		NBTCompound subsubcomp = lcomp.addCompound("listsubkey");
+		subsubcomp.setString("deep", "String");
+		subsubcomp.getCompoundList("deeplist").addCompound().setString("test", "test");
+		subsubcomp.getCompoundList("clonelist").addCompound(comp);
+
+		taglist = null;
+		lcomp = null;
+		subsubcomp = null;
+
+		taglist = comp.getCompoundList("complist");
+		if (taglist.size() == 1) {
+			lcomp = taglist.get(0);
+			if (lcomp.getKeys().size() != 4) {
+				throw new NbtApiException("Wrong key amount in Taglist (" + lcomp.getKeys().size() + ")!");
+			} else if (!(lcomp.getDouble("double1") == 0.3333 && lcomp.getInteger("int1") == 42
+					&& lcomp.getString("test2").equals("test2") && !lcomp.hasKey("test1"))) {
+				throw new NbtApiException("One key in the Taglist changed! The Item-NBT-API may not work!");
+			} else if(lcomp.getCompound("listsubkey") == null || !"String".equals(lcomp.getCompound("listsubkey").getString("deep"))){
+				throw new NbtApiException("The Compound nested in the listcompound was not correct! The Item-NBT-API may not work!");
+			} else if(lcomp.getCompound("listsubkey").getType("deep") != NBTType.NBTTagString){
+				throw new NbtApiException("The nested key's type wasn't correct! The Item-NBT-API may not work!");
+			} else if(lcomp.getCompound("listsubkey").getType("deeplist") != NBTType.NBTTagList){
+				throw new NbtApiException("The nested list's type wasn't correct '" + lcomp.getCompound("listsubkey").getType("deeplist") + "'! The Item-NBT-API may not work!");
+			}
+		} else {
+			throw new NbtApiException("Taglist is empty! The Item-NBT-API may not work!");
+		}
+
+		// Integer
+		NBTList<Integer> intlist = comp.getIntegerList("inttest");
+		intlist.add(42);
+		intlist.add(69);
+		if (intlist.size() == 2 && intlist.get(0) == 42 && intlist.get(1) == 69) {
+			// ok
+		} else {
+			throw new NbtApiException("IntList is not correct! " + Arrays.toString(intlist.toArray(new Integer[0])));
+		}
+
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/MergeTest.java

@@ -0,0 +1,22 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class MergeTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		NBTContainer test1 = new NBTContainer();
+		test1.setString("test1", "test");
+		NBTContainer test2 = new NBTContainer();
+		test2.setString("test2", "test");
+		test2.addCompound("test").setLong("time", System.currentTimeMillis());
+		test1.mergeCompound(test2);
+		if (!test1.getString("test1").equals(test1.getString("test2"))) {
+			throw new NbtApiException("Wasn't able to merge Compounds!");
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/RemovingKeys.java

@@ -0,0 +1,67 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class RemovingKeys implements Test {
+
+	private static final String STRING_TEST_KEY = "stringTest";
+	private static final String INT_TEST_KEY = "intTest";
+	private static final String DOUBLE_TEST_KEY = "doubleTest";
+	private static final String BOOLEAN_TEST_KEY = "booleanTest";
+	private static final String SHORT_TEST_KEY = "shortTest";
+	private static final String BYTE_TEST_KEY = "byteTest";
+	private static final String FLOAT_TEST_KEY = "floatTest";
+	private static final String LONG_TEST_KEY = "longTest";
+	private static final String INTARRAY_TEST_KEY = "intarrayTest";
+	private static final String BYTEARRAY_TEST_KEY = "bytearrayTest";
+
+	private static final String STRING_TEST_VALUE = "TestString";
+	private static final int INT_TEST_VALUE = 42;
+	private static final double DOUBLE_TEST_VALUE = 1.5d;
+	private static final boolean BOOLEAN_TEST_VALUE = true;
+	private static final short SHORT_TEST_VALUE = 64;
+	private static final byte BYTE_TEST_VALUE = 7;
+	private static final float FLOAT_TEST_VALUE = 13.37f;
+	private static final long LONG_TEST_VALUE = (long) Integer.MAX_VALUE + 42L;
+	private static final int[] INTARRAY_TEST_VALUE = new int[] { 1337, 42, 69 };
+	private static final byte[] BYTEARRAY_TEST_VALUE = new byte[] { 8, 7, 3, 2 };
+
+	@Override
+	public void test() throws Exception {
+		NBTContainer comp = new NBTContainer();
+
+		comp.setString(STRING_TEST_KEY, STRING_TEST_VALUE);
+		comp.setInteger(INT_TEST_KEY, INT_TEST_VALUE);
+		comp.setDouble(DOUBLE_TEST_KEY, DOUBLE_TEST_VALUE);
+		comp.setBoolean(BOOLEAN_TEST_KEY, BOOLEAN_TEST_VALUE);
+		comp.setByte(BYTE_TEST_KEY, BYTE_TEST_VALUE);
+		comp.setShort(SHORT_TEST_KEY, SHORT_TEST_VALUE);
+		comp.setLong(LONG_TEST_KEY, LONG_TEST_VALUE);
+		comp.setFloat(FLOAT_TEST_KEY, FLOAT_TEST_VALUE);
+		comp.setIntArray(INTARRAY_TEST_KEY, INTARRAY_TEST_VALUE);
+		comp.setByteArray(BYTEARRAY_TEST_KEY, BYTEARRAY_TEST_VALUE);
+
+		if (comp.getKeys().size() != 10) {
+			throw new NbtApiException("Key amount did not match after setting keys!");
+		}
+
+		comp.setString(STRING_TEST_KEY, null);
+		comp.setInteger(INT_TEST_KEY, null);
+		comp.setDouble(DOUBLE_TEST_KEY, null);
+		comp.setBoolean(BOOLEAN_TEST_KEY, null);
+		comp.setByte(BYTE_TEST_KEY, null);
+		comp.setShort(SHORT_TEST_KEY, null);
+		comp.setLong(LONG_TEST_KEY, null);
+		comp.setFloat(FLOAT_TEST_KEY, null);
+		comp.setIntArray(INTARRAY_TEST_KEY, null);
+		comp.setByteArray(BYTEARRAY_TEST_KEY, null);
+
+		if (comp.getKeys().size() != 0) {
+			throw new NbtApiException("Keys where not removed using the setter with null!");
+		}
+
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/SubCompoundsTest.java

@@ -0,0 +1,50 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class SubCompoundsTest implements Test {
+
+	private static final String COMP_TEST_KEY = "componentTest";
+	private static final String STRING_TEST_KEY = "stringTest";
+	private static final String INT_TEST_KEY = "intTest";
+	private static final String DOUBLE_TEST_KEY = "doubleTest";
+	private static final String BOOLEAN_TEST_KEY = "booleanTest";
+	private static final String STRING_TEST_VALUE = "TestString";
+	private static final int INT_TEST_VALUE = 42;
+	private static final double DOUBLE_TEST_VALUE = 1.5d;
+	private static final boolean BOOLEAN_TEST_VALUE = true;
+
+	@Override
+	public void test() throws Exception {
+		NBTContainer cont = new NBTContainer();
+
+		NBTCompound comp = cont.addCompound(COMP_TEST_KEY);
+		comp.setString(STRING_TEST_KEY, STRING_TEST_VALUE + "2");
+		comp.setInteger(INT_TEST_KEY, INT_TEST_VALUE * 2);
+		comp.setDouble(DOUBLE_TEST_KEY, DOUBLE_TEST_VALUE * 2);
+
+		if (cont.getCompound("invalide") != null) {
+			throw new NbtApiException("An invalide compound did not return null!");
+		}
+
+		comp = null;
+
+		comp = cont.getCompound(COMP_TEST_KEY);
+		if (comp == null) {
+			throw new NbtApiException("Wasn't able to get the NBTCompound!");
+		}
+		if (!comp.hasKey(STRING_TEST_KEY)) {
+			throw new NbtApiException("Wasn't able to check a compound key!");
+		}
+		if (!(STRING_TEST_VALUE + "2").equals(comp.getString(STRING_TEST_KEY))
+				|| comp.getInteger(INT_TEST_KEY) != INT_TEST_VALUE * 2
+				|| comp.getDouble(DOUBLE_TEST_KEY) != DOUBLE_TEST_VALUE * 2
+				|| comp.getBoolean(BOOLEAN_TEST_KEY) == BOOLEAN_TEST_VALUE) {
+			throw new NbtApiException("One key does not equal the original compound value!");
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/compounds/TypeTest.java

@@ -0,0 +1,22 @@
+package de.tr7zw.nbtapi.plugin.tests.compounds;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTType;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class TypeTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		NBTCompound comp = new NBTContainer();
+		comp.setString("s", "test");
+		comp.setInteger("i", 42);
+		comp.addCompound("c");
+		if (comp.getType("s") != NBTType.NBTTagString || comp.getType("i") != NBTType.NBTTagInt
+				|| comp.getType("c") != NBTType.NBTTagCompound)
+			throw new NbtApiException("One parsed type did not match what it should have been!");
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/entities/EntityCustomNbtTest.java

@@ -0,0 +1,41 @@
+package de.tr7zw.nbtapi.plugin.tests.entities;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Monster;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTEntity;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+import de.tr7zw.nbtinjector.NBTInjector;
+
+public class EntityCustomNbtTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		if(!NBTInjector.isInjected())return;
+		if (!Bukkit.getWorlds().isEmpty()) {
+			World world = Bukkit.getWorlds().get(0);
+			try {
+				if (!world.getEntitiesByClasses(Animals.class, Monster.class).isEmpty()) {
+					Entity ent = world.getEntitiesByClasses(Animals.class, Monster.class).iterator().next();
+					ent = NBTInjector.patchEntity(ent);
+					NBTCompound comp = NBTInjector.getNbtData(ent);
+					comp.setString("Hello", "World");
+					NBTEntity nbtent = new NBTEntity(ent);
+					if (!nbtent.asNBTString().contains("__extraData:{Hello:\"World\"}")) {
+						throw new NbtApiException("Custom Data did not save to the Entity!");
+					}
+					comp.removeKey("Hello");
+
+				}
+			} catch (Exception ex) {
+				throw new NbtApiException("Wasn't able to use NBTEntities!", ex);
+			}
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/entities/EntityTest.java

@@ -0,0 +1,49 @@
+package de.tr7zw.nbtapi.plugin.tests.entities;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Monster;
+
+import de.tr7zw.changeme.nbtapi.NBTEntity;
+import de.tr7zw.changeme.nbtapi.NBTTileEntity;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class EntityTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		if (!Bukkit.getWorlds().isEmpty()) {
+			World world = Bukkit.getWorlds().get(0);
+			try {
+				if (!world.getEntitiesByClasses(Animals.class, Monster.class).isEmpty()) {
+					NBTEntity nbte = new NBTEntity(
+							world.getEntitiesByClasses(Animals.class, Monster.class).iterator().next());
+					nbte.setString("INVALIDEKEY", "test");
+				}
+			} catch (Exception ex) {
+				throw new NbtApiException("Wasn't able to use NBTEntities!");
+			}
+			try {
+				Block block = world.getBlockAt(world.getSpawnLocation().getBlockX(), 255,
+						world.getSpawnLocation().getBlockZ());
+				if (block.getType() == Material.AIR) {
+					block.setType(Material.CHEST);
+					NBTTileEntity tile = new NBTTileEntity(block.getState());
+					tile.setString("Lock", "test");
+					if (!tile.asNBTString().contains("Lock:\"test\"")) {
+						block.setType(Material.AIR);
+						throw new NbtApiException("The Lock wasn't successfully set.");
+					}
+					block.setType(Material.AIR);
+				}
+			} catch (Exception ex) {
+				throw new NbtApiException("Wasn't able to use NBTTiles!", ex);
+			}
+		}
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/items/EmptyItemTest.java

@@ -0,0 +1,20 @@
+package de.tr7zw.nbtapi.plugin.tests.items;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import de.tr7zw.changeme.nbtapi.NBTItem;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class EmptyItemTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		ItemStack item = new ItemStack(Material.STONE);
+		NBTItem nbti = new NBTItem(item);
+		if (nbti.getBoolean("test") == null || nbti.getString("test") == null)
+			throw new NbtApiException("Getters return null instead of the default value");
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/items/ItemConvertionTest.java

@@ -0,0 +1,35 @@
+package de.tr7zw.nbtapi.plugin.tests.items;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import com.google.common.collect.Lists;
+
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTItem;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+
+public class ItemConvertionTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		ItemStack item = new ItemStack(Material.STONE, 1);
+		ItemMeta meta = item.getItemMeta();
+		meta.setLore(Lists.newArrayList("Firest Line", "Second Line"));
+		item.setItemMeta(meta);
+		String nbt = NBTItem.convertItemtoNBT(item).asNBTString();
+		if (!nbt.contains("Firest Line") || !nbt.contains("Second Line"))
+			throw new NbtApiException("The Item nbt '" + nbt + "' didn't contain the lore");
+		ItemStack rebuild = NBTItem.convertNBTtoItem(new NBTContainer(nbt));
+		if (!item.isSimilar(rebuild))
+			throw new NbtApiException("Rebuilt item did not match the original!");
+		
+		NBTContainer cont = new NBTContainer();
+		cont.setItemStack("testItem", item);
+		if(!cont.getItemStack("testItem").isSimilar(item))
+			throw new NbtApiException("Rebuilt item did not match the original!");
+	}
+
+}

item-nbt-plugin/src/main/java/de/tr7zw/nbtapi/plugin/tests/tiles/TilesCustomNBTTest.java

@@ -0,0 +1,40 @@
+package de.tr7zw.nbtapi.plugin.tests.tiles;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTTileEntity;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.nbtapi.plugin.tests.Test;
+import de.tr7zw.nbtinjector.NBTInjector;
+
+public class TilesCustomNBTTest implements Test {
+
+	@Override
+	public void test() throws Exception {
+		if(!NBTInjector.isInjected())return;
+		if (!Bukkit.getWorlds().isEmpty()) {
+			World world = Bukkit.getWorlds().get(0);
+			try {
+				Block block = world.getBlockAt(world.getSpawnLocation().getBlockX(), 255,
+						world.getSpawnLocation().getBlockZ());
+				if (block.getType() == Material.AIR) {
+					block.setType(Material.CHEST);
+					NBTCompound comp = NBTInjector.getNbtData(block.getState());
+					comp.setString("Foo", "Bar");
+					if (!new NBTTileEntity(block.getState()).asNBTString().contains("__extraData:{Foo:\"Bar\"}")) {
+						block.setType(Material.AIR);
+						throw new NbtApiException("Custom Data did not save to the Tile!");
+					}
+					block.setType(Material.AIR);
+				}
+			} catch (Exception ex) {
+				throw new NbtApiException("Wasn't able to use NBTTiles!", ex);
+			}
+		}
+	}
+
+}

item-nbt-plugin/src/main/resources/plugin.yml

@@ -1,4 +1,5 @@
-main: de.tr7zw.itemnbtapi.ItemNBTAPI
-name: ItemNBTAPI
+main: de.tr7zw.nbtapi.plugin.NBTAPI
+name: NBTAPI
 version: ${project.version}
 author: tr7zw
+loadbefore: [ItemNBTAPI]

nbt-injector/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 tr7zw
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

nbt-injector/pom.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>de.tr7zw</groupId>
+    <artifactId>item-nbt-parent</artifactId>
+    <version>2.2.0</version>
+  </parent>
+  <artifactId>nbt-injector</artifactId>
+  <packaging>jar</packaging>
+  <dependencies>
+    <dependency>
+      <groupId>de.tr7zw</groupId>
+      <artifactId>item-nbt-api</artifactId>
+      <version>2.2.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.javassist</groupId>
+      <artifactId>javassist</artifactId>
+      <version>3.26.0-GA</version>
+      <scope>compile</scope>
+    </dependency>
+  </dependencies>
+  <build>
+    <defaultGoal>clean install javadoc:javadoc</defaultGoal>
+  </build>
+</project>

nbt-injector/src/main/java/de/tr7zw/nbtinjector/ClassGenerator.java

@@ -0,0 +1,193 @@
+package de.tr7zw.nbtinjector;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.CtNewConstructor;
+import javassist.LoaderClassPath;
+import javassist.NotFoundException;
+
+/**
+ * This class uses Javassist to create wrapped Entity/Tile classes during the
+ * runtime
+ * 
+ * @author tr7zw
+ *
+ */
+public class ClassGenerator {
+
+	/**
+	 * Hidden Constructor
+	 */
+	private ClassGenerator() {
+
+	}
+
+	private static final String GENERATOR_PACKAGE = "de.tr7zw.nbtinjector.generated";
+
+	/**
+	 * Wrappes a given class with the INBTWrapper interface
+	 * 
+	 * @param classPool     The Javassist classpool
+	 * @param originalClass The NMS Tile/Entity class
+	 * @param writeMethod   String of the saving method
+	 * @param readMethod    String of the loading method
+	 * @param extraDataKey  Key used to save the custom nbt
+	 * @return Class reference to the generated class
+	 * @throws NotFoundException
+	 * @throws CannotCompileException
+	 * @throws IOException
+	 */
+	protected static Class<?> wrapNbtClass(ClassPool classPool, Class<?> originalClass, String writeMethod,
+			String readMethod, String extraDataKey) throws NotFoundException, CannotCompileException, IOException {
+		classPool.insertClassPath(new LoaderClassPath(ClassGenerator.class.getClassLoader()));
+
+		CtClass generated = classPool.makeClass("de.tr7zw.nbtinjector.generated." + originalClass.getSimpleName());
+
+		CtClass wrapperInterface = classPool.get(INBTWrapper.class.getName());
+		generated.setInterfaces(new CtClass[] { wrapperInterface });
+		generated.setSuperclass(classPool.get(originalClass.getName()));
+
+		classPool.importPackage("net.minecraft.server." + MinecraftVersion.getVersion().name().replace("MC", "v"));
+		classPool.importPackage(NBTCompound.class.getPackage().getName());
+		classPool.importPackage(GENERATOR_PACKAGE);
+
+		generated.addField(CtField.make("public NBTCompound $extraCompound = new NBTContainer();", generated));
+		generated.addMethod(CtMethod
+				.make("public NBTCompound getNbtData() {\n" + "  return this.$extraCompound;\n" + "}", generated));
+		generated.addMethod(CtMethod.make("public NBTTagCompound readExtraCompound(NBTTagCompound root) {\n"
+				+ "  NBTTagCompound compound = root.getCompound(\"" + extraDataKey + "\");\n"
+				+ "  this.$extraCompound = new NBTContainer(compound);\n"
+				// + " System.out.println(\"Read: \" + root);\n"
+				+ "  return root;" + "}", generated));
+		generated.addMethod(CtMethod.make("public NBTTagCompound writeExtraCompound(NBTTagCompound root) {\n"
+				+ "  NBTBase compound = (NBTBase) this.$extraCompound.getCompound();\n"
+				+ "  NBTTagCompound newRoot = new NBTTagCompound();\n" + "  newRoot.set(\"" + extraDataKey
+				+ "\", compound);\n" + "  root.a(newRoot);\n" + "  return root;"// Merge
+				+ "}", generated));
+
+		generated.addMethod(CtMethod.make(writeMethod, generated));
+		generated.addMethod(CtMethod.make(readMethod, generated));
+
+		// Overwrite constructors
+		for (Constructor<?> constructor : originalClass.getConstructors()) {
+			String paramString = "";
+			String paramNameString = "";
+			int c = 0;
+			for (Class<?> clazz : constructor.getParameterTypes()) {
+				if (c != 0) {
+					paramString += ",";
+					paramNameString += ",";
+				}
+				paramString += clazz.getName() + " param" + c;
+				paramNameString += "param" + c;
+				c++;
+			}
+			generated.addConstructor(CtNewConstructor.make("public " + originalClass.getSimpleName() + "(" + paramString
+					+ ") {\n" + "  super(" + paramNameString + ");\n" + "}", generated));
+		}
+
+		generated.writeFile("nbtinjector_generated");
+		return generated.toClass(INBTWrapper.class.getClassLoader(), INBTWrapper.class.getProtectionDomain());
+	}
+
+	/**
+	 * Creates a class for the EntityTypes getter for a given entity
+	 * 
+	 * @param classPool   The Javassist classpool
+	 * @param targetClass The NMS Entity class
+	 * @return Class reference to the generated class
+	 * @throws NotFoundException
+	 * @throws CannotCompileException
+	 * @throws IOException
+	 */
+	protected static Class<?> createEntityTypeWrapper(ClassPool classPool, Class<?> targetClass)
+			throws NotFoundException, CannotCompileException, IOException {
+		classPool.insertClassPath(new LoaderClassPath(ClassGenerator.class.getClassLoader()));
+
+		CtClass generated = classPool.makeClass(GENERATOR_PACKAGE + ".entityCreator." + targetClass.getSimpleName());
+
+		CtClass wrapperInterface = classPool.get(ClassWrapper.NMS_ENTITYTYPES.getClazz().getName() + "$b");
+		generated.setInterfaces(new CtClass[] { wrapperInterface });
+
+		classPool.importPackage("net.minecraft.server." + MinecraftVersion.getVersion().name().replace("MC", "v"));
+		classPool.importPackage(GENERATOR_PACKAGE);
+
+		generated.addMethod(CtMethod.make("public Entity create(EntityTypes var1, World var2) {\n" + "  return new "
+				+ targetClass.getName() + "(var1, var2);\n" + "}", generated));
+
+		generated.writeFile("nbtinjector_generated");
+		return generated.toClass(INBTWrapper.class.getClassLoader(), INBTWrapper.class.getProtectionDomain());
+	}
+
+	/**
+	 * Wrappes a given Entity class with the INBTWrapper interface
+	 * 
+	 * @param classPool     The Javassist classpool
+	 * @param originalClass The NMS Entity class
+	 * @param extraDataKey
+	 * @return Class reference to the generated class
+	 * @throws NotFoundException
+	 * @throws CannotCompileException
+	 * @throws IOException
+	 */
+	protected static Class<?> wrapEntity(ClassPool classPool, Class<?> originalClass, String extraDataKey)
+			throws NotFoundException, CannotCompileException, IOException {
+		String writeReturn = MinecraftVersion.getVersion().getVersionId() > MinecraftVersion.MC1_10_R1.getVersionId()
+				? "NBTTagCompound"
+				: "void";
+		String writeName = ReflectionMethod.NMS_ENTITY_GET_NBT.getMethodName();
+		String readName = ReflectionMethod.NMS_ENTITY_SET_NBT.getMethodName();
+		if (MinecraftVersion.getVersion().getVersionId() < MinecraftVersion.MC1_11_R1.getVersionId()) {
+			writeName = "b";
+			readName = "f";
+		}
+
+		String writeMethod = "public " + writeReturn + " " + writeName + "(NBTTagCompound compound) {\n" + "  super."
+				+ writeName + "(compound);\n" + "  compound = writeExtraCompound(compound);\n"
+				// + " System.out.println(\"Saved-Data: \" + compound);"
+				+ "  " + (!"void".equals(writeReturn) ? "return compound;" : "") + "}";
+		String readMethod = "public void " + readName + "(NBTTagCompound compound) {\n" + "  super." + readName
+				+ "(compound);\n" + "  readExtraCompound(compound);\n" + "}";
+		return wrapNbtClass(classPool, originalClass, writeMethod, readMethod, extraDataKey);
+	}
+
+	/**
+	 * Wrappes a given Tile class with the INBTWrapper interface
+	 * 
+	 * @param classPool     The Javassist classpool
+	 * @param originalClass The NMS Tile class
+	 * @param extraDataKey
+	 * @return Class reference to the generated class
+	 * @throws NotFoundException
+	 * @throws CannotCompileException
+	 * @throws IOException
+	 */
+	protected static Class<?> wrapTileEntity(ClassPool classPool, Class<?> originalClass, String extraDataKey)
+			throws NotFoundException, CannotCompileException, IOException {
+		String writeReturn = MinecraftVersion.getVersion().getVersionId() > MinecraftVersion.MC1_9_R1.getVersionId()
+				? "NBTTagCompound"
+				: "void";
+		String writeName = ReflectionMethod.TILEENTITY_GET_NBT.getMethodName();
+		String readName = ReflectionMethod.TILEENTITY_SET_NBT.getMethodName();
+		String writeMethod = "public " + writeReturn + " " + writeName + "(NBTTagCompound compound) {\n"
+				+ "  compound = writeExtraCompound(compound);\n"
+				// + " System.out.println(\"Save: \" +compound);\n"
+				+ "  " + (!"void".equals(writeReturn) ? "return " : "") + "super." + writeName + "(compound);\n" + "}";
+		String readMethod = "public void " + readName + "(NBTTagCompound compound) {\n" + "  super." + readName
+				+ "(compound);\n" + "  readExtraCompound(compound);\n"
+				// + " System.out.println(\"Read: \" +compound);\n"
+				+ "}";
+		return wrapNbtClass(classPool, originalClass, writeMethod, readMethod, extraDataKey);
+	}
+
+}

nbt-injector/src/main/java/de/tr7zw/nbtinjector/INBTWrapper.java

@@ -0,0 +1,18 @@
+package de.tr7zw.nbtinjector;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+
+/**
+ * This interface gets placed on Tiles and Entities
+ * 
+ * @author tr7zw
+ *
+ */
+public interface INBTWrapper {
+
+	/**
+	 * @return The custom NBT compound inside this Object
+	 */
+	NBTCompound getNbtData();
+
+}

nbt-injector/src/main/java/de/tr7zw/nbtinjector/InternalInjectors.java

@@ -0,0 +1,288 @@
+package de.tr7zw.nbtinjector;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.ReflectionUtil;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+import de.tr7zw.nbtinjector.NBTInjector.Entity;
+import de.tr7zw.nbtinjector.NBTInjector.TileEntity;
+import javassist.ClassPool;
+import static de.tr7zw.changeme.nbtapi.utils.MinecraftVersion.logger;
+
+/**
+ * Contains the internal methods for different Minecraft Versions of injecting
+ * the Entities/Tiles
+ * 
+ * @author tr7zw
+ *
+ */
+@SuppressWarnings("unchecked")
+public class InternalInjectors {
+
+	private static final List<String> skippingEntities = Arrays.asList("minecraft:player", "minecraft:fishing_bobber",
+			"minecraft:lightning_bolt"); // These are broken/won't work, used by 1.14+
+	private static final Map<String, String> classMappings = new HashMap<>();
+
+	static {
+		classMappings.put("minecraft:wandering_trader", "VillagerTrader");
+		classMappings.put("minecraft:trader_llama", "LlamaTrader");
+		classMappings.put("minecraft:area_effect_cloud", "AreaEffectCloud");
+		classMappings.put("minecraft:donkey", "HorseDonkey");
+		classMappings.put("minecraft:ender_dragon", "EnderDragon");
+		classMappings.put("minecraft:skeleton_horse", "HorseSkeleton");
+		classMappings.put("minecraft:fireball", "LargeFireball");
+		classMappings.put("minecraft:mule", "HorseMule");
+		classMappings.put("minecraft:zombie_horse", "HorseZombie");
+		classMappings.put("minecraft:mooshroom", "MushroomCow");
+		classMappings.put("minecraft:wither_skeleton", "SkeletonWither");
+		classMappings.put("minecraft:snow_golem", "Snowman");
+		classMappings.put("minecraft:polar_bear", "PolarBear");
+		classMappings.put("minecraft:magma_cube", "MagmaCube");
+		classMappings.put("minecraft:armor_stand", "ArmorStand");
+		classMappings.put("minecraft:elder_guardian", "GuardianElder");
+		classMappings.put("minecraft:zombie_pigman", "PigZombie");
+		classMappings.put("minecraft:giant", "GiantZombie");
+		classMappings.put("minecraft:zombie_villager", "ZombieVillager");
+		classMappings.put("minecraft:husk", "ZombieHusk");
+		classMappings.put("minecraft:iron_golem", "IronGolem");
+		classMappings.put("minecraft:tropical_fish", "TropicalFish");
+		classMappings.put("minecraft:stray", "SkeletonStray");
+		classMappings.put("minecraft:illusioner", "IllagerIllusioner");
+		classMappings.put("minecraft:pufferfish", "PufferFish");
+		classMappings.put("minecraft:cave_spider", "CaveSpider");
+		classMappings.put("minecraft:item_frame", "ItemFrame");
+		classMappings.put("minecraft:leash_knot", "Leash");
+	}
+
+	/**
+	 * Hidden constructor
+	 */
+	private InternalInjectors() {
+
+	}
+
+	protected static void entity1v10Below(ClassPool classPool) throws ReflectiveOperationException {
+		for (Map.Entry<String, Class<?>> entry : new HashSet<>(Entity.getCMap().entrySet())) {
+			try {
+				if (INBTWrapper.class.isAssignableFrom(entry.getValue())) {
+					continue;
+				} // Already injected
+				int entityId = Entity.getFMap().get(entry.getValue());
+
+				Class<?> wrapped = ClassGenerator.wrapEntity(classPool, entry.getValue(), "__extraData");
+				Entity.getCMap().put(entry.getKey(), wrapped);
+				Entity.getDMap().put(wrapped, entry.getKey());
+
+				Entity.getEMap().put(entityId, wrapped);
+				Entity.getFMap().put(wrapped, entityId);
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + entry.getKey(), e);
+			}
+		}
+	}
+
+	protected static void entity1v12Below(ClassPool classPool) throws ReflectiveOperationException {
+		Object registry = Entity.getRegistry();
+		Map<Object, Object> inverse = new HashMap<>();
+		Set<?> it = new HashSet<>((Set<?>) ReflectionMethod.REGISTRY_KEYSET.run(registry));
+		Object registryId = Entity.getRegistryId(registry);
+		for (Object mckey : it) {
+			Class<?> entclass = (Class<?>) ReflectionMethod.REGISTRY_GET.run(registry, mckey);
+			inverse.put(entclass, mckey);
+			try {
+				if (INBTWrapper.class.isAssignableFrom(entclass)) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapEntity(classPool, entclass, "__extraData");
+				ReflectionMethod.REGISTRY_SET.run(registry, mckey, wrapped);
+				inverse.put(wrapped, mckey);
+				int id = (int) registryId.getClass().getMethod("getId", new Class[] {Object.class}).invoke(registryId, entclass);
+				registryId.getClass().getMethod("a", new Class[] {Object.class, int.class}).invoke(registryId, wrapped, id);
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + mckey, e);
+			}
+		}
+		Field inverseField = registry.getClass().getDeclaredField("b");
+		ReflectionUtil.setFinal(registry, inverseField, inverse);
+	}
+
+	protected static void entity1v13Below(ClassPool classPool) throws ReflectiveOperationException {
+		Object entityRegistry = ClassWrapper.NMS_IREGISTRY.getClazz().getField("ENTITY_TYPE").get(null);
+		Set<?> registryentries = new HashSet<>((Set<?>) ReflectionMethod.REGISTRYMATERIALS_KEYSET.run(entityRegistry));
+		for (Object mckey : registryentries) {
+			Object entityTypesObj = ReflectionMethod.REGISTRYMATERIALS_GET.run(entityRegistry, mckey);
+			Field supplierField = entityTypesObj.getClass().getDeclaredField("aT");
+			Field classField = entityTypesObj.getClass().getDeclaredField("aS");
+			classField.setAccessible(true);
+			supplierField.setAccessible(true);
+			Function<Object, Object> function = (Function<Object, Object>) supplierField.get(entityTypesObj);
+			Class<?> nmsclass = (Class<?>) classField.get(entityTypesObj);
+			try {
+				if (INBTWrapper.class.isAssignableFrom(nmsclass)) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapEntity(classPool, nmsclass, "__extraData");
+				ReflectionUtil.setFinal(entityTypesObj, classField, wrapped);
+				ReflectionUtil.setFinal(entityTypesObj, supplierField, new Function<Object, Object>() {
+
+					@Override
+					public Object apply(Object t) {
+						try {
+							return wrapped.getConstructor(ClassWrapper.NMS_WORLD.getClazz()).newInstance(t);
+						} catch (Exception ex) {
+							logger.log(Level.SEVERE, "Error while creating custom entity instance! ", ex);
+							return function.apply(t);// Fallback to the original one
+						}
+					}
+				});
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + mckey, e);
+			}
+		}
+	}
+
+	protected static void entity1v14(ClassPool classPool) throws ReflectiveOperationException {
+		Object entityRegistry = ClassWrapper.NMS_IREGISTRY.getClazz().getField("ENTITY_TYPE").get(null);
+		Set<?> registryentries = new HashSet<>((Set<?>) ReflectionMethod.REGISTRYMATERIALS_KEYSET.run(entityRegistry));
+		for (Object mckey : registryentries) {
+			if (skippingEntities.contains(mckey.toString())) {
+				logger.info("Skipping, won't be able add NBT to '" + mckey + "' entities!");
+				continue;
+			}
+			Object entityTypesObj = ReflectionMethod.REGISTRYMATERIALS_GET.run(entityRegistry, mckey);
+			String creatorFieldName = "aZ";
+			if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_15_R1.getVersionId())
+				creatorFieldName = "ba";
+			Field creatorField = entityTypesObj.getClass().getDeclaredField(creatorFieldName);
+			creatorField.setAccessible(true);
+			Object creator = creatorField.get(entityTypesObj);
+			Method createEntityMethod = creator.getClass().getMethod("create", ClassWrapper.NMS_ENTITYTYPES.getClazz(),
+					ClassWrapper.NMS_WORLD.getClazz());
+			createEntityMethod.setAccessible(true);
+			Class<?> nmsclass = null;
+			try {
+				nmsclass = createEntityMethod.invoke(creator, entityTypesObj, null).getClass();
+			} catch (Exception ignore) {
+				// ignore
+			}
+			if (nmsclass == null) {
+				String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
+				String name = mckey.toString().replace("minecraft:", "");
+				name = name.substring(0, 1).toUpperCase() + name.substring(1);
+				name = "Entity" + name;
+				if (classMappings.containsKey(mckey.toString()))
+					name = "Entity" + classMappings.get(mckey.toString());
+				try {
+					nmsclass = Class.forName("net.minecraft.server." + version + "." + name);
+				} catch (Exception ignore) {
+					logger.info("Not found: " + "net.minecraft.server." + version + "." + name);
+					// ignore
+				}
+			}
+			if (nmsclass == null) {
+				logger.info(
+						"Wasn't able to create an Entity instace, won't be able add NBT to '" + mckey + "' entities!");
+				continue;
+			}
+			try {
+				if (INBTWrapper.class.isAssignableFrom(nmsclass)) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapEntity(classPool, nmsclass, "__extraData");
+				ReflectionUtil.setFinal(entityTypesObj, creatorField,
+						ClassGenerator.createEntityTypeWrapper(classPool, wrapped).newInstance());
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + mckey, e);
+			}
+		}
+	}
+
+	protected static void tile1v10Below(ClassPool classPool) throws ReflectiveOperationException {
+		for (Map.Entry<String, Class<?>> entry : new HashSet<>(TileEntity.getFMap().entrySet())) {
+			try {
+				if (INBTWrapper.class.isAssignableFrom(entry.getValue())) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapTileEntity(classPool, entry.getValue(), "__extraData");
+				TileEntity.getFMap().put(entry.getKey(), wrapped);
+				TileEntity.getGMap().put(wrapped, entry.getKey());
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + entry.getKey(), e);
+			}
+		}
+	}
+
+	protected static void tile1v12Below(ClassPool classPool) throws ReflectiveOperationException {
+		Object registry = TileEntity.getRegistry();
+		Map<Object, Object> inverse = new HashMap<>();
+		Set<?> it = new HashSet<>((Set<?>) ReflectionMethod.REGISTRY_KEYSET.run(registry));
+		for (Object mckey : it) {
+			Class<?> tileclass = (Class<?>) ReflectionMethod.REGISTRY_GET.run(registry, mckey);
+			inverse.put(tileclass, mckey);
+			try {
+				if (INBTWrapper.class.isAssignableFrom(tileclass)) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapTileEntity(classPool, tileclass, "__extraData");
+				ReflectionMethod.REGISTRY_SET.run(registry, mckey, wrapped);
+				inverse.put(wrapped, mckey);
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + mckey, e);
+			}
+		}
+		Field inverseField = registry.getClass().getDeclaredField("b");
+		ReflectionUtil.setFinal(registry, inverseField, inverse);
+	}
+
+	protected static void tile1v13(ClassPool classPool) throws ReflectiveOperationException {
+		Object tileRegistry = ClassWrapper.NMS_IREGISTRY.getClazz().getField("BLOCK_ENTITY_TYPE").get(null);
+		Set<?> registryentries = new HashSet<>((Set<?>) ReflectionMethod.REGISTRYMATERIALS_KEYSET.run(tileRegistry));
+		for (Object mckey : registryentries) {
+			Object tileEntityTypesObj = ReflectionMethod.REGISTRYMATERIALS_GET.run(tileRegistry, mckey);
+			String supplierFieldName = "A";
+			if (MinecraftVersion.getVersion().getVersionId() == MinecraftVersion.MC1_14_R1.getVersionId())
+				supplierFieldName = "H";
+			else if (MinecraftVersion.getVersion().getVersionId() >= MinecraftVersion.MC1_15_R1.getVersionId())
+				supplierFieldName = "I";
+			Field supplierField = tileEntityTypesObj.getClass().getDeclaredField(supplierFieldName);
+			supplierField.setAccessible(true);
+			Supplier<Object> supplier = (Supplier<Object>) supplierField.get(tileEntityTypesObj);
+			Class<?> nmsclass = supplier.get().getClass();
+			try {
+				if (INBTWrapper.class.isAssignableFrom(nmsclass)) {
+					continue;
+				} // Already injected
+				Class<?> wrapped = ClassGenerator.wrapTileEntity(classPool, nmsclass, "__extraData");
+				ReflectionUtil.setFinal(tileEntityTypesObj, supplierField, new Supplier<Object>() {
+					@Override
+					public Object get() {
+						try {
+							return wrapped.newInstance();
+						} catch (InstantiationException | IllegalAccessException e) {
+							logger.log(Level.SEVERE, "Error while creating custom tile instance! ", e);
+							return supplier.get(); // Use the original one as fallback
+						}
+					}
+				});
+			} catch (Exception e) {
+				throw new NbtApiException("Exception while injecting " + mckey, e);
+			}
+		}
+	}
+
+}

nbt-injector/src/main/java/de/tr7zw/nbtinjector/NBTInjector.java

@@ -0,0 +1,301 @@
+package de.tr7zw.nbtinjector;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.logging.Logger;
+
+import de.tr7zw.changeme.nbtapi.NBTCompound;
+import de.tr7zw.changeme.nbtapi.NBTContainer;
+import de.tr7zw.changeme.nbtapi.NBTEntity;
+import de.tr7zw.changeme.nbtapi.NBTReflectionUtil;
+import de.tr7zw.changeme.nbtapi.NBTTileEntity;
+import de.tr7zw.changeme.nbtapi.NbtApiException;
+import de.tr7zw.changeme.nbtapi.utils.MinecraftVersion;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ClassWrapper;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ObjectCreator;
+import de.tr7zw.changeme.nbtapi.utils.nmsmappings.ReflectionMethod;
+import javassist.ClassPool;
+
+/**
+ * Main class to interact with custom NBT on Tiles and Entities
+ * 
+ * @author tr7zw
+ *
+ */
+public class NBTInjector {
+
+	/**
+	 * Hidden Constructor
+	 */
+	private NBTInjector() {
+
+	}
+
+	static Logger logger = Logger.getLogger("NBTInjector");
+	private static boolean isInjected = false;
+	private static final String NOT_INJECTED_MESSAGE = "The NBTInjector has not been enabled!\n"
+			+ "You need to call 'NBTInjector.inject()' during the Method 'onLoad' of your Plugin!"
+			+ " Check the Wiki/Pluginpage for more information!";
+
+	/**
+	 * Replaces the vanilla classes with Wrapped classes that support custom NBT.
+	 * This method needs to be called during onLoad so classes are replaced before
+	 * worlds load. If your plugin adds a new Entity(probably during onLoad) recall
+	 * this method so it's class gets Wrapped.
+	 */
+	public static void inject() {
+		if(isInjected)return;
+		isInjected = true;
+		try {
+			ClassPool classPool = ClassPool.getDefault();
+			logger.info("[NBTINJECTOR] Injecting Entity classes...");
+			if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_10_R1.getVersionId()) {
+				InternalInjectors.entity1v10Below(classPool);
+			} else if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_12_R1.getVersionId()) {
+				InternalInjectors.entity1v12Below(classPool);
+			} else if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_13_R2.getVersionId()) {
+				InternalInjectors.entity1v13Below(classPool);
+			} else { // 1.14+
+				InternalInjectors.entity1v14(classPool);
+			}
+
+			logger.info("[NBTINJECTOR] Injecting Tile Entity classes...");
+			if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_10_R1.getVersionId()) {
+				InternalInjectors.tile1v10Below(classPool);
+			} else if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_12_R1.getVersionId()) {
+				InternalInjectors.tile1v12Below(classPool);
+			} else { // 1.13+
+				InternalInjectors.tile1v13(classPool);
+			}
+		} catch (Exception e) {
+			throw new NbtApiException(e);
+		}
+	}
+
+	public static boolean isInjected() {
+		return isInjected;
+	}
+
+	private static NBTCompound getNbtData(Object object) {
+		if (object instanceof INBTWrapper) {
+			return ((INBTWrapper) object).getNbtData();
+		}
+		return null;
+	}
+
+	/**
+	 * Entities that have just been spawned(from plugins or natually) may use the
+	 * wrong(Vanilla) class. Calling this method removes the wrong entity and
+	 * respawns it using the correct class. It also tries to keep all data of the
+	 * original entity, but some stuff like passengers will probably cause problems.
+	 * Recalling this method on a patched Entity doesn nothing and returns the
+	 * Entity instance.
+	 * 
+	 * WARNING: This causes the entity to get a new Bukkit Entity instance. For
+	 * other plugins the entity will be a dead/removed entity, even if it's still
+	 * kinda there. Bestcase you spawn an Entity and directly replace your instance
+	 * with a patched one. Also, for players ingame the entity will quickly flash,
+	 * since it's respawned.
+	 * 
+	 * @param entity Entity to respawn with the correct class.
+	 * @return Entity The new instance of the entity.
+	 */
+	public static org.bukkit.entity.Entity patchEntity(org.bukkit.entity.Entity entity) {
+		if (entity == null) {
+			return null;
+		}
+		if(!isInjected)throw new NbtApiException(NOT_INJECTED_MESSAGE);
+		try {
+			Object ent = NBTReflectionUtil.getNMSEntity(entity);
+			if (!(ent instanceof INBTWrapper)) {// Replace Entity with custom one
+				Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(entity.getWorld());
+				Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
+				NBTContainer oldNBT = new NBTContainer(new NBTEntity(entity).getCompound());
+				Method create = ClassWrapper.NMS_ENTITYTYPES.getClazz().getMethod("a",
+						ClassWrapper.NMS_NBTTAGCOMPOUND.getClazz(), ClassWrapper.NMS_WORLD.getClazz());
+				String id = "";
+				if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_10_R1.getVersionId()) {
+					id = Entity.getBackupMap().get(ent.getClass());
+				} else if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_13_R2.getVersionId()) {
+					id = ReflectionMethod.REGISTRY_GET_INVERSE.run(Entity.getRegistry(), ent.getClass()).toString();
+				} else {
+					id = (String) ReflectionMethod.NMS_ENTITY_GETSAVEID.run(ent);
+				}
+				oldNBT.setString("id", id);
+				oldNBT.removeKey("UUIDMost");
+				oldNBT.removeKey("UUIDLeast");
+				entity.remove();
+				Object newEntity = create.invoke(null, oldNBT.getCompound(), nmsworld);
+				if (newEntity instanceof Optional<?> && ((Optional<?>) newEntity).isPresent())
+					newEntity = ((Optional<?>) newEntity).get();
+				Method spawn = ClassWrapper.NMS_WORLD.getClazz().getMethod("addEntity",
+						ClassWrapper.NMS_ENTITY.getClazz());
+				spawn.invoke(nmsworld, newEntity);
+				//logger.info("Created patched instance: " + newEntity.getClass().getName());
+				Method asBukkit = newEntity.getClass().getMethod("getBukkitEntity");
+				return (org.bukkit.entity.Entity) asBukkit.invoke(newEntity);
+			}
+		} catch (Exception e) {
+			throw new NbtApiException("Error while patching an Entity '" + entity + "'", e);
+		}
+		return entity;
+	}
+
+	/**
+	 * Gets the persistant NBTCompound from a given entity. If the Entity isn't yet
+	 * patched, this method will return null.
+	 * 
+	 * @param entity Entity to get the NBTCompound from
+	 * @return NBTCompound instance
+	 */
+	public static NBTCompound getNbtData(org.bukkit.entity.Entity entity) {
+		if (entity == null) {
+			return null;
+		}
+		if(!isInjected)throw new NbtApiException(NOT_INJECTED_MESSAGE);
+		try {
+			Object ent = NBTReflectionUtil.getNMSEntity(entity);
+			if (!(ent instanceof INBTWrapper)) {
+				logger.info("Entity wasn't the correct class! '" + ent.getClass().getName() + "'");
+			}
+			return getNbtData(ent);
+		} catch (Exception e) {
+			throw new NbtApiException("Error while getting the NBT from an Entity '" + entity + "'.", e);
+		}
+	}
+
+	/**
+	 * Gets the persistant NBTCompound from a given TileEntity. If the Tile isn't
+	 * yet patched, this method will autopatch it. This will unlink the given
+	 * BlockState, so calling block.getState() again may be necessary. This behavior
+	 * may change in the future.
+	 * 
+	 * @param tile TileEntity to get the NBTCompound from
+	 * @return NBTCompound instance
+	 */
+	public static NBTCompound getNbtData(org.bukkit.block.BlockState tile) {
+		if (tile == null) {
+			return null;
+		}
+		if(!isInjected)throw new NbtApiException(NOT_INJECTED_MESSAGE);
+		try {
+			Object pos = ObjectCreator.NMS_BLOCKPOSITION.getInstance(tile.getX(), tile.getY(), tile.getZ());
+			Object cworld = ClassWrapper.CRAFT_WORLD.getClazz().cast(tile.getWorld());
+			Object nmsworld = ReflectionMethod.CRAFT_WORLD_GET_HANDLE.run(cworld);
+			Object tileEntity = ReflectionMethod.NMS_WORLD_GET_TILEENTITY.run(nmsworld, pos);
+			if (tileEntity == null) { // Not a tile block
+				return null;
+			}
+			if (!(tileEntity instanceof INBTWrapper)) {
+				// Loading Updated Tile
+
+				Object tileEntityUpdated;
+				if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_9_R1) {
+					tileEntityUpdated = ReflectionMethod.TILEENTITY_LOAD_LEGACY191.run(null, null,
+							new NBTTileEntity(tile).getCompound());
+				} else if (MinecraftVersion.getVersion() == MinecraftVersion.MC1_8_R3
+						|| MinecraftVersion.getVersion() == MinecraftVersion.MC1_9_R2) {
+					tileEntityUpdated = ReflectionMethod.TILEENTITY_LOAD_LEGACY183.run(null,
+							new NBTTileEntity(tile).getCompound());
+				} else if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_12_R1.getVersionId()) {
+					tileEntityUpdated = ReflectionMethod.TILEENTITY_LOAD_LEGACY1121.run(null, nmsworld,
+							new NBTTileEntity(tile).getCompound());
+				} else {
+					tileEntityUpdated = ReflectionMethod.TILEENTITY_LOAD.run(null,
+							new NBTTileEntity(tile).getCompound());
+				}
+				ReflectionMethod.NMS_WORLD_REMOVE_TILEENTITY.run(nmsworld, pos);
+				ReflectionMethod.NMS_WORLD_SET_TILEENTITY.run(nmsworld, pos, tileEntityUpdated);
+				return getNbtData(tileEntityUpdated);
+			}
+			return getNbtData(tileEntity);
+		} catch (Exception e) {
+			throw new NbtApiException(e);
+		}
+	}
+
+	private static Field getAccessable(Field field) {
+		field.setAccessible(true);
+		return field;
+	}
+
+	@SuppressWarnings("unchecked")
+	static class Entity {
+
+		/**
+		 * Hidden Constructor
+		 */
+		private Entity() {
+		}
+
+		private static Map<Class<?>, String> backupMap = new HashMap<>();
+
+		static {
+			try {
+				if (MinecraftVersion.getVersion().getVersionId() <= MinecraftVersion.MC1_10_R1.getVersionId()) {
+					backupMap.putAll(getDMap());
+				}
+			} catch (ReflectiveOperationException e) {
+				throw new NbtApiException(e);
+			}
+		}
+
+		static Object getRegistry() throws ReflectiveOperationException {
+			return getAccessable(ClassWrapper.NMS_ENTITYTYPES.getClazz().getDeclaredField("b")).get(null);
+		}
+		
+		static Object getRegistryId(Object reg) throws ReflectiveOperationException {
+			return getAccessable(reg.getClass().getDeclaredField("a")).get(reg);
+		}
+
+		static Map<Class<?>, String> getBackupMap() throws ReflectiveOperationException {
+			return backupMap;
+		}
+
+		static Map<String, Class<?>> getCMap() throws ReflectiveOperationException {
+			return (Map<String, Class<?>>) getAccessable(ClassWrapper.NMS_ENTITYTYPES.getClazz().getDeclaredField("c"))
+					.get(null);
+		}
+
+		static Map<Class<?>, String> getDMap() throws ReflectiveOperationException {
+			return (Map<Class<?>, String>) getAccessable(ClassWrapper.NMS_ENTITYTYPES.getClazz().getDeclaredField("d"))
+					.get(null);
+		}
+
+		static Map<Integer, Class<?>> getEMap() throws ReflectiveOperationException {
+			return (Map<Integer, Class<?>>) getAccessable(ClassWrapper.NMS_ENTITYTYPES.getClazz().getDeclaredField("e"))
+					.get(null);
+		}
+
+		static Map<Class<?>, Integer> getFMap() throws ReflectiveOperationException {
+			return (Map<Class<?>, Integer>) getAccessable(ClassWrapper.NMS_ENTITYTYPES.getClazz().getDeclaredField("f"))
+					.get(null);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	static class TileEntity {
+		/**
+		 * Hidden Constructor
+		 */
+		private TileEntity() {
+		}
+
+		static Object getRegistry() throws ReflectiveOperationException {
+			return getAccessable(ClassWrapper.NMS_TILEENTITY.getClazz().getDeclaredField("f")).get(null);
+		}
+
+		static Map<String, Class<?>> getFMap() throws ReflectiveOperationException {
+			return (Map<String, Class<?>>) getAccessable(ClassWrapper.NMS_TILEENTITY.getClazz().getDeclaredField("f"))
+					.get(null);
+		}
+
+		static Map<Class<?>, String> getGMap() throws ReflectiveOperationException {
+			return (Map<Class<?>, String>) getAccessable(ClassWrapper.NMS_TILEENTITY.getClazz().getDeclaredField("g"))
+					.get(null);
+		}
+	}
+}

pom.xml

@@ -1,89 +1,109 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>de.tr7zw</groupId>
-    <artifactId>item-nbt-parent</artifactId>
-    <version>1.8.3-SNAPSHOT</version>
-    <packaging>pom</packaging>
-
-    <modules>
-        <module>item-nbt-api</module>
-        <module>item-nbt-plugin</module>
-    </modules>
-
-    <properties>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-    <build>
-        <defaultGoal>clean install</defaultGoal>
-
-		<resources>
-			<resource>
-				<filtering>false</filtering>
-				<directory>.</directory>
-				<includes>
-					<include>LICENSE</include>
-				</includes>
-			</resource>
-		</resources>
-
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.1</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-source-plugin</artifactId>
-                <version>3.0.1</version>
-                <executions>
-                    <execution>
-                        <id>attach-sources</id>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>3.1.0</version>
-                <executions>
-                    <execution>
-                        <id>attach-javadocs</id>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-
-	<repositories>
-		<repository>
-			<id>spigotmc-repo</id>
-			<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots</url>
-		</repository>
-    </repositories>
-
-    <dependencies>
-        <dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>1.13.1-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-		</dependency>
-    </dependencies>
-
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>de.tr7zw</groupId>
+  <artifactId>item-nbt-parent</artifactId>
+  <version>2.2.0</version>
+  <packaging>pom</packaging>
+  <modules>
+    <module>item-nbt-api</module>
+    <module>nbt-injector</module>
+    <module>item-nbt-plugin</module>
+  </modules>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>org.spigotmc</groupId>
+      <artifactId>spigot-api</artifactId>
+      <version>1.14.2-R0.1-SNAPSHOT</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>de.tr7zw.spigotmc.maven</groupId>
+      <artifactId>tr-spigotmc-maven-plugin</artifactId>
+      <version>0.0.1-SNAPSHOT</version>
+      <scope>provided</scope>
+    </dependency>
+  </dependencies>
+  <repositories>
+    <!-- CodeMC -->
+    <repository>
+      <id>codemc-repo</id>
+      <url>https://repo.codemc.org/repository/maven-public/</url>
+      <layout>default</layout>
+    </repository>
+    <!-- CodeMC NMS -->
+    <repository>
+      <id>codemc-nms-repo</id>
+      <url>https://repo.codemc.org/repository/nms/</url>
+      <layout>default</layout>
+    </repository>
+  </repositories>
+  <build>
+    <defaultGoal>clean install</defaultGoal>
+    <resources>
+      <resource>
+        <filtering>false</filtering>
+        <directory>.</directory>
+        <includes>
+          <include>LICENSE</include>
+        </includes>
+      </resource>
+    </resources>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.8.1</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>3.2.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>3.1.1</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <source>8</source>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>com.github.ekryd.sortpom</groupId>
+        <artifactId>sortpom-maven-plugin</artifactId>
+        <version>2.10.0</version>
+        <executions>
+          <execution>
+            <id>sortpom</id>
+            <goals>
+              <goal>verify</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
 </project>