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:

• (required) getResourceFrom(ItemResource, int) and getAmountFrom(ItemResource, int) to read the stored resource and amount in the item access.
• (required) update(ItemResource, int, T, int) to update an item resource from the item access with new contents of the handler.
• (required) getCapacity(int, T) to specify the capacity of this handler.
• (optional) isValid(int, T) to limit which resources are allowed in this handler; by default any resource is allowed.

Field Summary

Fields

Modifier and Type	Field	Description
protected final ItemAccess	itemAccess
protected final int	size

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	ItemAccessResourceHandler(ItemAccess itemAccess, int size)

Method Summary

Modifier and Type	Method	Description
int	extract(int index, T resource, int amount, TransactionContext transaction)	Extracts up to the given amount of a resource from the handler at the given index.
long	getAmountAsLong(int index)	Returns the amount of the currently stored resource at the given index, as a long.
protected abstract int	getAmountFrom(ItemResource accessResource, int index)	Retrieves the amount stored in the current contents of the item access.
protected abstract int	getCapacity(int index, T resource)	Return the maximum capacity of this handler for the passed resource.
long	getCapacityAsLong(int index, T resource)	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.
T	getResource(int index)	Returns the resource at the given index, which may be empty.
protected abstract T	getResourceFrom(ItemResource accessResource, int index)	Retrieves the resource stored in the current contents of the item access.
int	insert(int index, T resource, int amount, TransactionContext transaction)	Inserts up to the given amount of a resource into the handler at the given index.
boolean	isValid(int index, T resource)	Return true if the passed non-empty resource can fit in this handler, false otherwise.
int	size()	Returns the current number of indices in this resource handler.
protected abstract @Nullable ItemResource	update(ItemResource accessResource, int index, T newResource, int newAmount)	Returns a resource with updated resource and amount.

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface ResourceHandler

extract, getAmountAsInt, getCapacityAsInt, insert

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:

• ResourceHandler.getAmountAsInt(int)

update

protected abstract @Nullable 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, or null if the container items should be consumed instead of replaced

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:

• getCapacityAsLong(int, T), to report a capacity of 0 for invalid items;
• insert(int, T, int, TransactionContext), to reject items that cannot fit in this handler.

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:

• ResourceHandler.isValid(int, T)

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:

• ResourceHandler.getCapacityAsInt(int, T)

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:

• ResourceHandler.getAmountAsInt(int)

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:

• ResourceHandler.getCapacityAsInt(int, Resource)

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:

• Inserting without a specific index, which can be more efficient.

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:

• Extracting without a specific index, which can be more efficient.