Package net.neoforged.neoforge.transfer

Class ItemAccessResourceHandler<T extends Resource>

java.lang.Object
net.neoforged.neoforge.transfer.ItemAccessResourceHandler<T>
Type Parameters:
T - The type of resource this handler manages.
All Implemented Interfaces:
ResourceHandler<T>
Direct Known Subclasses:
BucketResourceHandler, ItemAccessFluidHandler, ItemAccessItemHandler
public abstract class ItemAccessResourceHandler<T extends Resource> extends Object implements ResourceHandler<T>
Base implementation of a ResourceHandler backed by an ItemAccess. This implementation is generic in the type of transferred resources T, and in how they are ultimately stored in the item access.

As a result of this flexibility, this base implementation comes with the following methods that will typically be overridden:

  • Field Details

    • itemAccess

      protected final ItemAccess itemAccess

    • size

      protected final int size

  • Constructor Details

    • ItemAccessResourceHandler

      protected ItemAccessResourceHandler(ItemAccess itemAccess, int size)

  • Method Details

    • getResourceFrom

      protected abstract T getResourceFrom(ItemResource accessResource, int index)
      Retrieves the resource stored in the current contents of the item access.

    • getAmountFrom

      protected abstract int getAmountFrom(ItemResource accessResource, int index)
      Retrieves the amount stored in the current contents of the item access.
      See Also:

    • update

      protected abstract ItemResource update(ItemResource accessResource, int index, T newResource, int newAmount)
      Returns a resource with updated resource and amount.
      Parameters:
      accessResource - current resource, before the update
      index - the index at which the resource and amount should be updated
      newResource - the new resource, never empty: empty is indicated by a 0 amount
      newAmount - the new amount
      Returns:
      accessResource updated with the new resource and amount, or ItemResource.EMPTY if the new resource or amount cannot be stored

    • isValid

      public boolean isValid(int index, T resource)
      Return true if the passed non-empty resource can fit in this handler, false otherwise.

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

      Specified by:
      isValid in interface ResourceHandler<T extends Resource>
      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
      See Also:

    • getCapacity

      protected abstract int getCapacity(int index, T resource)
      Return the maximum capacity of this handler for the passed resource. If the passed resource is empty, an estimate should be returned.
      Returns:
      The maximum capacity of this handler for the passed resource.
      See Also:

    • size

      public 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<T extends Resource>
      Returns:
      The size of the resource handler. Can be 0 if the handler currently has no indices.

    • getResource

      public T 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<T extends Resource>
      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<T extends Resource>
      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, T 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<T extends Resource>
      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:

    • insert

      public int insert(int index, T 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<T extends Resource>
      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, T 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<T extends Resource>
      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: