Package net.neoforged.neoforge.transfer.fluid

Class CauldronWrapper

java.lang.Object

net.neoforged.neoforge.transfer.transaction.SnapshotJournal<BlockState>

net.neoforged.neoforge.transfer.fluid.CauldronWrapper

All Implemented Interfaces:

ResourceHandler<FluidResource>

@Internal
public final class CauldronWrapper
extends SnapshotJournal<BlockState>
implements ResourceHandler<FluidResource>

A handler for cauldrons. This handler is used to interact with the fluid content of a cauldron.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static final record	CauldronWrapper.WrapperLocation	To make sure multiple accesses to the same cauldron return the same wrapper, we maintain a (Level, BlockPos) -> Wrapper cache.

Field Summary

Fields

Modifier and Type	Field	Description
private final CauldronWrapper.WrapperLocation	location
private static final Map<CauldronWrapper.WrapperLocation,CauldronWrapper>	wrappers	Wrapper map, similar to VanillaContainerWrapper.wrappers.

Constructor Summary

Constructors

Modifier	Constructor	Description
private	CauldronWrapper(CauldronWrapper.WrapperLocation location)

Method Summary

Modifier and Type	Method	Description
protected BlockState	createSnapshot()	Return a new nonnull object containing the current state of this journal.
int	extract(int index, FluidResource resource, int amount, TransactionContext transaction)	Extracts up to the given amount of a resource from the handler at the given index.
static CauldronWrapper	get(Level level, BlockPos pos)
long	getAmountAsLong(int index)	Returns the amount of the currently stored resource at the given index, as a long.
long	getCapacityAsLong(int index, FluidResource 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.
private CauldronFluidContent	getContent(BlockState state)
FluidResource	getResource(int index)	Returns the resource at the given index, which may be empty.
int	insert(int index, FluidResource 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, FluidResource resource)	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.
protected void	onRootCommit(BlockState originalState)	Called after the root transaction was successfully committed, to perform irreversible actions such as setChanged() or neighbor updates.
protected void	revertToSnapshot(BlockState snapshot)	Roll back to a state previously created by SnapshotJournal.createSnapshot().
private void	setLevel(CauldronFluidContent newContent, int fluidLevel, TransactionContext transaction)	Temporarily updates the block state in the level in a transactional way.
int	size()	Returns the current number of indices in this resource handler.

Methods inherited from class net.neoforged.neoforge.transfer.transaction.SnapshotJournal

releaseSnapshot, updateSnapshots

Methods inherited from class java.lang.Object

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

Methods inherited from interface net.neoforged.neoforge.transfer.ResourceHandler

extract, getAmountAsInt, getCapacityAsInt, insert

Field Details

wrappers

private static final Map<CauldronWrapper.WrapperLocation,CauldronWrapper> wrappers

Wrapper map, similar to VanillaContainerWrapper.wrappers. We need the cauldron wrapper to hold a strong reference to the wrapper location to avoid the weak keys being cleared too early.

location

private final CauldronWrapper.WrapperLocation location

Constructor Details

CauldronWrapper

private CauldronWrapper(CauldronWrapper.WrapperLocation location)

Method Details

get

public static CauldronWrapper get(Level level,
 BlockPos pos)

getContent

private CauldronFluidContent getContent(BlockState state)

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<FluidResource>

Returns:

The size of the resource handler. Can be 0 if the handler currently has no indices.

getResource

public FluidResource 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<FluidResource>

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<FluidResource>

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,
 FluidResource 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<FluidResource>

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)

isValid

public boolean isValid(int index,
 FluidResource 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<FluidResource>

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

setLevel

private void setLevel(CauldronFluidContent newContent,
 int fluidLevel,
 TransactionContext transaction)

Temporarily updates the block state in the level in a transactional way. See onRootCommit(net.minecraft.world.level.block.state.BlockState) for the final modification.

insert

public int insert(int index,
 FluidResource 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<FluidResource>

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,
 FluidResource 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<FluidResource>

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.

createSnapshot

protected BlockState 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<BlockState>

revertToSnapshot

protected void revertToSnapshot(BlockState snapshot)

Description copied from class: SnapshotJournal

Roll back to a state previously created by SnapshotJournal.createSnapshot().

Specified by:

revertToSnapshot in class SnapshotJournal<BlockState>

onRootCommit

protected void onRootCommit(BlockState originalState)

Description copied from class: SnapshotJournal

Called after the root transaction was successfully committed, to perform irreversible actions such as setChanged() or neighbor updates.

When a root transaction is being closed, all journals for which onRootCommit will be called are stored in a global thread-local queue. The processing of this queue starts immediately after the root transaction is closed. As such, new root transactions can safely be opened from this method.

When a root transaction is opened from onRootCommit, any journal might be modified, leading to more onRootCommit callbacks being enqueued:

• A journal that is already enqueued for onRootCommit will not be enqueued a second time. It will thus be notified a single time for changes that spanned multiple transactions. The originalState will be the state at the beginning of the first of these transactions.
• A journal whose onRootCommit was already processed will be enqueued again. The journal will be notified a second time, with originalState the state at the beginning of the second transaction.
• In particular, a journal is removed from the queue immediately before onRootCommit is called. Should the journal be modified again from its own onRootCommit, it will be added to the queue, and onRootCommit will be called again later.

Given the large amount of actions that can happen between the last modification and the call to onRootCommit, journals should not depend on onRootCommit being called immediately for correctness, and implementations of this method should be careful (e.g. in case the journal got removed from the level). For example, skipping block change notifications because the block was removed from the level is preferable than crashing or silently overwriting the block.

Overrides:

onRootCommit in class SnapshotJournal<BlockState>

Parameters:

originalState - state of this journal before the transactional operations. This corresponds to the first snapshot that was created in the transactional operations.