rename wrapper class, add public facing methods

Signed-off-by: christian.lutnik <[email protected]>

Author: chrfwow

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

@@ -108,8 +108,8 @@ public boolean equals(Object obj) {
         if (obj == null) {
             return false;
         }
-        if (obj instanceof FeatureProviderWrapper) {
-            return this == ((FeatureProviderWrapper) obj).getDelegate();
+        if (obj instanceof StatefulFeatureProvider) {
+            return this == ((StatefulFeatureProvider) obj).getDelegate();
         }
         return this == obj;
     }

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

@@ -72,8 +72,8 @@ public boolean equals(Object obj) {
         if (obj == null) {
             return false;
         }
-        if (obj instanceof FeatureProviderWrapper) {
-            return ((FeatureProviderWrapper) obj).getDelegate() == this;
+        if (obj instanceof StatefulFeatureProvider) {
+            return ((StatefulFeatureProvider) obj).getDelegate() == this;
         }
         return obj == this;
     }

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

@@ -303,6 +303,10 @@ public ProviderState getProviderState(String domain) {
         return providerRepository.getProviderState(domain);
     }
 
+    public ProviderState getProviderState(FeatureProvider provider) {
+        return providerRepository.getProviderState(provider);
+    }
+
     /**
      * Adds hooks for globally, used for all evaluations.
      * Hooks are run in the order they're added in the before stage. They are run in reverse order for all other stages.

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

@@ -20,9 +20,9 @@
 @Slf4j
 class ProviderRepository {
 
-    private final Map<String, FeatureProviderWrapper> providers = new ConcurrentHashMap<>();
-    private final AtomicReference<FeatureProviderWrapper> defaultProvider = new AtomicReference<>(
-            new FeatureProviderWrapper(new NoOpProvider())
+    private final Map<String, StatefulFeatureProvider> providers = new ConcurrentHashMap<>();
+    private final AtomicReference<StatefulFeatureProvider> defaultProvider = new AtomicReference<>(
+            new StatefulFeatureProvider(new NoOpProvider())
     );
     private final ExecutorService taskExecutor = Executors.newCachedThreadPool(runnable -> {
         final Thread thread = new Thread(runnable);
@@ -51,6 +51,24 @@ public ProviderState getProviderState() {
         return defaultProvider.get().getState();
     }
 
+    public ProviderState getProviderState(FeatureProvider featureProvider) {
+        if (featureProvider instanceof StatefulFeatureProvider) {
+            return ((StatefulFeatureProvider) featureProvider).getState();
+        }
+
+        StatefulFeatureProvider defaultProvider = this.defaultProvider.get();
+        if (defaultProvider.equals(featureProvider)) {
+            return defaultProvider.getState();
+        }
+
+        for (StatefulFeatureProvider wrapper : providers.values()) {
+            if (wrapper.equals(featureProvider)) {
+                return wrapper.getState();
+            }
+        }
+        return null;
+    }
+
     public ProviderState getProviderState(String domain) {
         return Optional.ofNullable(domain).map(this.providers::get).orElse(this.defaultProvider.get()).getState();
     }
@@ -116,15 +134,15 @@ private void prepareAndInitializeProvider(String domain,
                                               BiConsumer<FeatureProvider, OpenFeatureError> afterError,
                                               boolean waitForInit) {
 
-        FeatureProviderWrapper newProviderWrapper = new FeatureProviderWrapper(newProvider);
+        StatefulFeatureProvider newProviderWrapper = new StatefulFeatureProvider(newProvider);
 
         if (!isProviderRegistered(newProvider)) {
             // only run afterSet if new provider is not already attached
             afterSet.accept(newProvider);
         }
 
         // provider is set immediately, on this thread
-        FeatureProviderWrapper oldProvider = domain != null
+        StatefulFeatureProvider oldProvider = domain != null
                 ? this.providers.put(domain, newProviderWrapper)
                 : this.defaultProvider.getAndSet(newProviderWrapper);
 
@@ -138,11 +156,11 @@ private void prepareAndInitializeProvider(String domain,
         }
     }
 
-    private void initializeProvider(FeatureProviderWrapper newProvider,
+    private void initializeProvider(StatefulFeatureProvider newProvider,
                                     Consumer<FeatureProvider> afterInit,
                                     Consumer<FeatureProvider> afterShutdown,
                                     BiConsumer<FeatureProvider, OpenFeatureError> afterError,
-                                    FeatureProviderWrapper oldProvider) {
+                                    StatefulFeatureProvider oldProvider) {
         try {
             if (ProviderState.NOT_READY.equals(newProvider.getState())) {
                 newProvider.initialize(OpenFeatureAPI.getInstance().getEvaluationContext());
@@ -166,7 +184,7 @@ private void initializeProvider(FeatureProviderWrapper newProvider,
         }
     }
 
-    private void shutDownOld(FeatureProviderWrapper oldProvider, Consumer<FeatureProvider> afterShutdown) {
+    private void shutDownOld(StatefulFeatureProvider oldProvider, Consumer<FeatureProvider> afterShutdown) {
         if (oldProvider != null && !isProviderRegistered(oldProvider)) {
             shutdownProvider(oldProvider);
             afterShutdown.accept(oldProvider.getDelegate());
@@ -184,7 +202,7 @@ private boolean isProviderRegistered(FeatureProvider provider) {
                 && (this.providers.containsValue(provider) || this.defaultProvider.get().equals(provider));
     }
 
-    private void shutdownProvider(FeatureProviderWrapper provider) {
+    private void shutdownProvider(StatefulFeatureProvider provider) {
         if (provider == null) {
             return;
         }

src/main/java/dev/openfeature/sdk/FeatureProviderWrapper.java renamed to src/main/java/dev/openfeature/sdk/StatefulFeatureProvider.java

@@ -5,7 +5,7 @@
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
-class FeatureProviderWrapper implements FeatureProvider, EventProviderListener {
+class StatefulFeatureProvider implements FeatureProvider, EventProviderListener {
 
     private interface ExcludeFromDelegate {
         void initialize(EvaluationContext evaluationContext) throws Exception;
@@ -20,7 +20,7 @@ private interface ExcludeFromDelegate {
     private final AtomicBoolean isInitialized = new AtomicBoolean();
     private ProviderState state = ProviderState.NOT_READY;
 
-    public FeatureProviderWrapper(FeatureProvider delegate) {
+    public StatefulFeatureProvider(FeatureProvider delegate) {
         this.delegate = delegate;
         if (delegate instanceof EventProvider) {
             ((EventProvider) delegate).setEventProviderListener(this);
@@ -72,8 +72,8 @@ public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
-        if (obj instanceof FeatureProviderWrapper) {
-            return delegate.equals(((FeatureProviderWrapper) obj).delegate);
+        if (obj instanceof StatefulFeatureProvider) {
+            return delegate.equals(((StatefulFeatureProvider) obj).delegate);
         }
         return delegate.equals(obj);
     }

src/test/java/dev/openfeature/sdk/ProviderRepositoryTest.java

@@ -2,7 +2,6 @@
 
 import dev.openfeature.sdk.exceptions.OpenFeatureError;
 import dev.openfeature.sdk.testutils.exception.TestException;
-import lombok.SneakyThrows;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -56,7 +55,7 @@ void shouldRejectNullAsDefaultProvider() {
             @Test
             @DisplayName("should have NoOpProvider set as default on initialization")
             void shouldHaveNoOpProviderSetAsDefaultOnInitialization() {
-                assertThat(((FeatureProviderWrapper)providerRepository.getProvider()).getDelegate())
+                assertThat(((StatefulFeatureProvider)providerRepository.getProvider()).getDelegate())
                         .isInstanceOf(NoOpProvider.class);
             }
 

src/test/java/dev/openfeature/sdk/FeatureProviderWrapperTest.java renamed to src/test/java/dev/openfeature/sdk/StatefulFeatureProviderTest.java

@@ -12,15 +12,15 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-class FeatureProviderWrapperTest {
+class StatefulFeatureProviderTest {
 
-    private FeatureProviderWrapper wrapper;
+    private StatefulFeatureProvider wrapper;
     private TestDelegate testDelegate;
 
     @BeforeEach
     public void setUp() {
         testDelegate = new TestDelegate();
-        wrapper = new FeatureProviderWrapper(testDelegate);
+        wrapper = new StatefulFeatureProvider(testDelegate);
     }
 
     @SuppressWarnings("java:S5845")