PR suggestion: use concrete hooks

Signed-off-by: Alexandra Oberaigner <[email protected]>

Author: alexandraoberaigner

src/main/java/dev/openfeature/sdk/ObjectHook.java

@@ -0,0 +1,15 @@
+package dev.openfeature.sdk;
+
+/**
+ * An extension point which can run around flag resolution. They are intended to be used as a way to add custom logic
+ * to the lifecycle of flag evaluation.
+ *
+ * @see Hook
+ */
+public interface ObjectHook extends Hook<Object> {
+
+    @Override
+    default boolean supportsFlagValueType(FlagValueType flagValueType) {
+        return FlagValueType.OBJECT == flagValueType;
+    }
+}

src/test/java/dev/openfeature/sdk/benchmark/AllocationBenchmark.java

@@ -6,14 +6,18 @@
 import static dev.openfeature.sdk.testutils.TestFlagsUtils.OBJECT_FLAG_KEY;
 import static dev.openfeature.sdk.testutils.TestFlagsUtils.STRING_FLAG_KEY;
 
+import dev.openfeature.sdk.BooleanHook;
 import dev.openfeature.sdk.Client;
+import dev.openfeature.sdk.DoubleHook;
 import dev.openfeature.sdk.EvaluationContext;
-import dev.openfeature.sdk.Hook;
 import dev.openfeature.sdk.HookContext;
 import dev.openfeature.sdk.ImmutableContext;
 import dev.openfeature.sdk.ImmutableStructure;
+import dev.openfeature.sdk.IntegerHook;
 import dev.openfeature.sdk.NoOpProvider;
+import dev.openfeature.sdk.ObjectHook;
 import dev.openfeature.sdk.OpenFeatureAPI;
+import dev.openfeature.sdk.StringHook;
 import dev.openfeature.sdk.Value;
 import java.util.HashMap;
 import java.util.Map;
@@ -25,7 +29,7 @@
 
 /**
  * Runs a large volume of flag evaluations on a VM with 1G memory and GC
- * completely disabled so we can take a heap-dump.
+ * completely disabled, so we can take a heap-dump.
  */
 public class AllocationBenchmark {
 
@@ -48,31 +52,31 @@ public void run() {
         Map<String, Value> clientAttrs = new HashMap<>();
         clientAttrs.put("client", new Value(2));
         client.setEvaluationContext(new ImmutableContext(clientAttrs));
-        client.addHooks(new Hook<Object>() {
+        client.addHooks(new ObjectHook() {
             @Override
             public Optional<EvaluationContext> before(HookContext<Object> ctx, Map<String, Object> hints) {
                 return Optional.ofNullable(new ImmutableContext());
             }
         });
-        client.addHooks(new Hook<String>() {
+        client.addHooks(new StringHook() {
             @Override
             public Optional<EvaluationContext> before(HookContext<String> ctx, Map<String, Object> hints) {
                 return Optional.ofNullable(new ImmutableContext());
             }
         });
-        client.addHooks(new Hook<Boolean>() {
+        client.addHooks(new BooleanHook() {
             @Override
             public Optional<EvaluationContext> before(HookContext<Boolean> ctx, Map<String, Object> hints) {
                 return Optional.ofNullable(new ImmutableContext());
             }
         });
-        client.addHooks(new Hook<Integer>() {
+        client.addHooks(new IntegerHook() {
             @Override
             public Optional<EvaluationContext> before(HookContext<Integer> ctx, Map<String, Object> hints) {
                 return Optional.ofNullable(new ImmutableContext());
             }
         });
-        client.addHooks(new Hook<Double>() {
+        client.addHooks(new DoubleHook() {
             @Override
             public Optional<EvaluationContext> before(HookContext<Double> ctx, Map<String, Object> hints) {
                 return Optional.ofNullable(new ImmutableContext());