Package net.neoforged.neoforge.transfer

Class StacksResourceHandler<S,T extends Resource>

java.lang.Object
net.neoforged.neoforge.transfer.StacksResourceHandler<S,T>
Type Parameters:
S - The type of stack used to store the contents of this handler.
T - The type of resource this handler manages.
All Implemented Interfaces:
ValueIOSerializable, ResourceHandler<T>
Direct Known Subclasses:
FluidStacksResourceHandler, ItemStacksResourceHandler, ResourceStacksResourceHandler
public abstract class StacksResourceHandler<S,T extends Resource> extends Object implements ResourceHandler<T>, ValueIOSerializable
Base implementation of a ResourceHandler backed by a list of stacks. This implementation is generic in the type of transferred resources T, and in the type of stack S used to store the contents of the handler.

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

See Also:

  • Field Details

  • Constructor Details

    • StacksResourceHandler

      protected StacksResourceHandler(int size, S emptyStack, com.mojang.serialization.Codec<S> stackCodec)

    • StacksResourceHandler

      protected StacksResourceHandler(NonNullList<S> stacks, S emptyStack, com.mojang.serialization.Codec<S> stackCodec)

  • Method Details

    • mutableCopyOf

      private NonNullList<S> mutableCopyOf(Collection<S> list)
      Creates a NonNullList that is a fixed-size mutable copy of the given collection.

    • setStacks

      protected void setStacks(NonNullList<S> stacks)
      Changes the list of stacks. Can change the size of the handler.
      Parameters:
      stacks - The new list of stacks. A shallow copy will be made.

    • updateStacksSize

      private void updateStacksSize()

    • serialize

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

    • deserialize

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

    • set

      public void set(int index, T resource, int amount)
      Directly overwrites the contents of the handler.

      Note that this method can be used as an IndexModifier, for usage in ResourceHandlerSlot.

      Parameters:
      index - index to change
      resource - new resource at the index
      amount - new amount at the index
      Throws:
      IllegalArgumentException - if either the amount is negative; or if the resource is non-empty for a 0 amount

    • getResourceFrom

      protected abstract T getResourceFrom(S stack)
      Retrieves the resource from a stack. In the case of an ItemStack an ItemResource would be returned for example.

    • getAmountFrom

      protected abstract int getAmountFrom(S stack)
      Retrieves the amount from a stack. In the case of an ItemStack the count would be returned for example.

    • getStackFrom

      protected abstract S getStackFrom(T resource, int amount)
      Creates a stack from a resource and an amount.

      If the stack would be empty, consider returning emptyStack instead of creating a new empty stack instance.

    • copyOf

      protected abstract S copyOf(S stack)
      Creates a copy of a stack, for use as a snapshot.

      If using an immutable stack type such as ResourceStack, it can be returned as is. In the case of a mutable stack type such as an item or fluid stack, a copy should be returned.

    • matches

      protected boolean matches(S stack, T resource)
      Checks if the passed resource corresponds to the stack.
      Parameters:
      stack - the stack, usually the current stored value
      resource - the resource, usually the received value in insert or extract
      Returns:
      true if the stack and resource match; false otherwise.

    • 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<S>
      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

    • 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.

    • onContentsChanged

      protected void onContentsChanged(int index, S previousContents)
      Called after the contents of the handler changed.

      For changes that happen through set(int, T, int), this method is called immediately. For changes that happen through insert(int, T, int, net.neoforged.neoforge.transfer.transaction.TransactionContext) or extract(int, T, int, net.neoforged.neoforge.transfer.transaction.TransactionContext), this function will be called at the end of the transaction, once per index that changed.

      Parameters:
      index - the index where the change happened
      previousContents - the stack before the change

    • copyToList

      public NonNullList<S> copyToList()
      Copies all the contents of this handler to a mutable fixed-size NonNullList.

    • 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<S>
      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<S>
      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<S>
      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<S>
      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<S>
      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<S>
      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: