Improve PdfDictionary#entrySet() and PdfDictionary#values().

The returned #values() and #entrySet() is not a static copy. Therefore, changes to the PdfDictionary continue to be reflected in the #values() and #entrySet().

DEVSIX-728

Author: pavel-alay

kernel/src/main/java/com/itextpdf/kernel/pdf/PdfDictionary.java

@@ -43,7 +43,6 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.kernel.pdf;
 
-import com.itextpdf.kernel.PdfException;
 import com.itextpdf.kernel.geom.Rectangle;
 
 import java.util.*;
@@ -370,16 +369,7 @@ public Collection<PdfObject> values(boolean asDirects) {
      * @return a Collection holding all the values
      */
     public Collection<PdfObject> values() {
-        Collection<PdfObject> directValues = new ArrayList<>();
-        for (PdfObject value : map.values()) {
-            if (value.isIndirectReference()) {
-                directValues.add(((PdfIndirectReference)value).getRefersTo());
-            } else {
-                directValues.add(value);
-            }
-        }
-
-        return directValues;
+        return new PdfDictionaryValues(map.values());
     }
 
     /**
@@ -413,16 +403,7 @@ public Collection<PdfObject> directValues() {
      * @return a Set of Map.Entry objects
      */
     public Set<Map.Entry<PdfName, PdfObject>> entrySet() {
-        Map<PdfName, PdfObject> directMap = new TreeMap<>();
-        for(Map.Entry<PdfName, PdfObject> entry : map.entrySet()) {
-            PdfObject value = entry.getValue();
-            if (value.isIndirectReference()) {
-                directMap.put(entry.getKey(), ((PdfIndirectReference)value).getRefersTo());
-            } else {
-                directMap.put(entry.getKey(), value);
-            }
-        }
-        return directMap.entrySet();
+        return new PdfDictionaryEntrySet(map.entrySet());
     }
 
     /**

kernel/src/main/java/com/itextpdf/kernel/pdf/PdfDictionaryEntrySet.java

@@ -0,0 +1,99 @@
+package com.itextpdf.kernel.pdf;
+
+import java.util.AbstractSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+class PdfDictionaryEntrySet extends AbstractSet<Map.Entry<PdfName, PdfObject>> {
+
+    private final Set<Map.Entry<PdfName, PdfObject>> set;
+
+    PdfDictionaryEntrySet(Set<Map.Entry<PdfName, PdfObject>> set) {
+        this.set = set;
+    }
+
+    @Override
+    public Iterator<Map.Entry<PdfName, PdfObject>> iterator() {
+        return new DirectIterator();
+    }
+
+    @Override
+    public int size() {
+        return set.size();
+    }
+
+    @Override
+    public void clear() {
+        set.clear();
+    }
+
+    private class DirectIterator implements Iterator<Map.Entry<PdfName, PdfObject>> {
+        Iterator<Map.Entry<PdfName, PdfObject>> parentIterator = set.iterator();
+
+        @Override
+        public boolean hasNext() {
+            return parentIterator.hasNext();
+        }
+
+        @Override
+        public Map.Entry<PdfName, PdfObject> next() {
+            return new DirectEntry(parentIterator.next());
+        }
+
+        @Override
+        public void remove() {
+            parentIterator.remove();
+        }
+    }
+
+    private class DirectEntry implements Map.Entry<PdfName, PdfObject> {
+
+        Map.Entry<PdfName, PdfObject> entry;
+
+        public DirectEntry(Map.Entry<PdfName, PdfObject> entry) {
+            this.entry = entry;
+        }
+
+        @Override
+        public PdfName getKey() {
+            return entry.getKey();
+        }
+
+        @Override
+        public PdfObject getValue() {
+            PdfObject obj = entry.getValue();
+            if (obj.isIndirectReference()) {
+                obj = ((PdfIndirectReference) obj).getRefersTo(true);
+            }
+            return obj;
+        }
+
+        @Override
+        public PdfObject setValue(PdfObject value) {
+            return entry.setValue(value);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            Map.Entry e = (Map.Entry)o;
+            Object k1 = getKey();
+            Object k2 = e.getKey();
+            if (k1 != null && k1.equals(k2)) {
+                Object v1 = getValue();
+                Object v2 = e.getValue();
+                if (v1 != null && v1.equals(v2))
+                    return true;
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
+        }
+    }
+}

kernel/src/main/java/com/itextpdf/kernel/pdf/PdfDictionaryValues.java

@@ -0,0 +1,90 @@
+package com.itextpdf.kernel.pdf;
+
+import java.util.AbstractCollection;
+import java.util.Collection;
+import java.util.Iterator;
+
+class PdfDictionaryValues extends AbstractCollection<PdfObject> {
+
+    private final Collection<PdfObject> collection;
+
+    PdfDictionaryValues(Collection<PdfObject> collection) {
+        this.collection = collection;
+    }
+
+    @Override
+    public boolean add(PdfObject object) {
+        return collection.add(object);
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        if (collection.contains(o))
+            return true;
+        if (o != null) {
+            if (((PdfObject) o).getIndirectReference() != null
+                && collection.contains(((PdfObject) o).getIndirectReference())) {
+                return true;
+            } else if (((PdfObject) o).isIndirectReference()
+                    && collection.contains(((PdfIndirectReference) o).getRefersTo())) {
+                return true;
+            }
+        }
+        return false;
+
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        if (collection.remove(o))
+            return true;
+        if (o != null) {
+            if (((PdfObject) o).getIndirectReference() != null
+                    && collection.remove(((PdfObject) o).getIndirectReference())) {
+                return true;
+            } else if (((PdfObject) o).isIndirectReference()
+                    && collection.remove(((PdfIndirectReference) o).getRefersTo())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public int size() {
+        return collection.size();
+    }
+
+    @Override
+    public void clear() {
+        collection.clear();
+    }
+
+    @Override
+    public Iterator<PdfObject> iterator() {
+        return new DirectIterator();
+    }
+
+    private class DirectIterator implements Iterator<PdfObject> {
+        Iterator<PdfObject> parentIterator = collection.iterator();
+
+        @Override
+        public boolean hasNext() {
+            return parentIterator.hasNext();
+        }
+
+        @Override
+        public PdfObject next() {
+            PdfObject obj = parentIterator.next();
+            if (obj.isIndirectReference()) {
+                obj = ((PdfIndirectReference) obj).getRefersTo(true);
+            }
+            return obj;
+        }
+
+        @Override
+        public void remove() {
+            parentIterator.remove();
+        }
+    }
+}