Inventory (SpongeAPI 7.3.0 API)

All Superinterfaces:

Iterable<Inventory>, Nameable

All Known Subinterfaces:

CarriedInventory<C>, ChestMinecart, Container, ContainerMinecart<M>, CraftingGridInventory, CraftingInventory, CraftingOutput, EmptyInventory, EquipmentInventory, EquipmentSlot, FilteringSlot, FuelSlot, GridInventory, HopperMinecart, Hotbar, InputSlot, Interactable, Inventory2D, InventoryColumn, InventoryRow, MainPlayerInventory, OrderedInventory, OutputSlot, PersistentInventory, PlayerInventory, SidedSlot, Slot, TileEntityInventory<T>, UserInventory<T>
```
public interface Inventory
extends Iterable<Inventory>, Nameable
```
Base interface for queryable inventories.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface Inventory.Builder
A Builder for Inventories based on InventoryArchetypes.

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Inventory.Builder` A Builder for Inventories based on `InventoryArchetype`s.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`static Inventory.Builder`	`builder()` Creates a new `Inventory.Builder` to build an `Inventory`.
`boolean`	`canFit(ItemStack stack)` Returns true if the entire stack can fit in this inventory.
`int`	`capacity()` The maximum number of stacks the Inventory can hold.
`void`	`clear()` Clears this inventory if it is clearable.
`boolean`	`contains(ItemStack stack)` Checks whether the stacks quantity or more of given stack is contained in this Inventory.
`boolean`	`contains(ItemType type)` Checks for whether there is a stack in this Inventory with the given ItemType.
`boolean`	`containsAny(ItemStack stack)` Checks whether the given stack is contained in this Inventory.
`boolean`	`containsInventory(Inventory inventory)` Returns true if the given inventory is a descendant of this one.
`<T extends Inventory> T`	`first()` Return the first child inventory, effectively the same as `Inventory::iterator().next()` but more convenient when we are expecting a result set with only a single entry.
`InventoryArchetype`	`getArchetype()` Creates an `InventoryArchetype` based on this `Inventory`.
`<T extends InventoryProperty<?,?>> Optional<T>`	`getInventoryProperty(Class<T> property)` Gets a property with the default key defined directly on this Inventory if one is defined.
`<T extends InventoryProperty<?,?>> Optional<T>`	`getInventoryProperty(Inventory child, Class<T> property)` Gets the property with the default key defined in this inventory for the specified (immediate) sub-inventory.
`int`	`getMaxStackSize()` Returns the maximum size of any stack in this Inventory.
`PluginContainer`	`getPlugin()` Returns the `PluginContainer` who built this inventory.
`<T extends InventoryProperty<?,?>> Collection<T>`	`getProperties(Class<T> property)` Gets all properties of the specified type defined directly on this Inventory.
`<T extends InventoryProperty<?,?>> Collection<T>`	`getProperties(Inventory child, Class<T> property)` Returns all properties matching the supplied type defined in this inventory for the specified (immediate) sub-inventory.
`<T extends InventoryProperty<?,?>> Optional<T>`	`getProperty(Class<T> property, Object key)` Gets a property with the specified key defined directly on this Inventory if one is defined.
`<T extends InventoryProperty<?,?>> Optional<T>`	`getProperty(Inventory child, Class<T> property, Object key)` Gets the property with the specified key defined in this inventory for the specified (immediate) sub-inventory.
`boolean`	`hasChildren()` Returns true if this Inventory contains children.
`Inventory`	`intersect(Inventory inventory)` Intersects the slots of both inventories.
`<T extends Inventory> T`	`next()` Return the next sibling inventory, allows traversing the inventory hierarchy without using an iterator.
`InventoryTransactionResult`	`offer(ItemStack stack)` Try to put an ItemStack into this Inventory.
`Inventory`	`parent()` Gets the parent `Inventory` of this `Inventory`.
`Optional<ItemStack>`	`peek()` Gets without removing the first available stack from this Inventory.
`Optional<ItemStack>`	`peek(int limit)` Uses the same semantics as `poll(int)` but does not remove the items from the inventory.
`Optional<ItemStack>`	`poll()` Gets and remove the first available stack from this Inventory.
`Optional<ItemStack>`	`poll(int limit)` Get and remove up to `limit` items of the type in the first available stack in this Inventory from all stacks in this Inventory.
`default <T extends Inventory> T`	`query(Class<?>... types)` Deprecated. use `query(QueryOperation...)` instead
`default <T extends Inventory> T`	`query(InventoryProperty<?,?>... props)` Deprecated. use `query(QueryOperation...)` instead
`default <T extends Inventory> T`	`query(ItemStack... types)` Deprecated. use `query(QueryOperation...)` instead
`default <T extends Inventory> T`	`query(ItemType... types)` Deprecated. use `query(QueryOperation...)` instead
`default <T extends Inventory> T`	`query(Object... args)` Deprecated. use `instead`
`<T extends Inventory> T`	`query(QueryOperation<?>... operations)` Query this inventory for inventories matching any of the supplied queries.
`default <T extends Inventory> T`	`query(Translation... names)` Deprecated. use `instead`
`default <T extends Inventory> T`	`queryAny(ItemStack... types)` Deprecated. use `query(QueryOperation...)` instead
`Inventory`	`root()` Gets the root `Inventory` of this `Inventory`.
`InventoryTransactionResult`	`set(ItemStack stack)` Forcibly put the supplied stack into this inventory.
`void`	`setMaxStackSize(int size)` Sets the maximum stack size of any stack in this ItemList.
`int`	`size()` The number of non-empty slots in the Inventory.
`<T extends Inventory> Iterable<T>`	`slots()` Returns an iterable view of all `Slot`s (leaf nodes) in this Inventory.
`int`	`totalItems()` Returns the number total number of individual items in this inventory.
`default Inventory`	`transform(InventoryTransformation transformation)` Transforms this inventory using the given transformation.
`Inventory`	`union(Inventory inventory)` Constructs a union of the slots in both inventories.

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

Methods inherited from interface org.spongepowered.api.Nameable
getName

- Method Detail
  - builder
```
static Inventory.Builder builder()
```
    Creates a new Inventory.Builder to build an Inventory.
    
    Returns:
    
    The builder
  - parent
```
Inventory parent()
```
    Gets the parent Inventory of this Inventory.
    
    Returns:
    
    the parent inventory, returns this inventory if there is no parent (this is a top-level inventory)
  - root
```
Inventory root()
```
    Gets the root Inventory of this Inventory. This is equivalent to calling parent() until it returns itself.
    
    Returns:
    
    the root inventory, returns this inventory if there is no parent (this is a top-level inventory)
  - slots
```
<T extends Inventory> Iterable<T> slots()
```
    Returns an iterable view of all Slots (leaf nodes) in this Inventory.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Returns:
    
    an iterable view of all Slots (leaf nodes) in this inventory
  - first
```
<T extends Inventory> T first()
```
    Return the first child inventory, effectively the same as Inventory::iterator().next() but more convenient when we are expecting a result set with only a single entry. Also use type specifier to allow easy pseudo-duck-typing. If no children, then returns this.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Returns:
    
    the first child inventory, if there are no children then simply returns this
  - next
```
<T extends Inventory> T next()
```
    Return the next sibling inventory, allows traversing the inventory hierarchy without using an iterator. If no more siblings, returns an EmptyInventory.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Returns:
    
    the next sibling inventory, or an EmptyInventory if there are no further siblings
  - poll
```
Optional<ItemStack> poll()
```
    Gets and remove the first available stack from this Inventory.
    'Available' has a different meaning for different inventory types. In a single-slot inventory this has a fixed implication. However larger and more complex inventories are at liberty to implement whatever logic they wish to back this method. If an inventory cannot provide a meaningful implementation of this method then it should return Optional.empty() instead.
    
    For consumers, this means that just because an inventory doesn't return anything here, this does not imply that the inventory is empty, just that a more specific query is required to obtain items from it.
    
    Returns:
    
    The first available item stack, or Optional.empty() if unavailable or unsupported
  - poll
```
Optional<ItemStack> poll(int limit)
```
    Get and remove up to limit items of the type in the first available stack in this Inventory from all stacks in this Inventory. If no stack is available then Optional.empty() is returned (as per the usual behaviour of poll(), otherwise a new ItemStack is returned containing the removed items, the contents of the stack in the inventory are reduced by the number of items consumed. Note that this method attempts to consume items into the output up to limit, which may consume items from an arbitrary number of internal slots.
    
    For example, assume an inventory containing 4 slots contains stacks as follows:
    [Stone x10] [Dirt x3] [Arrows x9] [Stone x32]
    Calling poll(16) on this inventory will consume Stone from the Inventory (because the first stack contains stone), and will then consume the remaining 6 items from the 4th slot.
    
    It is intended that this method is used in conjunction with a query which returns a set of slots containing a specific item type:
    Optional<ItemStack> q = inv.query(ItemTypes.DIRT).poll(1);
    Parameters:
    
    limit - Maximum number of items to consume from the inventory
    
    Returns:
    
    Matching ItemStack guaranteed to have items less than or equal to the specified limit.
    
    See Also:
    
    poll()
  - peek
```
Optional<ItemStack> peek()
```
    Gets without removing the first available stack from this Inventory. For the definition of 'available', see poll().
    
    Returns:
    
    First available itemstack, or Optional.empty() if unavailable or unsupported
  - peek
```
Optional<ItemStack> peek(int limit)
```
    Uses the same semantics as poll(int) but does not remove the items from the inventory. The ItemStack returned is thus a new ItemStack containing a copy of the items in inventory. Use this method only if you wish to determine whether a call to poll(int) is likely to succeed.
    
    Parameters:
    
    limit - Maximum number of items to consume from the inventory
    
    Returns:
    
    Matching ItemStack guaranteed to have items less than or equal to the specified limit.
    
    See Also:
    
    peek()
  - offer
```
InventoryTransactionResult offer(ItemStack stack)
```
    Try to put an ItemStack into this Inventory. Just like Queue, this method returns true if the Inventory accepted the stack and false if not, the size of the supplied stack is reduced by the number of items successfully consumed by the Inventory.
    Unlike set(org.spongepowered.api.item.inventory.ItemStack), this method's general contract does not permit items in the Inventory to be replaced. However trying to insert items that an Inventory cannot accept is not an error condition, the size of the supplied stack will simply not be reduced if no items are consumed by the Inventory.
    
    Parameters:
    
    stack - A stack of items to attempt to insert into the Inventory, note that upon successful insertion the supplied ItemStack itself will be mutated and returned with size reduced by the number of items successfully consumed by the Inventory
    
    Returns:
    
    true if one or more (up to the total number of items in the supplied stack) items were consumed. False if no items were consumed by the target inventory.
  - canFit
```
boolean canFit(ItemStack stack)
```
    Returns true if the entire stack can fit in this inventory.
    If this returns true offer(ItemStack) should always succeed.
    
    Parameters:
    
    stack - The stack of items to check if it can fit in this inventory.
    
    Returns:
    
    true if the entire stack can fit in this inventory.
  - set
```
InventoryTransactionResult set(ItemStack stack)
```
    Forcibly put the supplied stack into this inventory. Overwrites existing objects in the inventory as required to accommodate the entire stack. The entire stack is always consumed.
    The general contract of this method is to prioritise insertion of the supplied items over items already in the Inventory. However the Inventory may still reject the supplied items if they are of an unsupported type for the target (for example trying to insert non-fuel items into a fuel slot) or if the number of items is larger than the total capacity of the inventory and not all items from the supplied stack can be consumed.
    
    For Slots, the supplied stack is generally consumed and the existing contents ejected (at the discretion of the target Inventory). For multi-slot inventories the insertion order is up to the target inventory to decide, and does not have to match the traversal order of the leaf nodes as supplied by slots(), although this is generally recommended. Inventories should document their specific insertion logic where the insertion order differs from the traversal order.
    
    Consumers should inspect the returned InventoryTransactionResult and act accordingly. Ejected items should generally be "thrown" into the world or deposited into another Inventory (depending on the operation in question. The supplied stack is not adjusted, any rejected items are returned in the operation result struct.
    
    Parameters:
    
    stack - the stack to insert into the Inventory, will be mutated by the number of items successfully consumed
    
    Returns:
    
    operation result indicating the success state of the operation and any items rejected or ejected as a result of the operation
  - clear
```
void clear()
```
    Clears this inventory if it is clearable.
  - size
```
int size()
```
    The number of non-empty slots in the Inventory. Either 1 or 0 for Slots and always 0 for EmptyInventorys.
    
    Returns:
    
    the number non-empty in the inventory
  - totalItems
```
int totalItems()
```
    Returns the number total number of individual items in this inventory.
    This equivalent to counting up the stack sizes of all slots.
    
    Returns:
    
    the total number of items in the inventory
  - capacity
```
int capacity()
```
    The maximum number of stacks the Inventory can hold. Always 1 for Slots and always 0 for EmptyInventorys.
    
    Returns:
    
    the number of stacks the inventory can hold
  - hasChildren
```
boolean hasChildren()
```
    Returns true if this Inventory contains children. If false, this does not imply that the Inventory accepts no items, and an Inventory is perfectly at liberty to provide peek(), poll(), offer(org.spongepowered.api.item.inventory.ItemStack) and set(org.spongepowered.api.item.inventory.ItemStack) semantics even if it has no internal storage of its own.
    
    Returns:
    
    true if and only if this inventory contains child inventories
  - contains
```
boolean contains(ItemStack stack)
```
    Checks whether the stacks quantity or more of given stack is contained in this Inventory. This is equivalent to calling !inv.query(stack).hasChildren(); To check if an inventory contains any amount use containsAny(ItemStack).
    
    Parameters:
    
    stack - The stack to check for
    
    Returns:
    
    True if there are at least the given stack's amount of items present in this inventory.
  - contains
```
boolean contains(ItemType type)
```
    Checks for whether there is a stack in this Inventory with the given ItemType. This is equivalent to calling !inv.query(stack) .hasChildren();
    
    Parameters:
    
    type - The type to search for
    
    Returns:
    
    True if at least one stack in this list has the given type
  - containsAny
```
boolean containsAny(ItemStack stack)
```
    Checks whether the given stack is contained in this Inventory. The stack size is ignored. Note this will return true if any amount of the supplied stack is found. To check if an inventory contains at least an amount use contains(ItemStack).
    
    Parameters:
    
    stack - The stack to check for
    
    Returns:
    
    True if the stack is present in this inventory
  - getMaxStackSize
```
int getMaxStackSize()
```
    Returns the maximum size of any stack in this Inventory.
    
    Returns:
    
    The maximum stack size of this list
  - setMaxStackSize
```
void setMaxStackSize(int size)
```
    Sets the maximum stack size of any stack in this ItemList.
    
    Parameters:
    
    size - The new maximum stack size
  - getProperties
```
<T extends InventoryProperty<?,?>> Collection<T> getProperties(Inventory child,
                                                               Class<T> property)
```
    Returns all properties matching the supplied type defined in this inventory for the specified (immediate) sub-inventory. If no matching properties are defined an empty collection is returned.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    child - the child inventory to inspect
    
    property - the type of property to query for
    
    Returns:
    
    collection of matching properties, may be an empty collection if no properties match the supplied criterion
  - getProperties
```
<T extends InventoryProperty<?,?>> Collection<T> getProperties(Class<T> property)
```
    Gets all properties of the specified type defined directly on this Inventory. For sub-inventories this is effectively the same as inv.getParent().getProperty(inv, property); but for top-level inventories may include properties defined on the inventory directly.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    property - the type of property to query for
    
    Returns:
    
    collection of matching properties, may be an empty collection if no properties match the supplied criterion
  - getProperty
```
<T extends InventoryProperty<?,?>> Optional<T> getProperty(Inventory child,
                                                           Class<T> property,
                                                           Object key)
```
    Gets the property with the specified key defined in this inventory for the specified (immediate) sub-inventory.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    child - the child inventory to inspect
    
    property - the type of property to query for
    
    key - Property key to search for
    
    Returns:
    
    matching properties, may be absent if no property matched the supplied criteria
  - getProperty
```
<T extends InventoryProperty<?,?>> Optional<T> getProperty(Class<T> property,
                                                           Object key)
```
    Gets a property with the specified key defined directly on this Inventory if one is defined. For sub-inventories this is effectively the same as inv.getParent().getProperty(inv, property, key); but for top-level inventories may include properties defined on the inventory directly.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    property - the type of property to query for
    
    key - Property key to search for
    
    Returns:
    
    matching properties, may be absent if no property matched the supplied criteria
  - getInventoryProperty
```
<T extends InventoryProperty<?,?>> Optional<T> getInventoryProperty(Inventory child,
                                                                    Class<T> property)
```
    Gets the property with the default key defined in this inventory for the specified (immediate) sub-inventory.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    child - the child inventory to inspect
    
    property - the type of property to query for
    
    Returns:
    
    matching properties, may be absent if no property matched the supplied criteria
  - getInventoryProperty
```
<T extends InventoryProperty<?,?>> Optional<T> getInventoryProperty(Class<T> property)
```
    Gets a property with the default key defined directly on this Inventory if one is defined. For sub-inventories this is effectively the same as inv.getParent().getProperty(inv, property); but for top-level inventories may include properties defined on the inventory directly.
    
    Type Parameters:
    
    T - expected type of inventory property, generic to enable easy pseudo-duck-typing
    
    Parameters:
    
    property - the type of property to query for
    
    Returns:
    
    matching properties, may be absent if no property matched the supplied criteria
  - query
```
@Deprecated
default <T extends Inventory> T query(Class<?>... types)
```
    Deprecated. use query(QueryOperation...) instead
    
    Query this inventory for inventories matching any of the supplied types. This is effectively an instanceof check against each child inventory. Logical OR is applied between operands.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    types - inventory types (interfaces or classes) to query for
    
    Returns:
    
    the query result
  - query
```
@Deprecated
default <T extends Inventory> T query(ItemType... types)
```
    Deprecated. use query(QueryOperation...) instead
    
    Query this inventory for inventories containing any of the supplied item types. This query operates directly on Slot leaf nodes in the inventory and will always return a collection containing only Slot instances. Logical OR is applied between operands.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    types - item types to query for
    
    Returns:
    
    the query result
  - query
```
@Deprecated
default <T extends Inventory> T query(ItemStack... types)
```
    Deprecated. use query(QueryOperation...) instead
    
    Query this inventory for inventories containing stacks which match the supplied stack operand. This query operates directly on Slot leaf nodes in the inventory and will always return a collection containing only Slot instances. To query for stacks of any size use queryAny(ItemStack...).
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    types - items to query for, stack sizes must match the supplied stack exactly
    
    Returns:
    
    the query result
  - query
```
@Deprecated
default <T extends Inventory> T query(InventoryProperty<?,?>... props)
```
    Deprecated. use query(QueryOperation...) instead
    
    Query this inventory for inventories which match any of the supplied properties. The equals method of each property is called on each child inventory which has the supplied property. Logical OR is applied between operands. This method is effectively the same as calling query(java.lang.Class<?>...) with an Property.Operator of Property.Operator.EQUAL.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    props - inventory properties to query for
    
    Returns:
    
    the query result
  - query
```
@Deprecated
default <T extends Inventory> T query(Translation... names)
```
    Deprecated. use instead
    
    Query this inventory for inventories matching any of the supplied titles. Logical OR is applied between operands.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    names - the names of the inventories to search for
    
    Returns:
    
    the query result
  - query
```
@Deprecated
default <T extends Inventory> T query(Object... args)
```
    Deprecated. use instead
    
    Query this inventory by dynamically inspecting each operand. Each operand in turn is checked for a match against the other query methods, and if a matching method is found the query is performed using the operand. This is repeated until all operands are consumed and allows a union of multiple query types to be aggregated into a single view.
    
    For operands with no matching type, the behaviour is determined by the individual inventory. A naive match may be obtained by calling .equals() against the child inventory passing the unknown operand as an argument.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    args - search parameters
    
    Returns:
    
    the query result
  - queryAny
```
@Deprecated
default <T extends Inventory> T queryAny(ItemStack... types)
```
    Deprecated. use query(QueryOperation...) instead
    
    Query this inventory for inventories containing any stacks which match the supplied stack operands ignoring its quantity. This query operates directly on Slot leaf nodes in the inventory and will always return a collection containing only Slot instances. Logical OR is applied between operands. This ignores stack sizes. To query for stacks of a specific size use query(ItemStack...).
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    types - items to query for, the size of the stacks is always ignored
    
    Returns:
    
    the query result
  - query
```
<T extends Inventory> T query(QueryOperation<?>... operations)
```
    Query this inventory for inventories matching any of the supplied queries. Logical OR is applied between operands.
    
    Type Parameters:
    
    T - expected inventory type, specified as generic to allow easy pseudo-duck-typing
    
    Parameters:
    
    operations - queries to check against
    
    Returns:
    
    the query result
  - getPlugin
```
PluginContainer getPlugin()
```
    Returns the PluginContainer who built this inventory.
    
    Returns:
    
    The container
  - getArchetype
```
InventoryArchetype getArchetype()
```
    Creates an InventoryArchetype based on this Inventory.
    
    Returns:
    
    The inventory archetype
  - intersect
```
Inventory intersect(Inventory inventory)
```
    Intersects the slots of both inventories. The resulting inventory will only contain slots that are present in both inventories.
    
    Parameters:
    
    inventory - the other inventory
    
    Returns:
    
    an inventory wrapping all slots that are present in both inventories
  - union
```
Inventory union(Inventory inventory)
```
    Constructs a union of the slots in both inventories.
    The resulting inventory will contain all slots from both inventories.
    
    The slots of this inventory are ordered before the slots of the given inventory.
    
    If the same slot is contained in both inventories the duplicate in the second one is removed.
    
    Parameters:
    
    inventory - the other inventory
    
    Returns:
    
    an inventory wrapping all slots of both inventories.
  - containsInventory
```
boolean containsInventory(Inventory inventory)
```
    Returns true if the given inventory is a descendant of this one. This method will check for deeply nested inventories but will only return true if the entire inventory structure is contained. This means that e.g. for a query result of multiple slots the inventory will not return true even if all slots are contained. If you want to check if all slots of an inventory are contained in another one use intersect(Inventory) instead.
    You can use this if you want to check if a single Slot is contained in an inventory or an entire row is contained in a Grid.
    
    Parameters:
    
    inventory - the other inventory
    
    Returns:
    
    whether the given inventory is contained in this one.
  - transform
```
default Inventory transform(InventoryTransformation transformation)
```
    Transforms this inventory using the given transformation.
    
    Parameters:
    
    transformation - The transformation
    
    Returns:
    
    The transformed Inventory

Interface Inventory

Nested Class Summary

Method Summary

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.spongepowered.api.Nameable

Method Detail

builder

parent

root

slots

first

next

poll

poll

peek

peek

offer

canFit

set

clear

size

totalItems

capacity

hasChildren

contains

contains

containsAny

getMaxStackSize

setMaxStackSize

getProperties

getProperties

getProperty

getProperty

getInventoryProperty

getInventoryProperty

query

query

query

query

query

query

queryAny

query

getPlugin

getArchetype

intersect

union

containsInventory

transform