feat: equivalent EvaluationContext impls are .equal

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

@@ -3,10 +3,9 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-import lombok.EqualsAndHashCode;
+import java.util.Objects;
 
 @SuppressWarnings({"PMD.BeanMembersShouldSerialize", "checkstyle:MissingJavadocType"})
-@EqualsAndHashCode
 abstract class AbstractStructure implements Structure {
 
     protected final Map<String, Value> attributes;
@@ -48,4 +47,18 @@ public Map<String, Object> asObjectMap() {
                         (accumulated, entry) -> accumulated.put(entry.getKey(), convertValue(entry.getValue())),
                         HashMap::putAll);
     }
+
+    @Override
+    public boolean equals(Object object) {
+        if (!(object instanceof AbstractStructure)) {
+            return false;
+        }
+        AbstractStructure that = (AbstractStructure) object;
+        return Objects.equals(attributes, that.attributes);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(attributes);
+    }
 }

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

@@ -24,6 +24,31 @@ public interface EvaluationContext extends Structure {
      */
     EvaluationContext merge(EvaluationContext overridingContext);
 
+    /**
+     * If the other object is an EvaluationContext, this method compares the results of asUnmodifiableMap() for
+     * equality. Otherwise, it returns false.
+     * <br>
+     * <br>
+     * Implementations of EvaluationContext are encouraged to delegate their equals() method to this method, or provide
+     * a more optimized check with the same semantics.
+     *
+     * @param other the object to compare to
+     * @return true if the other object is an EvaluationContext and has the same map representation, false otherwise
+     */
+    default boolean isEqualTo(Object other) {
+        if (other == null) {
+            return false;
+        }
+        if (other == this) {
+            return true;
+        }
+        if (!(other instanceof EvaluationContext)) {
+            return false;
+        }
+        var otherContext = (EvaluationContext) other;
+        return asUnmodifiableMap().equals(otherContext.asUnmodifiableMap());
+    }
+
     /**
      * Recursively merges the overriding map into the base Value map.
      * The base map is mutated, the overriding map is not.

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

@@ -5,7 +5,6 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
-import lombok.EqualsAndHashCode;
 import lombok.ToString;
 import lombok.experimental.Delegate;
 
@@ -17,7 +16,6 @@
  * not be modified after instantiation.
  */
 @ToString
-@EqualsAndHashCode
 @SuppressWarnings("PMD.BeanMembersShouldSerialize")
 public final class ImmutableContext implements EvaluationContext {
 
@@ -26,6 +24,9 @@ public final class ImmutableContext implements EvaluationContext {
     @Delegate(excludes = DelegateExclusions.class)
     private final ImmutableStructure structure;
 
+    // Lazily computed hash code, safe because this class is immutable.
+    private volatile Integer cachedHashCode;
+
     /**
      * Create an immutable context with an empty targeting_key and attributes
      * provided.
@@ -96,6 +97,40 @@ public EvaluationContext merge(EvaluationContext overridingContext) {
         return new ImmutableContext(attributes);
     }
 
+    /**
+     * Equality for EvaluationContext implementations is defined in terms of their resolved
+     * attribute maps. Two contexts are considered equal if their {@link #asMap()} representations
+     * contain the same key/value pairs, regardless of how the context was constructed or layered.
+     *
+     * @param o the object to compare with this context
+     * @return true if the other object is an EvaluationContext whose resolved attributes match
+     */
+    @Override
+    public boolean equals(Object o) {
+        return isEqualTo(o);
+    }
+
+    /**
+     * Computes a hash code consistent with {@link #equals(Object)}. Since this context is immutable,
+     * the hash code is lazily computed once from its resolved attribute map and then cached.
+     *
+     * @return the cached hash code derived from this context's attribute map
+     */
+    @Override
+    public int hashCode() {
+        Integer result = cachedHashCode;
+        if (result == null) {
+            synchronized (this) {
+                result = cachedHashCode;
+                if (result == null) {
+                    result = structure.hashCode();
+                    cachedHashCode = result;
+                }
+            }
+        }
+        return result;
+    }
+
     @SuppressWarnings("all")
     private static class DelegateExclusions {
         @ExcludeFromGeneratedCoverageReport

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

@@ -21,6 +21,9 @@ public class LayeredEvaluationContext implements EvaluationContext {
     private ArrayList<EvaluationContext> hookContexts;
     private String targetingKey;
     private Set<String> keySet = null;
+    // Lazily computed resolved attribute map for this layered context.
+    // This must be invalidated whenever the underlying layers change.
+    private Map<String, Value> cachedMap;
 
     /**
      * Constructor for LayeredEvaluationContext.
@@ -174,15 +177,20 @@ public Value getValue(String key) {
         return getFromContext(apiContext, key);
     }
 
-    @Override
-    public Map<String, Value> asMap() {
+    private Map<String, Value> getResolvedMap() {
+        if (cachedMap != null) {
+            return cachedMap;
+        }
+
         if (keySet != null && keySet.isEmpty()) {
-            return new HashMap<>(0);
+            cachedMap = Collections.emptyMap();
+            return cachedMap;
         }
 
         HashMap<String, Value> map;
         if (keySet != null) {
-            map = new HashMap<>(keySet.size());
+            // use helper to size the map based on expected entries
+            map = HashMapUtils.forEntries(keySet.size());
         } else {
             map = new HashMap<>();
         }
@@ -205,7 +213,15 @@ public Map<String, Value> asMap() {
                 map.putAll(hookContext.asMap());
             }
         }
-        return map;
+
+        cachedMap = Collections.unmodifiableMap(map);
+        return cachedMap;
+    }
+
+    @Override
+    public Map<String, Value> asMap() {
+        // Return a defensive copy so callers can't mutate our cached map.
+        return new HashMap<>(getResolvedMap());
     }
 
     @Override
@@ -214,7 +230,7 @@ public Map<String, Value> asUnmodifiableMap() {
             return Collections.emptyMap();
         }
 
-        return Collections.unmodifiableMap(asMap());
+        return getResolvedMap();
     }
 
     @Override
@@ -225,7 +241,8 @@ public Map<String, Object> asObjectMap() {
 
         HashMap<String, Object> map;
         if (keySet != null) {
-            map = new HashMap<>(keySet.size());
+            // use helper to size the map based on expected entries
+            map = HashMapUtils.forEntries(keySet.size());
         } else {
             map = new HashMap<>();
         }
@@ -248,9 +265,33 @@ public Map<String, Object> asObjectMap() {
                 map.putAll(hookContext.asObjectMap());
             }
         }
+
         return map;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof EvaluationContext)) {
+            return false;
+        }
+
+        EvaluationContext that = (EvaluationContext) o;
+
+        if (that instanceof LayeredEvaluationContext) {
+            return this.getResolvedMap().equals(((LayeredEvaluationContext) that).getResolvedMap());
+        }
+
+        return this.getResolvedMap().equals(that.asUnmodifiableMap());
+    }
+
+    @Override
+    public int hashCode() {
+        return getResolvedMap().hashCode();
+    }
+
     void putHookContext(EvaluationContext context) {
         if (context == null || context.isEmpty()) {
             return;
@@ -265,5 +306,6 @@ void putHookContext(EvaluationContext context) {
         }
         this.hookContexts.add(context);
         this.keySet = null;
+        this.cachedMap = null;
     }
 }

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

@@ -6,7 +6,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
-import lombok.EqualsAndHashCode;
 import lombok.ToString;
 import lombok.experimental.Delegate;
 
@@ -17,7 +16,6 @@
  * be modified after instantiation.
  */
 @ToString
-@EqualsAndHashCode
 @SuppressWarnings("PMD.BeanMembersShouldSerialize")
 public class MutableContext implements EvaluationContext {
 
@@ -125,6 +123,24 @@ public EvaluationContext merge(EvaluationContext overridingContext) {
         return new MutableContext(attributes);
     }
 
+    /**
+     * Equality for EvaluationContext implementations is defined in terms of their resolved
+     * attribute maps. Two contexts are considered equal if their {@link #asMap()} representations
+     * contain the same key/value pairs, regardless of how the context was constructed or layered.
+     *
+     * @param o the object to compare with this context
+     * @return true if the other object is an EvaluationContext whose resolved attributes match
+     */
+    @Override
+    public boolean equals(Object o) {
+        return isEqualTo(o);
+    }
+
+    @Override
+    public int hashCode() {
+        return structure.hashCode();
+    }
+
     /**
      * Hidden class to tell Lombok not to copy these methods over via delegation.
      */