net.minecraft.world.chunk

Class PalettedContainer<T>

java.lang.Object

net.minecraft.world.chunk.PalettedContainer<T>

All Implemented Interfaces:

PaletteResizeListener<T>

public class PalettedContainer<T>
extends Object
implements PaletteResizeListener<T>

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	PalettedContainer.CountConsumer<T>

Field Summary

Fields

Modifier and Type	Field and Description
protected PackedIntegerArray	data
private T	defaultValue
private Function<CompoundTag,T>	elementDeserializer
private Function<T,CompoundTag>	elementSerializer
private Palette<T>	fallbackPalette
private IdList<T>	idList
private PaletteResizeListener<T>	noOpPaletteResizeHandler
private Palette<T>	palette
private int	paletteSize
private ReentrantLock	writeLock

Constructor Summary

Constructors

Constructor and Description
PalettedContainer(Palette<T> fallbackPalette, IdList<T> idList, Function<CompoundTag,T> elementDeserializer, Function<T,CompoundTag> elementSerializer, T defaultElement)

Method Summary

Modifier and Type	Method and Description
void	count(PalettedContainer.CountConsumer<T> consumer)
void	fromPacket(PacketByteBuf buf)
protected T	get(int index)
T	get(int x, int y, int z)
int	getPacketSize()
boolean	hasAny(Predicate<T> predicate)
void	lock()
int	onResize(int newSize, T objectAdded)
void	read(ListTag paletteTag, long[] data)
T	set(int x, int y, int z, T value)
protected void	set(int int2, T t)
protected T	setAndGetOldValue(int index, T value)
private void	setPaletteSize(int size)
T	setSync(int x, int y, int z, T value)
private static int	toIndex(int x, int y, int z)
void	toPacket(PacketByteBuf buf)
void	unlock()
void	write(CompoundTag compoundTag, String string, String string2)

Methods inherited from class java.lang.Object

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

Field Detail

fallbackPalette

private final Palette<T> fallbackPalette

noOpPaletteResizeHandler

private final PaletteResizeListener<T> noOpPaletteResizeHandler

idList

private final IdList<T> idList

elementDeserializer

private final Function<CompoundTag,T> elementDeserializer

elementSerializer

private final Function<T,CompoundTag> elementSerializer

defaultValue

private final T defaultValue

data

protected PackedIntegerArray data

palette

private Palette<T> palette

paletteSize

private int paletteSize

writeLock

private final ReentrantLock writeLock

Constructor Detail

PalettedContainer

public PalettedContainer(Palette<T> fallbackPalette,
                         IdList<T> idList,
                         Function<CompoundTag,T> elementDeserializer,
                         Function<T,CompoundTag> elementSerializer,
                         T defaultElement)

Method Detail

lock

public void lock()

unlock

public void unlock()

toIndex

private static int toIndex(int x,
                           int y,
                           int z)

setPaletteSize

private void setPaletteSize(int size)

onResize

public int onResize(int newSize,
                    T objectAdded)

Specified by:

onResize in interface PaletteResizeListener<T>

setSync

public T setSync(int x,
                 int y,
                 int z,
                 T value)

set

public T set(int x,
             int y,
             int z,
             T value)

setAndGetOldValue

protected T setAndGetOldValue(int index,
                              T value)

set

protected void set(int int2,
                   T t)

get

public T get(int x,
             int y,
             int z)

get

protected T get(int index)

fromPacket

@Environment(value=CLIENT)
public void fromPacket(PacketByteBuf buf)

toPacket

public void toPacket(PacketByteBuf buf)

read

public void read(ListTag paletteTag,
                 long[] data)

write

public void write(CompoundTag compoundTag,
                  String string,
                  String string2)

getPacketSize

public int getPacketSize()

hasAny

public boolean hasAny(Predicate<T> predicate)

count

public void count(PalettedContainer.CountConsumer<T> consumer)