NBTCompound (PowerNBT 0.8.7 API)

java.lang.Object
- me.dpohvar.powernbt.api.NBTCompound

All Implemented Interfaces:

Map<String,Object>
```
public class NBTCompound
extends Object
implements Map<String,Object>
```
Represent net.minecraft.server.NBTTagCompound.
Allows you to work with NBTTagCompound as with Map.
values of this map will be converted to java primitive types if it possible.
net.minecraft.server.NBTTagList converted to NBTList
net.minecraft.server.NBTTagCompound converted to NBTCompound
types allowed to put:
* all primitive types (boolean as NBTTagByte 0 or 1)
* Object[] as NBTTagList
* java.util.Collection as NBTTagList
* java.util.Map as NBTTagCompound
arrays, collections and maps must contains only the allowed values.
Difference from Map:
put(String, Object) creates a clone of NBT tag before put:
```
   NBTCompound cmp = new NBTCompound(); // cmp = {}
   cmp.put("foo", "bar"); // cmp = {foo=bar}
   cmp.put("self", cmp); // cloning cmp before put, cmp = {foo=bar, self={foo=bar}}
   cmp.get("self"); // result = {foo=bar}
 
```
NBTCompound can not contain empty keys or values (null)
NBTCompound can not contain cross-references.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class NBTCompound.NBTEntrySet

class NBTCompound.NBTValues
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Nested Classes
Modifier and Type	Class and Description
`class`	`NBTCompound.NBTEntrySet`
`class`	`NBTCompound.NBTValues`

Constructor Summary

Constructors
Constructor and Description

NBTCompound()
Create new empty NBTCompound

NBTCompound(Map map)
Convert java Map to NBTCompound.

Constructors
Constructor and Description
`NBTCompound()` Create new empty NBTCompound
`NBTCompound(Map map)` Convert java `Map` to NBTCompound.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Object`	`bind(String key, NBTCompound value)` Put NBTCompound to handle without using cloning.
`Object`	`bind(String key, NBTList value)` Put NBTList to handle without using cloning.
`void`	`clear()`
`NBTCompound`	`clone()` Create clone of this NBT compouns
`NBTCompound`	`compound(String key)` Get NBTCompound or create new one Example: NBTCompound cmp = new NBTCompound().compound("display").list("Lore").add("lore1"); // cmp = {display:{Lore:["lore1"]}}
`boolean`	`containsKey(Object key)`
`boolean`	`containsKey(String key, byte type)` Check if compound contains key with value of specific type
`boolean`	`containsKey(String key, Class type)` Check if compound contains key with value of specific type
`boolean`	`containsValue(Object value)`
`NBTCompound.NBTEntrySet`	`entrySet()`
`boolean`	`equals(Object t)`
`static NBTCompound`	`forNBT(Object tag)` Create new instance of NBTCompound by NBTTagCompound
`static NBTCompound`	`forNBTCopy(Object tag)` Create new instance NBTCompound by copy of NBTTagCompound
`Object`	`get(Object key)`
`boolean`	`getBoolean(String key)` Try to get value and convert to boolean
`byte`	`getByte(String key)` Try to get byte value or convert to byte
`byte[]`	`getByteArray(String key)` Try to get byte[]
`NBTCompound`	`getCompound(String key)` Try to get NBTCompound
`double`	`getDouble(String key)` Try to get double value or convert to double
`float`	`getFloat(String key)` Try to get float value or convert to float
`Object`	`getHandle()` Get original NBTTagCompound.
`Object`	`getHandleCopy()` Get copy of original NBTTagCompound.
`Map<String,Object>`	`getHandleMap()` get Map stored in original NBTTagCompound.
`int`	`getInt(String key)` Try to get int value or convert to int
`int[]`	`getIntArray(String key)` Try to get int[]
`NBTList`	`getList(String key)` Try to get NBTList
`long`	`getLong(String key)` Try to get long value or convert to long
`short`	`getShort(String key)` Try to get short value or convert to short
`String`	`getString(String key)` Try to get string value or convert string
`boolean`	`isEmpty()`
`Set<String>`	`keySet()`
`NBTList`	`list(String key)` get NBTList or create new one Example: NBTCompound cmp = new NBTCompound().compound("display").list("Lore").add("lore1"); // cmp = {display:{Lore:["lore1"]}}
`void`	`merge(Map map)` Merge this compound with map.
`Object`	`put(String key, Object value)` Put the `copy` of value to NBTTagCompound
`void`	`putAll(Map<? extends String,?> map)` Copies all of the mappings from the map to this NBTTagCompound
`Object`	`remove(Object key)`
`int`	`size()`
`HashMap<String,Object>`	`toHashMap()` Convert nbt compound to `HashMap`
`<T extends Map<String,Object>> T`	`toMap(T map)` Convert NBT compound to java `Map`
`String`	`toString()`
`Collection<Object>`	`values()`

Methods inherited from class java.lang.Object
getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

- Constructor Detail
  - NBTCompound
```
public NBTCompound()
```
    Create new empty NBTCompound
  - NBTCompound
```
public NBTCompound(Map map)
```
    Convert java Map to NBTCompound.
    map should not contain cross-references!
    
    Parameters:
    
    map - map to convert
- Method Detail
  - forNBT
```
public static NBTCompound forNBT(Object tag)
```
    Create new instance of NBTCompound by NBTTagCompound
    
    Parameters:
    
    tag - instance of net.minecraft.server.NBTTagCompound
    
    Returns:
    
    NBTCompound
  - forNBTCopy
```
public static NBTCompound forNBTCopy(Object tag)
```
    Create new instance NBTCompound by copy of NBTTagCompound
    
    Parameters:
    
    tag - instance of net.minecraft.server.NBTTagCompound
    
    Returns:
    
    NBTCompound
  - toMap
```
public <T extends Map<String,Object>> T toMap(T map)
```
    Convert NBT compound to java Map
    
    Type Parameters:
    
    T - T
    
    Parameters:
    
    map - Empty map to fill
    
    Returns:
    
    map
  - toHashMap
```
public HashMap<String,Object> toHashMap()
```
    Convert nbt compound to HashMap
    
    Returns:
    
    HashMap
  - getHandle
```
public Object getHandle()
```
    Get original NBTTagCompound.
    
    Returns:
    
    NBTTagCompound
  - getHandleCopy
```
public Object getHandleCopy()
```
    Get copy of original NBTTagCompound.
    
    Returns:
    
    NBTTagCompound
  - getHandleMap
```
public Map<String,Object> getHandleMap()
```
    get Map stored in original NBTTagCompound.
    
    Returns:
    
    Map
  - equals
```
public boolean equals(Object t)
```
    Specified by:
    
    equals in interface Map<String,Object>
    
    Overrides:
    
    equals in class Object
  - clone
```
public NBTCompound clone()
```
    Create clone of this NBT compouns
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    cloned NBTCompound
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<String,Object>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<String,Object>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<String,Object>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<String,Object>
  - get
```
public Object get(Object key)
```
    Specified by:
    
    get in interface Map<String,Object>
  - put
```
public Object put(String key,
                  Object value)
```
    Put the copy of value to NBTTagCompound
    
    Specified by:
    
    put in interface Map<String,Object>
    
    Parameters:
    
    key - Key with which the value is to be associated
    
    value - Value to be associated with the specified key
    
    Returns:
    
    The copy of previous value associated with key
  - remove
```
public Object remove(Object key)
```
    Specified by:
    
    remove in interface Map<String,Object>
  - putAll
```
public void putAll(Map<? extends String,?> map)
```
    Copies all of the mappings from the map to this NBTTagCompound
    
    Specified by:
    
    putAll in interface Map<String,Object>
    
    Parameters:
    
    map - Mappings to be stored in this map
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<String,Object>
  - keySet
```
public Set<String> keySet()
```
    Specified by:
    
    keySet in interface Map<String,Object>
  - values
```
public Collection<Object> values()
```
    Specified by:
    
    values in interface Map<String,Object>
  - entrySet
```
public NBTCompound.NBTEntrySet entrySet()
```
    Specified by:
    
    entrySet in interface Map<String,Object>
  - merge
```
public void merge(Map map)
```
    Merge this compound with map.
    Merging occurs recursively for inner maps
    
    Parameters:
    
    map - map to merge
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getBoolean
```
public boolean getBoolean(String key)
```
    Try to get value and convert to boolean
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, false by default
  - getByte
```
public byte getByte(String key)
```
    Try to get byte value or convert to byte
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getShort
```
public short getShort(String key)
```
    Try to get short value or convert to short
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getInt
```
public int getInt(String key)
```
    Try to get int value or convert to int
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getLong
```
public long getLong(String key)
```
    Try to get long value or convert to long
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getFloat
```
public float getFloat(String key)
```
    Try to get float value or convert to float
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getDouble
```
public double getDouble(String key)
```
    Try to get double value or convert to double
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, 0 by default
  - getString
```
public String getString(String key)
```
    Try to get string value or convert string
    
    Parameters:
    
    key - key
    
    Returns:
    
    value, empty string by default
  - getIntArray
```
public int[] getIntArray(String key)
```
    Try to get int[]
    
    Parameters:
    
    key - key
    
    Returns:
    
    array, empty array by default
  - getByteArray
```
public byte[] getByteArray(String key)
```
    Try to get byte[]
    
    Parameters:
    
    key - key
    
    Returns:
    
    array, empty array by default
  - getCompound
```
public NBTCompound getCompound(String key)
```
    Try to get NBTCompound
    
    Parameters:
    
    key - key
    
    Returns:
    
    NBTCompound value, or null if there is no compound
  - getList
```
public NBTList getList(String key)
```
    Try to get NBTList
    
    Parameters:
    
    key - key
    
    Returns:
    
    NBTList value, or null if there is no list
  - compound
```
public NBTCompound compound(String key)
```
    Get NBTCompound or create new one
    Example:
```
     NBTCompound cmp = new NBTCompound().compound("display").list("Lore").add("lore1");
     // cmp = {display:{Lore:["lore1"]}}
 
```
    Parameters:
    
    key - Key
    
    Returns:
    
    Existing or created compound
  - list
```
public NBTList list(String key)
```
    get NBTList or create new one
    Example:
```
     NBTCompound cmp = new NBTCompound().compound("display").list("Lore").add("lore1");
     // cmp = {display:{Lore:["lore1"]}}
 
```
    Parameters:
    
    key - Key
    
    Returns:
    
    Existing or created list
  - bind
```
public Object bind(String key,
                   NBTCompound value)
```
    Put NBTCompound to handle without using cloning.
    Be sure that you do not have cross-reference.
    Do not bind NBTCompound to itself!
    
    Parameters:
    
    key - key with which the NBTCompound is to be associated
    
    value - NBTCompound to be associated with key
    
    Returns:
    
    the previous value associated with key
  - bind
```
public Object bind(String key,
                   NBTList value)
```
    Put NBTList to handle without using cloning.
    Be sure that you do not have cross-reference.
    
    Parameters:
    
    key - Key with which the NBTList is to be associated
    
    value - NBTList to be associated with key
    
    Returns:
    
    the previous value associated with key
  - containsKey
```
public boolean containsKey(String key,
                           Class type)
```
    Check if compound contains key with value of specific type
    
    Parameters:
    
    key - key
    
    type - type of value
    
    Returns:
    
    true if compound has key with specific value
  - containsKey
```
public boolean containsKey(String key,
                           byte type)
```
    Check if compound contains key with value of specific type
    
    Parameters:
    
    key - key
    
    type - byte type of NBT tag
    
    Returns:
    
    true if compound has key with specific value

Class NBTCompound

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

NBTCompound

NBTCompound

Method Detail

forNBT

forNBTCopy

toMap

toHashMap

getHandle

getHandleCopy

getHandleMap

equals

clone

size

isEmpty

containsKey

containsValue

get

put

remove

putAll

clear

keySet

values

entrySet

merge

toString

getBoolean

getByte

getShort

getInt

getLong

getFloat

getDouble

getString

getIntArray

getByteArray

getCompound

getList

compound

list

bind

bind

containsKey

containsKey