Create lists of ValidationError only when necessary

This commit reduces memory usage by only creating a list of
ValidationException objects when the first one in encountered. JSONs
that are valid will gain the most in terms of memory usage, as no lists
will be created. JSONs that are only partially valid will still see
memory usage improvements.

Author: Lionel Montrieux

core/src/main/java/org/everit/json/schema/ArraySchema.java

@@ -1,7 +1,7 @@
 package org.everit.json.schema;
 
-import static java.lang.String.format;
-import static java.util.Objects.requireNonNull;
+import org.everit.json.schema.internal.JSONPrinter;
+import org.json.JSONArray;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -12,8 +12,8 @@
 import java.util.function.IntFunction;
 import java.util.stream.IntStream;
 
-import org.everit.json.schema.internal.JSONPrinter;
-import org.json.JSONArray;
+import static java.lang.String.format;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Array schema validator.
@@ -200,44 +200,42 @@ public boolean requiresArray() {
         return requiresArray;
     }
 
-    private Optional<ValidationException> testItemCount(final JSONArray subject) {
+    private void testItemCount(final JSONArray subject) {
         int actualLength = subject.length();
         if (minItems != null && actualLength < minItems) {
-            return Optional.of(failure("expected minimum item count: " + minItems
+            addValidationException(failure("expected minimum item count: " + minItems
                     + ", found: " + actualLength, "minItems"));
+            return;
         }
         if (maxItems != null && maxItems < actualLength) {
-            return Optional.of(failure("expected maximum item count: " + maxItems
+            addValidationException(failure("expected maximum item count: " + maxItems
                     + ", found: " + actualLength, "maxItems"));
         }
-        return Optional.empty();
     }
 
-    private List<ValidationException> testItems(final JSONArray subject) {
-        List<ValidationException> rval = new ArrayList<>();
+    private void testItems(final JSONArray subject) {
         if (allItemSchema != null) {
             validateItemsAgainstSchema(IntStream.range(0, subject.length()),
                     subject,
                     allItemSchema,
-                    rval::add);
+                    this::addValidationException);
         } else if (itemSchemas != null) {
             if (!additionalItems && subject.length() > itemSchemas.size()) {
-                rval.add(failure(format("expected: [%d] array items, found: [%d]",
+                addValidationException(failure(format("expected: [%d] array items, found: [%d]",
                         itemSchemas.size(), subject.length()), "items"));
             }
             int itemValidationUntil = Math.min(subject.length(), itemSchemas.size());
             validateItemsAgainstSchema(IntStream.range(0, itemValidationUntil),
                     subject,
                     itemSchemas::get,
-                    rval::add);
+                    this::addValidationException);
             if (schemaOfAdditionalItems != null) {
                 validateItemsAgainstSchema(IntStream.range(itemValidationUntil, subject.length()),
                         subject,
                         schemaOfAdditionalItems,
-                        rval::add);
+                        this::addValidationException);
             }
         }
-        return rval;
     }
 
     private void validateItemsAgainstSchema(final IntStream indices, final JSONArray items,
@@ -257,57 +255,57 @@ private void validateItemsAgainstSchema(final IntStream indices, final JSONArray
         }
     }
 
-    private Optional<ValidationException> testUniqueness(final JSONArray subject) {
+    private void testUniqueness(final JSONArray subject) {
         if (subject.length() == 0) {
-            return Optional.empty();
+            return;
         }
         Collection<Object> uniqueItems = new ArrayList<Object>(subject.length());
         for (int i = 0; i < subject.length(); ++i) {
             Object item = subject.get(i);
             for (Object contained : uniqueItems) {
                 if (ObjectComparator.deepEquals(contained, item)) {
-                    return Optional.of(
+                    addValidationException(
                             failure("array items are not unique", "uniqueItems"));
+                    return;
                 }
             }
             uniqueItems.add(item);
         }
-        return Optional.empty();
     }
 
     @Override
     public void validate(final Object subject) {
-        List<ValidationException> failures = new ArrayList<>();
         if (!(subject instanceof JSONArray)) {
             if (requiresArray) {
                 throw failure(JSONArray.class, subject);
             }
         } else {
+            validationExceptions = null;
             JSONArray arrSubject = (JSONArray) subject;
-            testItemCount(arrSubject).ifPresent(failures::add);
+            testItemCount(arrSubject);
             if (uniqueItems) {
-                testUniqueness(arrSubject).ifPresent(failures::add);
+                testUniqueness(arrSubject);
             }
-            failures.addAll(testItems(arrSubject));
-            testContains(arrSubject).ifPresent(failures::add);
+            testItems(arrSubject);
+            testContains(arrSubject);
+        }
+        if (null != validationExceptions) {
+            ValidationException.throwFor(this, validationExceptions);
         }
-        ValidationException.throwFor(this, failures);
     }
 
-    private Optional<ValidationException> testContains(JSONArray arrSubject) {
+    private void testContains(JSONArray arrSubject) {
         if (containedItemSchema == null) {
-            return Optional.empty();
+            return;
         }
         boolean anyMatch = IntStream.range(0, arrSubject.length())
                 .mapToObj(arrSubject::get)
                 .map(item -> ifFails(containedItemSchema, item))
                 .filter(maybeFailure -> !maybeFailure.isPresent())
                 .findFirst()
                 .isPresent();
-        if (anyMatch) {
-            return Optional.empty();
-        } else {
-            return Optional.of(failure("expected at least one array item to match 'contains' schema", "contains"));
+        if (!anyMatch) {
+            addValidationException(failure("expected at least one array item to match 'contains' schema", "contains"));
         }
     }
 

core/src/main/java/org/everit/json/schema/ObjectSchema.java

@@ -3,15 +3,23 @@
 import org.everit.json.schema.internal.JSONPrinter;
 import org.json.JSONObject;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static java.lang.String.format;
 import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toList;
 
@@ -264,101 +272,92 @@ public boolean requiresObject() {
         return requiresObject;
     }
 
-    private List<ValidationException> testAdditionalProperties(final JSONObject subject) {
+    private void testAdditionalProperties(final JSONObject subject) {
         if (!additionalProperties) {
-            return getAdditionalProperties(subject)
+            addValidationExceptions(getAdditionalProperties(subject)
                     .map(unneeded -> format("extraneous key [%s] is not permitted", unneeded))
                     .map(msg -> new ValidationException(this, msg, "additionalProperties"))
-                    .collect(toList());
+                    .collect(toList()));
+            return;
         } else if (schemaOfAdditionalProperties != null) {
             List<String> additionalPropNames = getAdditionalProperties(subject)
                     .collect(toList());
-            List<ValidationException> rval = new ArrayList<ValidationException>();
             for (String propName : additionalPropNames) {
                 Object propVal = subject.get(propName);
                 ifFails(schemaOfAdditionalProperties, propVal)
                         .map(failure -> failure.prepend(propName, this))
-                        .ifPresent(rval::add);
+                        .ifPresent(this::addValidationException);
             }
-            return rval;
         }
-        return emptyList();
     }
 
-    private List<ValidationException> testPatternProperties(final JSONObject subject) {
+    private void testPatternProperties(final JSONObject subject) {
         String[] propNames = JSONObject.getNames(subject);
         if (propNames == null || propNames.length == 0) {
-            return emptyList();
+            return;
         }
-        List<ValidationException> rval = new ArrayList<>();
         for (Entry<Pattern, Schema> entry : patternProperties.entrySet()) {
             for (String propName : propNames) {
                 if (entry.getKey().matcher(propName).find()) {
                     ifFails(entry.getValue(), subject.get(propName))
                             .map(exc -> exc.prepend(propName))
-                            .ifPresent(rval::add);
+                            .ifPresent(this::addValidationException);
                 }
             }
         }
-        return rval;
     }
 
-    private List<ValidationException> testProperties(final JSONObject subject) {
+    private void testProperties(final JSONObject subject) {
         if (propertySchemas != null) {
-            List<ValidationException> rval = new ArrayList<>();
             for (Entry<String, Schema> entry : propertySchemas.entrySet()) {
                 String key = entry.getKey();
                 if (subject.has(key)) {
                     ifFails(entry.getValue(), subject.get(key))
                             .map(exc -> exc.prepend(key))
-                            .ifPresent(rval::add);
+                            .ifPresent(this::addValidationException);
                 }
             }
-            return rval;
         }
-        return emptyList();
     }
 
-    private List<ValidationException> testPropertyDependencies(final JSONObject subject) {
-        return propertyDependencies.keySet().stream()
+    private void testPropertyDependencies(final JSONObject subject) {
+        addValidationExceptions(propertyDependencies.keySet().stream()
                 .filter(subject::has)
                 .flatMap(ifPresent -> propertyDependencies.get(ifPresent).stream())
                 .filter(mustBePresent -> !subject.has(mustBePresent))
                 .map(missingKey -> format("property [%s] is required", missingKey))
                 .map(excMessage -> failure(excMessage, "dependencies"))
-                .collect(toList());
+                .collect(toList()));
     }
 
-    private List<ValidationException> testRequiredProperties(final JSONObject subject) {
-        return requiredProperties.stream()
+    private void testRequiredProperties(final JSONObject subject) {
+        addValidationExceptions(requiredProperties.stream()
                 .filter(key -> !subject.has(key))
                 .map(missingKey -> format("required key [%s] not found", missingKey))
                 .map(excMessage -> failure(excMessage, "required"))
-                .collect(toList());
+                .collect(toList()));
     }
 
-    private List<ValidationException> testSchemaDependencies(final JSONObject subject) {
-        List<ValidationException> rval = new ArrayList<>();
+    private void testSchemaDependencies(final JSONObject subject) {
         for (Map.Entry<String, Schema> schemaDep : schemaDependencies.entrySet()) {
             String propName = schemaDep.getKey();
             if (subject.has(propName)) {
-                ifFails(schemaDep.getValue(), subject).ifPresent(rval::add);
+                ifFails(schemaDep.getValue(), subject).ifPresent(this::addValidationException);
             }
         }
-        return rval;
     }
 
-    private List<ValidationException> testSize(final JSONObject subject) {
+    private void testSize(final JSONObject subject) {
         int actualSize = subject.length();
         if (minProperties != null && actualSize < minProperties.intValue()) {
-            return asList(failure(format("minimum size: [%d], found: [%d]", minProperties, actualSize),
-                    "minProperties"));
+            addValidationExceptions(asList(failure(format("minimum size: [%d], found: [%d]", minProperties, actualSize),
+                    "minProperties")));
+            return;
         }
         if (maxProperties != null && actualSize > maxProperties.intValue()) {
-            return asList(failure(format("maximum size: [%d], found: [%d]", maxProperties, actualSize),
-                    "maxProperties"));
+            addValidationExceptions(asList(failure(format("maximum size: [%d], found: [%d]", maxProperties, actualSize),
+                    "maxProperties")));
         }
-        return emptyList();
     }
 
     @Override
@@ -368,25 +367,27 @@ public void validate(final Object subject) {
                 throw failure(JSONObject.class, subject);
             }
         } else {
-            List<ValidationException> failures = new ArrayList<>();
+            validationExceptions = null;
             JSONObject objSubject = (JSONObject) subject;
-            failures.addAll(testProperties(objSubject));
-            failures.addAll(testRequiredProperties(objSubject));
-            failures.addAll(testAdditionalProperties(objSubject));
-            failures.addAll(testSize(objSubject));
-            failures.addAll(testPropertyDependencies(objSubject));
-            failures.addAll(testSchemaDependencies(objSubject));
-            failures.addAll(testPatternProperties(objSubject));
-            failures.addAll(testPropertyNames(objSubject));
-            ValidationException.throwFor(this, failures);
+            testProperties(objSubject);
+            testRequiredProperties(objSubject);
+            testAdditionalProperties(objSubject);
+            testSize(objSubject);
+            testPropertyDependencies(objSubject);
+            testSchemaDependencies(objSubject);
+            testPatternProperties(objSubject);
+            testPropertyNames(objSubject);
+            if (null != validationExceptions) {
+                ValidationException.throwFor(this, validationExceptions);
+            }
         }
     }
 
-    private Collection<? extends ValidationException> testPropertyNames(JSONObject subject) {
+    private void testPropertyNames(JSONObject subject) {
         if (propertyNameSchema != null) {
             String[] names = JSONObject.getNames(subject);
             if (names == null || names.length == 0) {
-                return emptyList();
+                return;
             }
             Collection<ValidationException> failures = Arrays.stream(names)
                     .map(name -> {
@@ -399,9 +400,8 @@ private Collection<? extends ValidationException> testPropertyNames(JSONObject s
                     })
                     .filter(Objects::nonNull)
                     .collect(toList());
-            return failures;
+            validationExceptions.addAll(failures);
         }
-        return emptyList();
     }
 
     @Override

core/src/main/java/org/everit/json/schema/Schema.java

@@ -1,10 +1,12 @@
 package org.everit.json.schema;
 
 import org.everit.json.schema.internal.JSONPrinter;
-import org.json.JSONPointer;
 import org.json.JSONWriter;
 
 import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -61,6 +63,8 @@ public Builder<S> schemaLocation(String schemaLocation) {
 
     protected final String schemaLocation;
 
+    protected List<ValidationException> validationExceptions = null;
+
     /**
      * Constructor.
      *
@@ -222,4 +226,18 @@ protected ValidationException failure(Class<?> expectedType, Object actualValue)
     protected boolean canEqual(final Object other) {
         return (other instanceof Schema);
     }
+
+    protected void addValidationException(ValidationException e) {
+        if (null == validationExceptions) {
+            validationExceptions = new ArrayList<>();
+        }
+        validationExceptions.add(e);
+    }
+
+    protected void addValidationExceptions(Collection<ValidationException> c) {
+        if (null == validationExceptions) {
+            validationExceptions = new ArrayList<>();
+        }
+        validationExceptions.addAll(c);
+    }
 }