diff --git a/.gitignore b/.gitignore
index 61b3b58..56102af 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,8 @@
+#################
+## Eclipse
+#################
+.src/test/
+
#################
## Eclipse
#################
diff --git a/pom.xml b/pom.xml
index 035a9cf..7d008b9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
com.farisKingKits
- 5.2.6
+ 5.2.7jar
@@ -144,7 +144,7 @@
org.bukkitbukkit
- 1.9.2-R0.1-SNAPSHOT
+ 1.10.2-R0.1-SNAPSHOTcom.google.code.gson
diff --git a/src/main/java/com/comphenix/attributes/Attributes.java b/src/main/java/com/comphenix/attributes/Attributes.java
new file mode 100644
index 0000000..cc54e1b
--- /dev/null
+++ b/src/main/java/com/comphenix/attributes/Attributes.java
@@ -0,0 +1,457 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Kristian Stangeland
+//
+// 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.
+
+package com.comphenix.attributes;
+
+import com.comphenix.attributes.NbtFactory.NbtCompound;
+import com.comphenix.attributes.NbtFactory.NbtList;
+import com.faris.kingkits.helper.util.ObjectUtilities;
+import com.faris.kingkits.helper.util.Utilities;
+import com.google.common.base.Function;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Maps;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.inventory.ItemStack;
+
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.concurrent.ConcurrentMap;
+
+public class Attributes {
+ public enum Operation {
+ ADD_NUMBER(0),
+ MULTIPLY_PERCENTAGE(1),
+ ADD_PERCENTAGE(2);
+ private int id;
+
+ private Operation(int id) {
+ this.id = id;
+ }
+
+ public int getId() {
+ return id;
+ }
+
+ public static Operation fromId(int id) {
+ // Linear scan is very fast for small N
+ for (Operation op : values()) {
+ if (op.getId() == id) {
+ return op;
+ }
+ }
+ throw new IllegalArgumentException("Corrupt operation ID " + id + " detected.");
+ }
+ }
+
+ public static class AttributeType {
+ private static ConcurrentMap LOOKUP = Maps.newConcurrentMap();
+ public static final AttributeType GENERIC_MAX_HEALTH = new AttributeType("generic.maxHealth").register();
+ public static final AttributeType GENERIC_FOLLOW_RANGE = new AttributeType("generic.followRange").register();
+ public static final AttributeType GENERIC_ATTACK_DAMAGE = new AttributeType("generic.attackDamage").register();
+ public static final AttributeType GENERIC_MOVEMENT_SPEED = new AttributeType("generic.movementSpeed").register();
+ public static final AttributeType GENERIC_KNOCKBACK_RESISTANCE = new AttributeType("generic.knockbackResistance").register();
+ public static final AttributeType GENERIC_ARMOUR_DEFENSE = new AttributeType("generic.armor").register();
+ public static final AttributeType GENERIC_ATTACK_SPEED = new AttributeType("generic.attackSpeed").register();
+ public static final AttributeType GENERIC_LUCK = new AttributeType("generic.luck").register();
+ public static final AttributeType HORSE_JUMP_STRENGTH = new AttributeType("horse.jumpStrength").register();
+ public static final AttributeType ZOMBIE_SPAWN_REINFORCEMENTS = new AttributeType("zombie.spawnReinforcements").register();
+
+ private static Map TYPE_LOOKUP = new HashMap<>();
+
+ private final String minecraftId;
+
+ /**
+ * Construct a new attribute type.
+ *
+ * Remember to {@link #register()} the type.
+ *
+ * @param minecraftId - the ID of the type.
+ */
+ public AttributeType(String minecraftId) {
+ this.minecraftId = minecraftId;
+ }
+
+ /**
+ * Retrieve the associated minecraft ID.
+ *
+ * @return The associated ID.
+ */
+ public String getMinecraftId() {
+ return minecraftId;
+ }
+
+ /**
+ * Register the type in the central registry.
+ *
+ * @return The registered type.
+ */
+ // Constructors should have no side-effects!
+ public AttributeType register() {
+ AttributeType old = LOOKUP.putIfAbsent(minecraftId, this);
+ return old != null ? old : this;
+ }
+
+ /**
+ * Retrieve the attribute type associated with a given ID.
+ *
+ * @param minecraftId The ID to search for.
+ * @return The attribute type, or NULL if not found.
+ */
+ public static AttributeType fromId(String minecraftId) {
+ return LOOKUP.get(minecraftId);
+ }
+
+ /**
+ * Retrieve every registered attribute type.
+ *
+ * @return Every type.
+ */
+ public static Iterable values() {
+ return LOOKUP.values();
+ }
+
+ public static AttributeType valueOf(String name) {
+ if (name == null) return null;
+ String modName = name.replace(' ', '_').toUpperCase();
+ if (TYPE_LOOKUP.containsKey(modName)) {
+ return TYPE_LOOKUP.get("GENERIC_" + modName);
+ } else if (TYPE_LOOKUP.containsKey("GENERIC_" + modName)) {
+ return TYPE_LOOKUP.get("GENERIC_" + modName);
+ } else if (TYPE_LOOKUP.containsKey("ZOMBIE_" + modName)) {
+ return TYPE_LOOKUP.get("ZOMBIE_" + modName);
+ } else if (TYPE_LOOKUP.containsKey("HORSE_" + modName)) {
+ return TYPE_LOOKUP.get("HORSE_" + modName);
+ } else {
+ return fromId(name);
+ }
+ }
+
+ public static void initialiseNameMap() {
+ TYPE_LOOKUP.clear();
+ try {
+ for (Field field : AttributeType.class.getFields()) {
+ if (field.getType() == AttributeType.class) {
+ TYPE_LOOKUP.put(field.getName(), (AttributeType) field.get(null));
+ }
+ }
+ } catch (Exception ex) {
+ ex.printStackTrace();
+ }
+ }
+ }
+
+ public static class Attribute implements ConfigurationSerializable {
+ private NbtCompound data;
+
+ private Attribute(Builder builder) {
+ data = NbtFactory.createCompound();
+ setAmount(builder.amount);
+ setOperation(builder.operation);
+ setAttributeType(builder.type);
+ setName(builder.name);
+ setUUID(builder.uuid);
+ }
+
+ private Attribute(NbtCompound data) {
+ this.data = data;
+ }
+
+ public double getAmount() {
+ return data.getDouble("Amount", 0.0);
+ }
+
+ public void setAmount(double amount) {
+ data.put("Amount", amount);
+ }
+
+ public Operation getOperation() {
+ return Operation.fromId(data.getInteger("Operation", 0));
+ }
+
+ public void setOperation(Operation operation) {
+ Preconditions.checkNotNull(operation, "operation cannot be NULL.");
+ data.put("Operation", operation.getId());
+ }
+
+ public AttributeType getAttributeType() {
+ return AttributeType.fromId(data.getString("AttributeName", null));
+ }
+
+ public void setAttributeType(AttributeType type) {
+ Preconditions.checkNotNull(type, "type cannot be NULL.");
+ data.put("AttributeName", type.getMinecraftId());
+ }
+
+ public String getName() {
+ return data.getString("Name", null);
+ }
+
+ public void setName(String name) {
+ Preconditions.checkNotNull(name, "name cannot be NULL.");
+ data.put("Name", name);
+ }
+
+ public UUID getUUID() {
+ return new UUID(data.getLong("UUIDMost", null), data.getLong("UUIDLeast", null));
+ }
+
+ public void setUUID(UUID id) {
+ Preconditions.checkNotNull("id", "id cannot be NULL.");
+ data.put("UUIDLeast", id.getLeastSignificantBits());
+ data.put("UUIDMost", id.getMostSignificantBits());
+ }
+
+ /**
+ * Construct a new attribute builder with a random UUID and default operation of adding numbers.
+ *
+ * @return The attribute builder.
+ */
+ public static Builder newBuilder() {
+ return new Builder().uuid(UUID.randomUUID()).operation(Operation.ADD_NUMBER);
+ }
+
+ @Override
+ public Map serialize() {
+ Map serializedAttribute = new LinkedHashMap<>();
+ serializedAttribute.put("UUID", this.getUUID().toString());
+ serializedAttribute.put("Name", this.getName());
+ serializedAttribute.put("Type", this.getAttributeType().getMinecraftId());
+ serializedAttribute.put("Amount", this.getAmount());
+ Operation operation = this.getOperation();
+ if (operation != null) serializedAttribute.put("Operation", operation.name());
+ return serializedAttribute;
+ }
+
+ public static Attribute deserialize(Map serializedAttribute) {
+ Attribute deserializedAttribute = null;
+ if (serializedAttribute != null && serializedAttribute.containsKey("Name")) {
+ AttributeType attributeType = null;
+ try {
+ attributeType = AttributeType.valueOf(ObjectUtilities.getObject(serializedAttribute, String.class, "Type"));
+ } catch (Exception ignored) {
+ }
+ if (attributeType != null) {
+ UUID attributeUUID = Utilities.isUUID(serializedAttribute.get("UUID")) ? UUID.fromString(serializedAttribute.get("UUID").toString()) : null;
+ double attributeAmount = ObjectUtilities.getObject(serializedAttribute, Number.class, "Amount", 0D).doubleValue();
+ Operation operation = null;
+ try {
+ operation = Operation.valueOf(ObjectUtilities.getObject(serializedAttribute, String.class, "Operation"));
+ } catch (Exception ignored) {
+ }
+ if (operation == null) operation = Operation.ADD_NUMBER;
+ Builder attributeBuilder = new Builder().name(ObjectUtilities.getObject(serializedAttribute, String.class, "Name")).type(attributeType).operation(operation).amount(attributeAmount);
+ if (attributeUUID != null) attributeBuilder.uuid(attributeUUID);
+ deserializedAttribute = attributeBuilder.build();
+ }
+ }
+ return deserializedAttribute;
+ }
+
+ // Makes it easier to construct an attribute
+ public static class Builder {
+ private double amount;
+ private Operation operation = Operation.ADD_NUMBER;
+ private AttributeType type;
+ private String name;
+ private UUID uuid;
+
+ private Builder() {
+ // Don't make this accessible
+ }
+
+ public Builder amount(double amount) {
+ this.amount = amount;
+ return this;
+ }
+
+ public Builder operation(Operation operation) {
+ this.operation = operation;
+ return this;
+ }
+
+ public Builder type(AttributeType type) {
+ this.type = type;
+ return this;
+ }
+
+ public Builder name(String name) {
+ this.name = name;
+ return this;
+ }
+
+ public Builder uuid(UUID uuid) {
+ this.uuid = uuid;
+ return this;
+ }
+
+ public Attribute build() {
+ return new Attribute(this);
+ }
+ }
+ }
+
+ // This may be modified
+ public ItemStack stack;
+ private NbtList attributes;
+
+ public Attributes(ItemStack stack) {
+ // Create a CraftItemStack (under the hood)
+ this.stack = NbtFactory.getCraftItemStack(stack);
+ loadAttributes(false);
+ }
+
+ /**
+ * Load the NBT list from the TAG compound.
+ *
+ * @param createIfMissing - create the list if its missing.
+ */
+ private void loadAttributes(boolean createIfMissing) {
+ if (this.attributes == null) {
+ NbtCompound nbt = NbtFactory.fromItemTag(this.stack);
+ this.attributes = nbt.getList("AttributeModifiers", createIfMissing);
+ }
+ }
+
+ /**
+ * Remove the NBT list from the TAG compound.
+ */
+ private void removeAttributes() {
+ NbtCompound nbt = NbtFactory.fromItemTag(this.stack);
+ nbt.remove("AttributeModifiers");
+ this.attributes = null;
+ }
+
+ /**
+ * Retrieve the modified item stack.
+ *
+ * @return The modified item stack.
+ */
+ public ItemStack getStack() {
+ return stack;
+ }
+
+ /**
+ * Retrieve the number of attributes.
+ *
+ * @return Number of attributes.
+ */
+ public int size() {
+ return attributes != null ? attributes.size() : 0;
+ }
+
+ /**
+ * Add a new attribute to the list.
+ *
+ * @param attribute - the new attribute.
+ */
+ public void add(Attribute attribute) {
+ Preconditions.checkNotNull(attribute.getName(), "must specify an attribute name.");
+ loadAttributes(true);
+ int removeIndex = -1;
+ for (int i = 0; i < this.attributes.size(); i++) {
+ NbtCompound attributeData = (NbtCompound) this.attributes.get(i);
+ if (attribute.getName().equals(attributeData.getString("AttributeName", null))) {
+ removeIndex = i;
+ break;
+ }
+ }
+ if (removeIndex != -1) this.attributes.remove(removeIndex);
+ this.attributes.add(attribute.data);
+ }
+
+ /**
+ * Remove the first instance of the given attribute.
+ *
+ * The attribute will be removed using its UUID.
+ *
+ * @param attribute - the attribute to remove.
+ * @return TRUE if the attribute was removed, FALSE otherwise.
+ */
+ public boolean remove(Attribute attribute) {
+ if (attributes == null)
+ return false;
+ UUID uuid = attribute.getUUID();
+
+ for (Iterator it = values().iterator(); it.hasNext(); ) {
+ if (Objects.equal(it.next().getUUID(), uuid)) {
+ it.remove();
+
+ // Last removed attribute?
+ if (size() == 0) {
+ removeAttributes();
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Remove every attribute.
+ */
+ public void clear() {
+ removeAttributes();
+ }
+
+ /**
+ * Retrieve the attribute at a given index.
+ *
+ * @param index - the index to look up.
+ * @return The attribute at that index.
+ */
+ public Attribute get(int index) {
+ if (size() == 0)
+ throw new IllegalStateException("Attribute list is empty.");
+ return new Attribute((NbtCompound) attributes.get(index));
+ }
+
+ /**
+ * Retrieve all the attributes.
+ *
+ * @return The attributes.
+ */
+ public List getAll() {
+ if (size() == 0) return new ArrayList<>();
+ List attributesList = new ArrayList<>();
+ for (Object attribute : this.attributes) {
+ attributesList.add(new Attribute((NbtCompound) attribute));
+ }
+ return attributesList;
+ }
+
+ // We can't make Attributes itself iterable without splitting it up into separate classes
+ public Iterable values() {
+ return new Iterable() {
+ @Override
+ public Iterator iterator() {
+ // Handle the empty case
+ if (size() == 0)
+ return Collections.emptyList().iterator();
+
+ return Iterators.transform(attributes.iterator(),
+ new Function() {
+ @Override
+ public Attribute apply(Object element) {
+ return new Attribute((NbtCompound) element);
+ }
+ });
+ }
+ };
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/comphenix/attributes/NbtFactory.java b/src/main/java/com/comphenix/attributes/NbtFactory.java
new file mode 100644
index 0000000..991b0db
--- /dev/null
+++ b/src/main/java/com/comphenix/attributes/NbtFactory.java
@@ -0,0 +1,1056 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015 Kristian Stangeland
+//
+// 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.
+
+package com.comphenix.attributes;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.MapMaker;
+import com.google.common.io.Closeables;
+import com.google.common.io.Files;
+import com.google.common.io.InputSupplier;
+import com.google.common.io.OutputSupplier;
+import com.google.common.primitives.Primitives;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.*;
+import java.util.concurrent.ConcurrentMap;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+public class NbtFactory {
+ // Convert between NBT id and the equivalent class in java
+ private static final BiMap> NBT_CLASS = HashBiMap.create();
+ private static final BiMap NBT_ENUM = HashBiMap.create();
+
+ /**
+ * Whether or not to enable stream compression.
+ *
+ * @author Kristian
+ */
+ public enum StreamOptions {
+ NO_COMPRESSION,
+ GZIP_COMPRESSION,
+ }
+
+ private enum NbtType {
+ TAG_END(0, Void.class),
+ TAG_BYTE(1, byte.class),
+ TAG_SHORT(2, short.class),
+ TAG_INT(3, int.class),
+ TAG_LONG(4, long.class),
+ TAG_FLOAT(5, float.class),
+ TAG_DOUBLE(6, double.class),
+ TAG_BYTE_ARRAY(7, byte[].class),
+ TAG_INT_ARRAY(11, int[].class),
+ TAG_STRING(8, String.class),
+ TAG_LIST(9, List.class),
+ TAG_COMPOUND(10, Map.class);
+
+ // Unique NBT id
+ public final int id;
+
+ private NbtType(int id, Class type) {
+ this.id = id;
+ NBT_CLASS.put(id, type);
+ NBT_ENUM.put(id, this);
+ }
+
+ private String getFieldName() {
+ if (this == TAG_COMPOUND)
+ return "map";
+ else if (this == TAG_LIST)
+ return "list";
+ else
+ return "data";
+ }
+ }
+
+ // The NBT base class
+ private Class BASE_CLASS;
+ private Class COMPOUND_CLASS;
+ private Class STREAM_TOOLS;
+ private Class READ_LIMITER_CLASS;
+ private Method NBT_CREATE_TAG;
+ private Method NBT_GET_TYPE;
+ private Field NBT_LIST_TYPE;
+ private final Field[] DATA_FIELD = new Field[12];
+
+ // CraftItemStack
+ private Class CRAFT_STACK;
+ private Field CRAFT_HANDLE;
+ private Field STACK_TAG;
+
+ // Loading/saving compounds
+ private LoadCompoundMethod LOAD_COMPOUND;
+ private Method SAVE_COMPOUND;
+
+ // Shared instance
+ private static NbtFactory INSTANCE;
+
+ /**
+ * Represents a root NBT compound.
+ *
+ * All changes to this map will be reflected in the underlying NBT compound. Values may only be one of the following:
+ *
+ *
Primitive types
+ *
{@link java.lang.String String}
+ *
{@link NbtList}
+ *
{@link NbtCompound}
+ *
+ *
+ * See also:
+ *
+ *
{@link NbtFactory#createCompound()}
+ *
{@link NbtFactory#fromCompound(Object)}
+ *
+ *
+ * @author Kristian
+ */
+ public final class NbtCompound extends ConvertedMap {
+ private NbtCompound(Object handle) {
+ super(handle, getDataMap(handle));
+ }
+
+ // Simplifiying access to each value
+ public Byte getByte(String key, Byte defaultValue) {
+ return containsKey(key) ? (Byte) get(key) : defaultValue;
+ }
+
+ public Short getShort(String key, Short defaultValue) {
+ return containsKey(key) ? (Short) get(key) : defaultValue;
+ }
+
+ public Integer getInteger(String key, Integer defaultValue) {
+ return containsKey(key) ? (Integer) get(key) : defaultValue;
+ }
+
+ public Long getLong(String key, Long defaultValue) {
+ return containsKey(key) ? (Long) get(key) : defaultValue;
+ }
+
+ public Float getFloat(String key, Float defaultValue) {
+ return containsKey(key) ? (Float) get(key) : defaultValue;
+ }
+
+ public Double getDouble(String key, Double defaultValue) {
+ return containsKey(key) ? (Double) get(key) : defaultValue;
+ }
+
+ public String getString(String key, String defaultValue) {
+ return containsKey(key) ? (String) get(key) : defaultValue;
+ }
+
+ public byte[] getByteArray(String key, byte[] defaultValue) {
+ return containsKey(key) ? (byte[]) get(key) : defaultValue;
+ }
+
+ public int[] getIntegerArray(String key, int[] defaultValue) {
+ return containsKey(key) ? (int[]) get(key) : defaultValue;
+ }
+
+ /**
+ * Retrieve the list by the given name.
+ *
+ * @param key - the name of the list.
+ * @param createNew - whether or not to create a new list if its missing.
+ * @return An existing list, a new list or NULL.
+ */
+ public NbtList getList(String key, boolean createNew) {
+ NbtList list = (NbtList) get(key);
+
+ if (list == null && createNew)
+ put(key, list = createList());
+ return list;
+ }
+
+ /**
+ * Retrieve the map by the given name.
+ *
+ * @param key - the name of the map.
+ * @param createNew - whether or not to create a new map if its missing.
+ * @return An existing map, a new map or NULL.
+ */
+ public NbtCompound getMap(String key, boolean createNew) {
+ return getMap(Arrays.asList(key), createNew);
+ }
+ // Done
+
+ /**
+ * Set the value of an entry at a given location.
+ *
+ * Every element of the path (except the end) are assumed to be compounds, and will
+ * be created if they are missing.
+ *
+ * @param path - the path to the entry.
+ * @param value - the new value of this entry.
+ * @return This compound, for chaining.
+ */
+ public NbtCompound putPath(String path, Object value) {
+ List entries = getPathElements(path);
+ Map map = getMap(entries.subList(0, entries.size() - 1), true);
+
+ map.put(entries.get(entries.size() - 1), value);
+ return this;
+ }
+
+ /**
+ * Retrieve the value of a given entry in the tree.
+ *
+ * Every element of the path (except the end) are assumed to be compounds. The
+ * retrieval operation will be cancelled if any of them are missing.
+ *
+ * @param path - path to the entry.
+ * @return The value, or NULL if not found.
+ */
+ @SuppressWarnings("unchecked")
+ public T getPath(String path) {
+ List entries = getPathElements(path);
+ NbtCompound map = getMap(entries.subList(0, entries.size() - 1), false);
+
+ if (map != null) {
+ return (T) map.get(entries.get(entries.size() - 1));
+ }
+ return null;
+ }
+
+ /**
+ * Save the content of a NBT compound to a stream.
+ *
+ * Use {@link Files#newOutputStreamSupplier(java.io.File)} to provide a stream supplier to a file.
+ *
+ * @param stream - the output stream.
+ * @param option - whether or not to compress the output.
+ * @throws IOException If anything went wrong.
+ */
+ public void saveTo(OutputSupplier stream, StreamOptions option) throws IOException {
+ saveStream(this, stream, option);
+ }
+
+ /**
+ * Retrieve a map from a given path.
+ *
+ * @param path - path of compounds to look up.
+ * @param createNew - whether or not to create new compounds on the way.
+ * @return The map at this location.
+ */
+ private NbtCompound getMap(Iterable path, boolean createNew) {
+ NbtCompound current = this;
+
+ for (String entry : path) {
+ NbtCompound child = (NbtCompound) current.get(entry);
+
+ if (child == null) {
+ if (!createNew)
+ return null;
+ current.put(entry, child = createCompound());
+ }
+ current = child;
+ }
+ return current;
+ }
+
+ /**
+ * Split the path into separate elements.
+ *
+ * @param path - the path to split.
+ * @return The elements.
+ */
+ private List getPathElements(String path) {
+ return Lists.newArrayList(Splitter.on(".").omitEmptyStrings().split(path));
+ }
+ }
+
+ /**
+ * Represents a root NBT list.
+ * See also:
+ *
+ *
{@link NbtFactory#createList(Object...)}
+ *
{@link NbtFactory#fromList(Object)}
+ *
+ *
+ * @author Kristian
+ */
+ public final class NbtList extends ConvertedList {
+ private NbtList(Object handle) {
+ super(handle, getDataList(handle));
+ }
+ }
+
+ /**
+ * Represents an object that provides a view of a native NMS class.
+ *
+ * @author Kristian
+ */
+ public static interface Wrapper {
+ /**
+ * Retrieve the underlying native NBT tag.
+ *
+ * @return The underlying NBT.
+ */
+ public Object getHandle();
+ }
+
+ /**
+ * Retrieve or construct a shared NBT factory.
+ *
+ * @return The factory.
+ */
+ private static NbtFactory get() {
+ if (INSTANCE == null)
+ INSTANCE = new NbtFactory();
+ return INSTANCE;
+ }
+
+ /**
+ * Construct an instance of the NBT factory by deducing the class of NBTBase.
+ */
+ private NbtFactory() {
+ if (BASE_CLASS == null) {
+ try {
+ // Keep in mind that I do use hard-coded field names - but it's okay as long as we're dealing
+ // with CraftBukkit or its derivatives. This does not work in MCPC+ however.
+ ClassLoader loader = NbtFactory.class.getClassLoader();
+
+ String packageName = getPackageName();
+ Class offlinePlayer = loader.loadClass(packageName + ".CraftOfflinePlayer");
+
+ // Prepare NBT
+ COMPOUND_CLASS = getMethod(0, Modifier.STATIC, offlinePlayer, "getData").getReturnType();
+ BASE_CLASS = COMPOUND_CLASS.getSuperclass();
+ NBT_GET_TYPE = getMethod(0, Modifier.STATIC, BASE_CLASS, "getTypeId");
+ NBT_CREATE_TAG = getMethod(Modifier.STATIC, 0, BASE_CLASS, "createTag", byte.class);
+
+ // Prepare CraftItemStack
+ CRAFT_STACK = loader.loadClass(packageName + ".inventory.CraftItemStack");
+ CRAFT_HANDLE = getField(null, CRAFT_STACK, "handle");
+ STACK_TAG = getField(null, CRAFT_HANDLE.getType(), "tag");
+
+ // Loading/saving
+ String nmsPackage = BASE_CLASS.getPackage().getName();
+ initializeNMS(loader, nmsPackage);
+
+ LOAD_COMPOUND = READ_LIMITER_CLASS != null ?
+ new LoadMethodSkinUpdate(STREAM_TOOLS, READ_LIMITER_CLASS) :
+ new LoadMethodWorldUpdate(STREAM_TOOLS);
+ SAVE_COMPOUND = getMethod(Modifier.STATIC, 0, STREAM_TOOLS, null, BASE_CLASS, DataOutput.class);
+
+ } catch (ClassNotFoundException e) {
+ throw new IllegalStateException("Unable to find offline player.", e);
+ }
+ }
+ }
+
+ private void initializeNMS(ClassLoader loader, String nmsPackage) {
+ try {
+ STREAM_TOOLS = loader.loadClass(nmsPackage + ".NBTCompressedStreamTools");
+ READ_LIMITER_CLASS = loader.loadClass(nmsPackage + ".NBTReadLimiter");
+ } catch (ClassNotFoundException e) {
+ // Ignore - we will detect this later
+ }
+ }
+
+ private String getPackageName() {
+ Server server = Bukkit.getServer();
+ String name = server != null ? server.getClass().getPackage().getName() : null;
+
+ if (name != null && name.contains("craftbukkit")) {
+ return name;
+ } else {
+ // Fallback
+ return "org.bukkit.craftbukkit.v1_7_R3";
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Map getDataMap(Object handle) {
+ return (Map) getFieldValue(
+ getDataField(NbtType.TAG_COMPOUND, handle), handle);
+ }
+
+ @SuppressWarnings("unchecked")
+ private List