Skip to content

Instantly share code, notes, and snippets.

@IllusionTheDev

IllusionTheDev/DirectImmutableHolder.java

Created September 14, 2025 22:34
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save IllusionTheDev/e3eb5438f2f40eafe540f7185dec3af1 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save IllusionTheDev/e3eb5438f2f40eafe540f7185dec3af1 to your computer and use it in GitHub Desktop.
Download ZIP
Holder utility system. Allows for some neat links without duplicating code
Raw
DirectImmutableHolder.java
public class DirectImmutableHolder<T> implements Holder<T> {
private final T value;
private DirectImmutableHolder(T value) {
this.value = value;
}
public static <T> Holder<T> of(T value) {
return new DirectImmutableHolder<>(value);
}
@Override
public T get() {
return value;
}
@Override
public Holder<T> memoized() {
return this;
}
@Override
public String toString() {
return "DirectImmutableHolder{value=" + get() + "}";
}
}
Raw
DirectMutableHolder.java
public class DirectMutableHolder<T> implements MutableHolder<T> {
private T value;
private DirectMutableHolder(T value) {
this.value = value;
}
public static <T> DirectMutableHolder<T> of(T value) {
return new DirectMutableHolder<>(value);
}
public static <T> DirectMutableHolder<T> empty() {
return new DirectMutableHolder<>(null);
}
@Override
public void set(T value) {
this.value = value;
}
@Override
public T get() {
return value;
}
@Override
public String toString() {
return "MutableHolder{value=" + get() + "}";
}
}
Raw
Holder.java
public interface Holder<T> {
T get();
static <T> Holder<T> immutable(T value) {
return DirectImmutableHolder.of(value);
}
static <T> MutableHolder<T> mutable(T value) {
return DirectMutableHolder.of(value);
}
static <T> MutableHolder<T> mutable() {
return DirectMutableHolder.empty();
}
static <T> Holder<T> supplied(Supplier<T> supplier) {
return SuppliedHolder.of(supplier);
}
static <T> Holder<T> lazy(Supplier<T> supplier) {
return supplied(supplier).memoized();
}
default Holder<T> memoized() {
return MemoizedHolder.of(this);
}
default Holder<T> tickMemoized(Time memory) {
return TickMemoizedHolder.of(this, memory);
}
default Holder<T> locking() {
return LockingHolder.of(this);
}
default <V> Holder<V> transform(Function<T, V> function) {
return TransformingHolder.of(this, function);
}
default MutableHolder<T> ignoreMutable() {
return IgnoreMutableHolder.of(this);
}
}
Raw
IgnoreMutableHolder.java
public class IgnoreMutableHolder<T> implements MutableHolder<T> {
private final Holder<T> delegate;
private IgnoreMutableHolder(Holder<T> delegate) {
this.delegate = delegate;
}
public static <T> IgnoreMutableHolder<T> of(Holder<T> delegate) {
return new IgnoreMutableHolder<>(delegate);
}
@Override
public void set(T value) {
// ignore
}
@Override
public T get() {
return delegate.get();
}
}
Raw
LockingHolder.java
public class LockingHolder<T> implements Holder<T> {
private final Holder<T> delegate;
private final Object lock = new Object();
private LockingHolder(Holder<T> holder) {
this.delegate = holder;
}
public static <T> LockingHolder<T> of(Holder<T> delegate) {
return new LockingHolder<>(delegate);
}
@Override
public T get() {
synchronized (lock) {
return delegate.get();
}
}
}
Raw
MemoizedHolder.java
public class MemoizedHolder<T> implements Holder<T> {
private final Holder<T> delegate;
private T cached;
private boolean executed;
private MemoizedHolder(Holder<T> delegate) {
this.delegate = delegate;
this.cached = null;
this.executed = false;
}
public static <T> MemoizedHolder<T> of(Holder<T> delegate) {
return new MemoizedHolder<>(delegate);
}
@Override
public T get() {
if (!executed) {
cached = delegate.get();
executed = true;
}
return cached;
}
@Override
public String toString() {
return "MemoizedHolder{value=" + get() + "}";
}
}
Raw
MutableHolder.java
public interface MutableHolder<T> extends Holder<T> {
void set(T value);
default void update(UnaryOperator<T> operator) {
set(operator.apply(get()));
}
@Override
default MutableHolder<T> locking() {
return MutableLockingHolder.of(this);
}
static <T> MutableHolder<T> referenced(Supplier<T> supplier, Consumer<T> consumer) {
return MutableReferenceHolder.of(supplier, consumer);
}
}
Raw
MutableLockingHolder.java
public class MutableLockingHolder<T> implements MutableHolder<T> {
private final MutableHolder<T> delegate;
private final Object lock = new Object();
private MutableLockingHolder(MutableHolder<T> holder) {
this.delegate = holder;
}
public static <T> MutableLockingHolder<T> of(MutableHolder<T> delegate) {
return new MutableLockingHolder<>(delegate);
}
@Override
public T get() {
synchronized (lock) {
return delegate.get();
}
}
@Override
public void set(T value) {
synchronized (lock) {
delegate.set(value);
}
}
}
Raw
MutableReferenceHolder.java
public class MutableReferenceHolder<T> implements MutableHolder<T> {
private final Supplier<T> supplier;
private final Consumer<T> consumer;
private MutableReferenceHolder(Supplier<T> supplier, Consumer<T> consumer) {
this.supplier = supplier;
this.consumer = consumer;
}
public static <T> MutableHolder<T> of(Supplier<T> supplier, Consumer<T> consumer) {
return new MutableReferenceHolder<>(supplier, consumer);
}
@Override
public void set(T value) {
consumer.accept(value);
}
@Override
public T get() {
return supplier.get();
}
}
Raw
SuppliedHolder.java
public class SuppliedHolder<T> implements Holder<T> {
private final Supplier<T> supplier;
private SuppliedHolder(Supplier<T> supplier) {
this.supplier = supplier;
}
public static <T> SuppliedHolder<T> of(Supplier<T> supplier) {
return new SuppliedHolder<>(supplier);
}
@Override
public T get() {
return supplier.get();
}
@Override
public String toString() {
return "SuppliedHolder{value=" + get() + "}";
}
}
Raw
TickMemoizedHolder.java
public class TickMemoizedHolder<T> implements Holder<T> {
private final Holder<T> delegate;
private final Time memory;
private final AtomicReference<T> cached;
private long lastHit;
private TickMemoizedHolder(Holder<T> delegate, Time memory) {
this.delegate = delegate;
this.memory = memory;
this.cached = new AtomicReference<>();
this.lastHit = 0;
}
public static <T> TickMemoizedHolder<T> of(Holder<T> delegate, Time memory) {
return new TickMemoizedHolder<>(delegate, memory);
}
@Override
public T get() {
long current = System.currentTimeMillis();
if (current - lastHit > memory.as(TimeUnit.MILLISECONDS)) {
lastHit = current;
cached.set(delegate.get());
}
return cached.get();
}
@Override
public String toString() {
return "TickMemoizedHolder{value=" + get() + "cached=" + cached.get() + "}";
}
}
Raw
TransformingHolder.java
public class TransformingHolder<T, V> implements Holder<V> {
private final Holder<T> holder;
private final Function<T, V> function;
private TransformingHolder(Holder<T> holder, Function<T, V> function) {
this.holder = holder;
this.function = function;
}
public static <T, V> TransformingHolder<T, V> of(Holder<T> holder, Function<T, V> function) {
return new TransformingHolder<>(holder, function);
}
@Override
public V get() {
return function.apply(holder.get());
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment