From 3d3c657497e63aab0b9c88925fd227d3cdcf183a Mon Sep 17 00:00:00 2001
From: JFronny <git@akbvopenfl1.hopto.org>
Date: Sat, 9 Mar 2024 13:38:28 +0100
Subject: [PATCH] feat(commons): Implement fake ScopedValue for use until the
 real thing arrives

---
 .../commons/concurrent/ScopedValue.java       | 122 ++++++++++++++++++
 .../StructureViolationException.java          |  10 ++
 2 files changed, 132 insertions(+)
 create mode 100644 commons/src/main/java/io/gitlab/jfronny/commons/concurrent/ScopedValue.java
 create mode 100644 commons/src/main/java/io/gitlab/jfronny/commons/concurrent/StructureViolationException.java

diff --git a/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/ScopedValue.java b/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/ScopedValue.java
new file mode 100644
index 0000000..83928e5
--- /dev/null
+++ b/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/ScopedValue.java
@@ -0,0 +1,122 @@
+package io.gitlab.jfronny.commons.concurrent;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+import java.util.concurrent.Callable;
+import java.util.function.Supplier;
+
+/**
+ * Naive, inefficient reimplementation of JDK22 ScopedValue based on ThreadLocal.
+ * See the official Javadoc for more information.
+ * Use the JDK22 version if possible!
+ * Does not include ScopedValue.where
+ *
+ * @param <T> The type of the value
+ */
+public class ScopedValue<T> {
+    public static <T> ScopedValue<T> newInstance() {
+        return new ScopedValue<>();
+    }
+
+    public static <T, R> R callWhere(ScopedValue<T> key, T value, Callable<? extends R> op) throws Exception {
+        key.value.get().setValue(value);
+        try {
+            return op.call();
+        } finally {
+            key.value.get().clear();
+        }
+    }
+
+    public static <T, R> R getWhere(ScopedValue<T> key, T value, Supplier<? extends R> op) {
+        key.value.get().setValue(value);
+        try {
+            return op.get();
+        } finally {
+            key.value.get().clear();
+        }
+    }
+
+    public static <T> void runWhere(ScopedValue<T> key, T value, Runnable op) {
+        key.value.get().setValue(value);
+        try {
+            op.run();
+        } finally {
+            key.value.get().clear();
+        }
+    }
+
+    private final InheritableThreadLocal<Carrier<T>> value = new InheritableThreadLocal<>() {
+        @Override
+        protected Carrier<T> childValue(Carrier<T> parentValue) {
+            return new Carrier<>(parentValue);
+        }
+
+        @Override
+        protected Carrier<T> initialValue() {
+            return new Carrier<>();
+        }
+    };
+
+    public T get() {
+        return value.get().getValue();
+    }
+
+    public boolean isBound() {
+        return value.get().isPresent();
+    }
+
+    public T orElse(T other) {
+        return value.get().orElse(other);
+    }
+
+    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+        return value.get().orElseThrow(exceptionSupplier);
+    }
+
+    private static class Carrier<T> {
+        private Deque<T> value;
+        private Carrier<T> parent;
+
+        public Carrier() {
+            this(null);
+        }
+
+        public Carrier(Carrier<T> parent) {
+            this.value = new LinkedList<>();
+            this.parent = parent;
+        }
+
+        public T getValue() {
+            if (!value.isEmpty()) return value.peek();
+            if (parent == null) throw new NoSuchElementException("No value present");
+            return parent.getValue();
+        }
+
+        public boolean isPresent() {
+            if (!value.isEmpty()) return true;
+            if (parent == null) return false;
+            return parent.isPresent();
+        }
+
+        public void setValue(T value) {
+            this.value.push(value);
+        }
+
+        public void clear() {
+            value.pop();
+        }
+
+        public T orElse(T other) {
+            if (!value.isEmpty()) return value.peek();
+            if (parent == null) return other;
+            return parent.orElse(other);
+        }
+
+        public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
+            if (!value.isEmpty()) return value.peek();
+            if (parent == null) throw exceptionSupplier.get();
+            return parent.orElseThrow(exceptionSupplier);
+        }
+    }
+}
diff --git a/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/StructureViolationException.java b/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/StructureViolationException.java
new file mode 100644
index 0000000..2c7bfca
--- /dev/null
+++ b/commons/src/main/java/io/gitlab/jfronny/commons/concurrent/StructureViolationException.java
@@ -0,0 +1,10 @@
+package io.gitlab.jfronny.commons.concurrent;
+
+public class StructureViolationException extends RuntimeException {
+    public StructureViolationException() {
+    }
+
+    public StructureViolationException(String message) {
+        super(message);
+    }
+}