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, TransactionContext) or extract(int, T, int, 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: