fixup: split into packages

Signed-off-by: Simon Schrottner <[email protected]>

Author: aepfli

openfeature-api/src/main/java/dev/openfeature/api/AbstractEventProvider.java

@@ -0,0 +1,107 @@
+package dev.openfeature.api;
+
+import dev.openfeature.api.evaluation.EvaluationContext;
+import dev.openfeature.api.events.EventEmitter;
+import dev.openfeature.api.events.EventProvider;
+import dev.openfeature.api.events.ProviderEventDetails;
+import dev.openfeature.api.internal.TriConsumer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Abstract EventProvider. Providers must extend this class to support events.
+ * Emit events with {@link #emit(ProviderEvent, ProviderEventDetails)}. Please
+ * note that the SDK will automatically emit
+ * {@link ProviderEvent#PROVIDER_READY } or
+ * {@link ProviderEvent#PROVIDER_ERROR } accordingly when
+ * {@link Provider#initialize(EvaluationContext)} completes successfully
+ * or with error, so these events need not be emitted manually during
+ * initialization.
+ *
+ * @see Provider
+ */
+public abstract class AbstractEventProvider implements EventProvider {
+    private static final Logger log = LoggerFactory.getLogger(AbstractEventProvider.class);
+    private EventEmitter eventEmitter;
+    private final ExecutorService emitterExecutor = Executors.newCachedThreadPool();
+    private List<Hook<?>> hooks;
+
+    public void setEventEmitter(EventEmitter eventEmitter) {
+        this.eventEmitter = eventEmitter;
+    }
+
+    /**
+     * "Attach" this EventProvider to an SDK, which allows events to propagate from this provider.
+     * No-op if the same onEmit is already attached.
+     *
+     * @param onEmit the function to run when a provider emits events.
+     * @throws IllegalStateException if attempted to bind a new emitter for already bound provider
+     */
+    public void attach(TriConsumer<EventProvider, ProviderEvent, ProviderEventDetails> onEmit) {
+        if (eventEmitter == null) {
+            return;
+        }
+        eventEmitter.attach(onEmit);
+    }
+
+    /**
+     * "Detach" this EventProvider from an SDK, stopping propagation of all events.
+     */
+    public void detach() {
+        if (eventEmitter == null) {
+            return;
+        }
+        eventEmitter.detach();
+    }
+
+    /**
+     * Stop the event emitter executor and block until either termination has completed
+     * or timeout period has elapsed.
+     */
+    @Override
+    public void shutdown() {
+        if (eventEmitter == null) {
+            return;
+        }
+        eventEmitter.shutdown();
+    }
+
+    /**
+     * Emit the specified {@link ProviderEvent}.
+     *
+     * @param event   The event type
+     * @param details The details of the event
+     */
+    public Awaitable emit(final ProviderEvent event, final ProviderEventDetails details) {
+        return eventEmitter.emit(event, details);
+    }
+
+    @Override
+    public Provider addHooks(Hook<?>... hooks) {
+        if (this.hooks == null) {
+            this.hooks = new ArrayList<>();
+        }
+        this.hooks.addAll(List.of(hooks));
+        return this;
+    }
+
+    @Override
+    public List<Hook<?>> getHooks() {
+        if (hooks == null) {
+            return List.of();
+        }
+        return List.copyOf(hooks);
+    }
+
+    @Override
+    public void clearHooks() {
+        if (hooks == null) {
+            return;
+        }
+        hooks.clear();
+    }
+}

openfeature-api/src/main/java/dev/openfeature/api/Client.java

@@ -1,42 +1,19 @@
 package dev.openfeature.api;
 
-import java.util.List;
+import dev.openfeature.api.evaluation.EvaluationClient;
+import dev.openfeature.api.evaluation.EvaluationContextHolder;
+import dev.openfeature.api.events.EventBus;
+import dev.openfeature.api.lifecycle.Hookable;
+import dev.openfeature.api.tracking.Tracking;
+import dev.openfeature.api.types.ClientMetadata;
 
 /**
  * Interface used to resolve flags of varying types.
  */
-public interface Client extends Features, Tracking, EventBus<Client> {
+public interface Client
+        extends EvaluationClient, Tracking, EventBus<Client>, Hookable<Client>, EvaluationContextHolder<Client> {
     ClientMetadata getMetadata();
 
-    /**
-     * Return an optional client-level evaluation context.
-     *
-     * @return {@link EvaluationContext}
-     */
-    EvaluationContext getEvaluationContext();
-
-    /**
-     * Set the client-level evaluation context.
-     *
-     * @param ctx Client level context.
-     */
-    Client setEvaluationContext(EvaluationContext ctx);
-
-    /**
-     * Adds hooks for evaluation.
-     * Hooks are run in the order they're added in the before stage. They are run in reverse order for all other stages.
-     *
-     * @param hooks The hook to add.
-     */
-    Client addHooks(Hook... hooks);
-
-    /**
-     * Fetch the hooks associated to this client.
-     *
-     * @return A list of {@link Hook}s.
-     */
-    List<Hook> getHooks();
-
     /**
      * Returns the current state of the associated provider.
      *

openfeature-api/src/main/java/dev/openfeature/api/Hook.java

@@ -1,5 +1,8 @@
 package dev.openfeature.api;
 
+import dev.openfeature.api.evaluation.EvaluationContext;
+import dev.openfeature.api.evaluation.FlagEvaluationDetails;
+import dev.openfeature.api.lifecycle.HookContext;
 import java.util.Map;
 import java.util.Optional;
 

openfeature-api/src/main/java/dev/openfeature/api/OpenFeatureAPI.java

@@ -1,6 +1,10 @@
 package dev.openfeature.api;
 
+import dev.openfeature.api.evaluation.EvaluationContextHolder;
+import dev.openfeature.api.events.EventBus;
 import dev.openfeature.api.internal.noop.NoOpOpenFeatureAPI;
+import dev.openfeature.api.lifecycle.Hookable;
+import dev.openfeature.api.lifecycle.Lifecycle;
 import java.util.ServiceLoader;
 
 /**
@@ -18,14 +22,14 @@
  */
 public abstract class OpenFeatureAPI
         implements OpenFeatureCore,
-                OpenFeatureHooks,
-                OpenFeatureContext,
-                OpenFeatureEventHandling,
-                OpenFeatureTransactionContext,
-                OpenFeatureLifecycle {
-
+                Hookable<OpenFeatureAPI>,
+                EvaluationContextHolder<OpenFeatureAPI>,
+                EventBus<OpenFeatureAPI>,
+                Transactional,
+                Lifecycle {
+    // package-private multi-read/single-write lock
     private static volatile OpenFeatureAPI instance;
-    private static final Object lock = new Object();
+    private static final Object instanceLock = new Object();
 
     /**
      * Gets the singleton OpenFeature API instance.
@@ -35,7 +39,7 @@ public abstract class OpenFeatureAPI
      */
     public static OpenFeatureAPI getInstance() {
         if (instance == null) {
-            synchronized (lock) {
+            synchronized (instanceLock) {
                 if (instance == null) {
                     instance = loadImplementation();
                 }
@@ -89,7 +93,7 @@ private static OpenFeatureAPI loadImplementation() {
      * and should be used with caution in production environments.
      */
     protected static void resetInstance() {
-        synchronized (lock) {
+        synchronized (instanceLock) {
             instance = null;
         }
     }

openfeature-api/src/main/java/dev/openfeature/api/OpenFeatureContext.java

@@ -1,6 +1,7 @@
 package dev.openfeature.api;
 
 import dev.openfeature.api.exceptions.OpenFeatureError;
+import dev.openfeature.api.types.ProviderMetadata;
 
 /**
  * Core interface for basic OpenFeature operations.
@@ -47,26 +48,26 @@ public interface OpenFeatureCore {
      *
      * @param provider the provider to set as default
      */
-    void setProvider(FeatureProvider provider);
+    void setProvider(Provider provider);
 
     /**
      * Add a provider for a domain.
      *
      * @param domain   The domain to bind the provider to.
      * @param provider The provider to set.
      */
-    void setProvider(String domain, FeatureProvider provider);
+    void setProvider(String domain, Provider provider);
 
     /**
      * Sets the default provider and waits for its initialization to complete.
      *
      * <p>Note: If the provider fails during initialization, an {@link OpenFeatureError} will be thrown.
      * It is recommended to wrap this call in a try-catch block to handle potential initialization failures gracefully.
      *
-     * @param provider the {@link FeatureProvider} to set as the default.
+     * @param provider the {@link Provider} to set as the default.
      * @throws OpenFeatureError if the provider fails during initialization.
      */
-    void setProviderAndWait(FeatureProvider provider) throws OpenFeatureError;
+    void setProviderAndWait(Provider provider) throws OpenFeatureError;
 
     /**
      * Add a provider for a domain and wait for initialization to finish.
@@ -78,20 +79,20 @@ public interface OpenFeatureCore {
      * @param provider The provider to set.
      * @throws OpenFeatureError if the provider fails during initialization.
      */
-    void setProviderAndWait(String domain, FeatureProvider provider) throws OpenFeatureError;
+    void setProviderAndWait(String domain, Provider provider) throws OpenFeatureError;
 
     /**
      * Return the default provider.
      */
-    FeatureProvider getProvider();
+    Provider getProvider();
 
     /**
      * Fetch a provider for a domain. If not found, return the default.
      *
      * @param domain The domain to look for.
-     * @return A named {@link FeatureProvider}
+     * @return A named {@link Provider}
      */
-    FeatureProvider getProvider(String domain);
+    Provider getProvider(String domain);
 
     /**
      * Get metadata about the default provider.