Update cache to handle DiffContext

Author: quen2404

src/main/java/com/qdesrame/openapi/diff/compare/CacheKey.java

@@ -0,0 +1,43 @@
+package com.qdesrame.openapi.diff.compare;
+
+import com.qdesrame.openapi.diff.model.DiffContext;
+import lombok.Getter;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+@Getter
+public final class CacheKey {
+    private final String left;
+    private final String right;
+    private final DiffContext context;
+
+    public CacheKey(final String left, final String right, final DiffContext context) {
+        this.left = left;
+        this.right = right;
+        this.context = context;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+
+        if (o == null || getClass() != o.getClass()) return false;
+
+        CacheKey cacheKey = (CacheKey) o;
+
+        return new EqualsBuilder()
+                .append(left, cacheKey.left)
+                .append(right, cacheKey.right)
+                .append(context, cacheKey.context)
+                .isEquals();
+    }
+
+    @Override
+    public int hashCode() {
+        return new HashCodeBuilder(17, 37)
+                .append(left)
+                .append(right)
+                .append(context)
+                .toHashCode();
+    }
+}

src/main/java/com/qdesrame/openapi/diff/compare/ReferenceDiffCache.java

@@ -11,33 +11,25 @@
  * Created by adarsh.sharma on 07/01/18.
  */
 public abstract class ReferenceDiffCache<C, D> {
-    private Map<String, Map<String, D>> refDiffMap;
+    private Map<CacheKey, D> refDiffMap;
 
     public ReferenceDiffCache() {
         this.refDiffMap = new HashMap<>();
     }
 
-    private Optional<D> getFromCache(String leftRef, String rightRef) {
-        Optional<Map<String, D>> changedSchemaMap = Optional.ofNullable(refDiffMap.get(leftRef));
-        if (changedSchemaMap.isPresent()) {
-            return Optional.ofNullable(changedSchemaMap.get().get(rightRef));
-        }
-        return Optional.empty();
+    private Optional<D> getFromCache(CacheKey cacheKey) {
+        return Optional.ofNullable(refDiffMap.get(cacheKey));
     }
 
-    private void addToCache(String leftRef, String rightRef, D changed) {
-        Map<String, D> changedSchemaMap = refDiffMap.computeIfAbsent(leftRef, k -> new HashMap<>());
-        changedSchemaMap.put(rightRef, changed);
+    private void addToCache(CacheKey cacheKey, D changed) {
+        refDiffMap.put(cacheKey, changed);
     }
 
-    //    public Optional<D> cachedDiff(HashSet<String> refSet, C left, C right, String leftRef, String rightRef) {
-//        return cachedDiff(refSet, left, right, leftRef, rightRef, null);
-//    }
-//
     public Optional<D> cachedDiff(HashSet<String> refSet, C left, C right, String leftRef, String rightRef, DiffContext context) {
         boolean areBothRefParameters = leftRef != null && rightRef != null;
         if (areBothRefParameters) {
-            Optional<D> changedFromRef = getFromCache(leftRef, rightRef);
+            CacheKey key = new CacheKey(leftRef, rightRef, context);
+            Optional<D> changedFromRef = getFromCache(key);
             if (changedFromRef.isPresent()) {
                 return changedFromRef;
             } else {
@@ -47,9 +39,8 @@ public Optional<D> cachedDiff(HashSet<String> refSet, C left, C right, String le
                 } else {
                     refSet.add(refKey);
                     Optional<D> changed = computeDiff(refSet, left, right, context);
-                    addToCache(leftRef, rightRef, changed.orElse(null));
+                    addToCache(key, changed.orElse(null));
                     refSet.remove(refKey);
-
                     return changed;
                 }
             }

src/main/java/com/qdesrame/openapi/diff/model/DiffContext.java

@@ -1,6 +1,8 @@
 package com.qdesrame.openapi.diff.model;
 
 import io.swagger.v3.oas.models.PathItem;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -90,4 +92,32 @@ public DiffContext setParameters(Map<String, String> parameters) {
         this.parameters = parameters;
         return this;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+
+        if (o == null || getClass() != o.getClass()) return false;
+
+        DiffContext that = (DiffContext) o;
+
+        return new EqualsBuilder()
+                .append(response, that.response)
+                .append(request, that.request)
+                .append(url, that.url)
+                .append(parameters, that.parameters)
+                .append(method, that.method)
+                .isEquals();
+    }
+
+    @Override
+    public int hashCode() {
+        return new HashCodeBuilder(17, 37)
+                .append(url)
+                .append(parameters)
+                .append(method)
+                .append(response)
+                .append(request)
+                .toHashCode();
+    }
 }