Nedit/me.nullicorn.nedit.type/NBTCompound

NBTCompound

public class NBTCompound extends AbstractMap<K, V>

A map-like structure for storing NBT tags associated with unique UTF-8 (modified) names.

Nesting

If a compound is inside another compound, the inner one is considered to be "nested", and the outer one is its "parent". To access the nested compound's contents, you would first need to get it from its parent, check that it is not null, and then repeat for any further nested compounds. To avoid this, the implementation allows you to use dot-notation in these cases. More specifically, dot-notation is valid in methods that cannot alter the structure of the compound (and those that accept a tag name), like getter and contains methods.

Consider the following NBT data:


{
  user: {
    name: "User291",
    id: "ae630aa9-cdbb-4aaf-be42-868889585b4d",
    coins: 19531L,
    social_media: {
      discord: "Player291#4444",
      twitter: "User291",
      "i_have_a_dot_._in_me": true
    },
  }
}

In this case, to access the user's Discord username, we'd use the path

"user.social_media.discord"

To access the user's ID, we would use

"user.id"

And to access the entire user compound, just

"user"

If a tag's name has a literal dot (.) in it that does not indicate nesting, a backslash can be used to escape the character. This means using a double-backslash in string literals, such as

"user.social_media.i_have_a_dot_\\._in_me"

In any case, dot-notation is not required, and a compound's direct children can still be accessed normally using their respective names.

Author

Nullicorn

Constructors

NBTCompound

public void NBTCompound()

Creates an empty NBT compound.

Functions

clear

public void clear()

compute

public V compute(K key, BiFunction<? extends Object, ? extends Object, ? extends V> remappingFunction)

computeIfAbsent

public V computeIfAbsent(K key, Function<? extends Object, ? extends V> mappingFunction)

computeIfPresent

public V computeIfPresent(K key, BiFunction<? extends Object, ? extends Object, ? extends V> remappingFunction)

containsKey

public boolean containsKey(Object key)

Same as containsTag(...), but true will be returned if any tag in the compound uses the key, regardless of the tag's type.

containsTag

public boolean containsTag(String name, TagType type)

containsValue

public boolean containsValue(Object value)

copyOf

public static Map<K, V> copyOf<K, V>(Map<? extends K, ? extends V> map)

entry

public static Map.Entry<K, V> entry<K, V>(K k, V v)

entrySet

public Set<Map.Entry<String, Object>> entrySet()

equals

public boolean equals(Object o)

forEach

public void forEach(BiConsumer<? extends Object, ? extends Object> action)

get

public Object get(Object name)

Retrieves the value of a tag inside the compound.

getByte

public byte getByte(String name, byte defaultValue)

getByteArray

public Array<byte> getByteArray(String name)

getCompound

public NBTCompound getCompound(String name)

getDouble

public double getDouble(String name, double defaultValue)

getFloat

public float getFloat(String name, float defaultValue)

getInt

public int getInt(String name, int defaultValue)

getIntArray

public Array<int> getIntArray(String name)

getList

public NBTList getList(String name)

getLong

public long getLong(String name, long defaultValue)

getLongArray

public Array<long> getLongArray(String name)

getNumber

public Number getNumber(String name, Number defaultValue)

getOrDefault

public V getOrDefault(Object key, V defaultValue)

getShort

public short getShort(String name, short defaultValue)

getString

public String getString(String name)

Same as getString, but the default value is always null.

public String getString(String name, String defaultValue)

hashCode

public int hashCode()

isEmpty

public boolean isEmpty()

keySet

public Set<String> keySet()

merge

public V merge( K key, V value, BiFunction<? extends Object, ? extends Object, ? extends V> remappingFunction)

public static Map<K, V> of<K, V>()

ofEntries

public static Map<K, V> ofEntries<K, V>(Array<Map.Entry<? extends K, ? extends V>> entries)

put

public Object put(String name, Object value)

putAll

public void putAll(Map<? extends K, ? extends V> m)

putIfAbsent

public Object putIfAbsent(String name, Object value)

remove

public Object remove(Object name)

public boolean remove(Object name, Object value)

replace

public V replace(K key, V value)

public boolean replace( K key, V oldValue, V newValue)

replaceAll

public void replaceAll(BiFunction<? extends Object, ? extends Object, ? extends V> function)

size

public int size()

toString

public String toString()

values

public Collection<Object> values()