Package net.neoforged.neoforge.transfer.item

Class ItemStackResourceHandler

java.lang.Object
net.neoforged.neoforge.transfer.transaction.SnapshotJournal<ItemStack>
net.neoforged.neoforge.transfer.item.ItemStackResourceHandler
All Implemented Interfaces:
ValueIOSerializable, ResourceHandler<ItemResource>
Direct Known Subclasses:
CarriedSlotWrapper, LivingEntityEquipmentWrapper.SlotWrapper, VanillaContainerWrapper.SlotWrapper
public abstract class ItemStackResourceHandler extends SnapshotJournal<ItemStack> implements ResourceHandler<ItemResource>, ValueIOSerializable
A single-index item resource handler, backed by an ItemStack. Implementors should at least override getStack() and setStack(net.minecraft.world.item.ItemStack), and probably SnapshotJournal.onRootCommit(T) as well for setChanged() and similar calls.

isValid(net.neoforged.neoforge.transfer.item.ItemResource) can be used for more precise control over which items may be stored. getCapacity(ItemResource) can be overridden to change the maximum capacity depending on the item resource.

  • Field Details

  • Constructor Details

    • ItemStackResourceHandler

      public ItemStackResourceHandler()

  • Method Details

    • getStack

      protected abstract ItemStack getStack()
      Return the stack of this handler. It will be modified directly sometimes to avoid needless copies. However, any mutation of the stack will directly be followed by a call to setStack(net.minecraft.world.item.ItemStack). This means that either returning the backing stack directly or a copy is safe. If returning a copy, consider overriding getAmountAsLong(int) and getResource(int) to avoid unnecessary copies.
      Returns:
      The current stack.

    • setStack

      protected abstract void setStack(ItemStack stack)
      Set the stack of this handler.

    • isValid

      protected boolean isValid(ItemResource resource)
      Return true if the passed non-empty item resource can fit in this handler, false otherwise.

      The result of this function is used in the provided implementations of:

    • getCapacity

      protected int getCapacity(ItemResource resource)
      Return the maximum capacity of this handler for the passed item resource. If the passed item resource is empty, an estimate should be returned.

      If the capacity should be limited by the max stack size of the item, this function must take it into account. Additionally, the empty resource should be special-cased to return the intended maximum capacity of the handler, as it will otherwise report a max stack size of 1. For example, a handler with a maximum count of 4, or less for items that have a smaller max stack size, should override this to return resource.isEmpty() ? 4 : Math.min(resource.getMaxStackSize(), 4).

      Returns:
      The maximum capacity of this handler for the passed item resource.

    • size

      public final int size()
      Description copied from interface: ResourceHandler
      Returns the current number of indices in this resource handler.

      This size provides a bound on the valid indices for this handler, see the documentation of ResourceHandler.

      Specified by:
      size in interface ResourceHandler<ItemResource>
      Returns:
      The size of the resource handler. Can be 0 if the handler currently has no indices.

    • insert

      public int insert(int index, ItemResource resource, int amount, TransactionContext transaction)
      Description copied from interface: ResourceHandler
      Inserts up to the given amount of a resource into the handler at the given index.

      Changes to the handler are made in the context of a transaction.

      Specified by:
      insert in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to insert the resource into.
      resource - The resource to insert. Must be non-empty.
      amount - The maximum amount of the resource to insert. Must be non-negative.
      transaction - The transaction that this operation is part of.
      Returns:
      The amount that was inserted. Between 0 (inclusive, nothing was inserted) and amount (inclusive, everything was inserted).
      See Also:

    • extract

      public int extract(int index, ItemResource resource, int amount, TransactionContext transaction)
      Description copied from interface: ResourceHandler
      Extracts up to the given amount of a resource from the handler at the given index.

      Changes to the handler are made in the context of a transaction.

      Specified by:
      extract in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to extract the resource from.
      resource - The resource to extract. Must be non-empty.
      amount - The maximum amount of the resource to extract. Must be non-negative.
      transaction - The transaction that this operation is part of.
      Returns:
      The amount that was extracted. Between 0 (inclusive, nothing was extracted) and amount (inclusive, everything was extracted).
      See Also:

    • getResource

      public ItemResource getResource(int index)
      Description copied from interface: ResourceHandler
      Returns the resource at the given index, which may be empty.

      If the resource is empty, the stored amount must be 0.

      Specified by:
      getResource in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to get the resource from.
      Returns:
      the resource at the given index, which may be empty

    • getAmountAsLong

      public long getAmountAsLong(int index)
      Description copied from interface: ResourceHandler
      Returns the amount of the currently stored resource at the given index, as a long.

      In general, resource handlers can report long amounts. However, if the handler is known to only support amounts up to Integer.MAX_VALUE, or if the caller prefers to deal in ints only, the int-returning overload can be used instead.

      The returned amount must be non-negative. If the stored resource is empty, the amount must be 0.

      Specified by:
      getAmountAsLong in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to get the amount from.
      Returns:
      the amount at the given index, as a long
      See Also:

    • getCapacityAsLong

      public long getCapacityAsLong(int index, ItemResource resource)
      Description copied from interface: ResourceHandler
      Returns the capacity of the handler at the given index and for the given resource, irrespective of the current amount or resource currently at that index, as a long.

      In general, resource handlers can report long capacities. However, if the handler is known to only support capacities up to Integer.MAX_VALUE, or if the caller prefers to deal in ints only, the int-returning overload can be used instead.

      This function serves as a hint on the maximum amount the resource handler might contain, for example the handler can be considered full if amount >= capacity. Note that the returned capacity may overestimate the actual allowed amount, and it might be smaller than the current amount. The only way to know if a handler will accept a resource, is to try to insert it.

      Specified by:
      getCapacityAsLong in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to get the capacity for.
      resource - The resource to get the capacity for. May be empty to get the general capacity at the index.
      Returns:
      the capacity at the given index, as a long
      See Also:

    • isValid

      public boolean isValid(int index, ItemResource resource)
      Description copied from interface: ResourceHandler
      Returns whether the given resource is generally allowed to be contained at the given index, irrespective of the current amount or resource currently at that index.

      This function serves as a hint on whether the resource handler can contain the resource or not. The only way to know if a handler will accept a resource, is to try to insert it.

      Specified by:
      isValid in interface ResourceHandler<ItemResource>
      Parameters:
      index - The index to check.
      resource - The resource to check. Must be non-empty.
      Returns:
      whether the given resource is generally allowed to be contained at the given index, irrespective of the current amount or resource currently at that index

    • createSnapshot

      protected ItemStack createSnapshot()
      Description copied from class: SnapshotJournal
      Return a new nonnull object containing the current state of this journal. null may not be returned, or an exception will be thrown!
      Specified by:
      createSnapshot in class SnapshotJournal<ItemStack>

    • revertToSnapshot

      protected void revertToSnapshot(ItemStack snapshot)
      Description copied from class: SnapshotJournal
      Roll back to a state previously created by SnapshotJournal.createSnapshot().
      Specified by:
      revertToSnapshot in class SnapshotJournal<ItemStack>

    • serialize

      public void serialize(ValueOutput output)
      Specified by:
      serialize in interface ValueIOSerializable

    • deserialize

      public void deserialize(ValueInput input)
      Specified by:
      deserialize in interface ValueIOSerializable

    • toString

      public String toString()
      Overrides:
      toString in class Object