- removed unused ClassFactories.

- added ability to specify notCustmoRead/Written classes in notCustomRead.txt and notCustomWritten.txt

Author: jdereg

README.md

@@ -10,7 +10,7 @@ Key Features:
 - Supports polymorphic types and complex object graphs
 - Zero external dependencies (other than java-util)
 - Fully compatible with both JPMS and OSGi environments
-- Lightweight (`json-io.jar` is 256K, `java-util` is 449K)
+- Lightweight (`json-io.jar` is 255K, `java-util` is 450K)
 - Compatible with JDK 1.8 through JDK 23
 - Extensive configuration options via `ReadOptionsBuilder` and `WriteOptionsBuilder`
 - Featured on [json.org](http://json.org)
@@ -31,15 +31,15 @@ ___
 To include in your project:
 ##### Gradle
 ```groovy
-implementation 'com.cedarsoftware:json-io:4.51.0'
+implementation 'com.cedarsoftware:json-io:4.52.0'
 ```
 
 ##### Maven
 ```xml
  <dependency>
    <groupId>com.cedarsoftware</groupId>
    <artifactId>json-io</artifactId>
-   <version>4.51.0</version>
+   <version>4.52.0</version>
  </dependency>
 ```
 ___
@@ -51,18 +51,18 @@ ___
 >#### [Revision History](/changelog.md)
 
 ## Releases
->### 4.51.0 (current)
->- [ ] **Version**: [4.51.0](https://www.javadoc.io/doc/com.cedarsoftware/json-io/4.51.0/index.html)
+>### 4.52.0 (current)
+>- [ ] **Version**: [4.52.0](https://www.javadoc.io/doc/com.cedarsoftware/json-io/4.52.0/index.html)
 >- [ ] **Bundling**: Both JPMS (Java Platform Module System) and OSGi (Open Service Gateway initiative)
 >- [ ] **Maintained**: Fully
 >- [ ] **Java Package**: com.cedarsoftware.io
 >- [ ] **Java**: JDK1.8+ (Class file 52 format, includes module-info.class - multi-release JAR)
 >- [ ] **API**
->  - Static methods on [JsonIo](https://www.javadoc.io/doc/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonIo.html): [toJson()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonIo.html#toJson(java.lang.Object,com.cedarsoftware.io.WriteOptions)), [toJava()](https://www.javadoc.io/doc/com.cedarsoftware/json-io/latest/com/cedarsoftware/io/JsonIo.html#toJava(com.cedarsoftware.io.JsonObject,com.cedarsoftware.io.ReadOptions)), [formatJson()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonIo.html#formatJson(java.lang.String)), [deepCopy()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonIo.html#deepCopy(java.lang.Object,com.cedarsoftware.io.ReadOptions,com.cedarsoftware.io.WriteOptions))
+>  - Static methods on [JsonIo](https://www.javadoc.io/doc/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonIo.html): [toJson()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonIo.html#toJson(java.lang.Object,com.cedarsoftware.io.WriteOptions)), [toJava()](https://www.javadoc.io/doc/com.cedarsoftware/json-io/latest/com/cedarsoftware/io/JsonIo.html#toJava(com.cedarsoftware.io.JsonObject,com.cedarsoftware.io.ReadOptions)), [formatJson()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonIo.html#formatJson(java.lang.String)), [deepCopy()](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonIo.html#deepCopy(java.lang.Object,com.cedarsoftware.io.ReadOptions,com.cedarsoftware.io.WriteOptions))
 >  - Use [ReadOptionsBuilder](/user-guide-readOptions.md) and [WriteOptionsBuilder](/user-guide-writeOptions.md) to configure `JsonIo`
->  - Use [JsonReader.ClassFactory](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonReader.ClassFactory.html) for difficult classes (hard to instantiate & fill)
->  - Use [JsonWriter.JsonClassWriter](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.51.0/com/cedarsoftware/io/JsonWriter.JsonClassWriter.html) to customize the output JSON for a particular class
->- [ ] Updates will be 4.52.0, 4.53.0, ...
+>  - Use [JsonReader.ClassFactory](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonReader.ClassFactory.html) for difficult classes (hard to instantiate & fill)
+>  - Use [JsonWriter.JsonClassWriter](https://www.javadoc.io/static/com.cedarsoftware/json-io/4.52.0/com/cedarsoftware/io/JsonWriter.JsonClassWriter.html) to customize the output JSON for a particular class
+>- [ ] Updates will be 4.53.0, 4.54.0, ...
 >### 4.14.x (supported)
 >- [ ] **Version**: [4.14.3](https://www.javadoc.io/doc/com.cedarsoftware/json-io/4.14.3/index.html)
 >- [ ] **Bundling**: Both JPMS (Java Platform Module System) and OSGi (Open Service Gateway initiative)

changelog.md

@@ -1,4 +1,10 @@
 ### Revision History
+#### 4.52.0 CompactMap and CompactSet Enhancements
+* `CompactMap` and `CompactSet` JSON formats improved - match historical formats, except when using builder pattern.
+* `ByteBuffer and CharBuffer` converstions to/from `Map` added.
+* Performance improvements in JSON serialization and deserialization.
+* Code simplification related to instance creation for common types.
+* Updated [java-util](https://github.com/jdereg/java-util/blob/master/changelog.md) from `3.2.0` to `3.3.0.`
 #### 4.51.0 CompactMap and CompactSet Enhancements
 * **JSON Serialization Improvements**
   * Implemented specialized JSON serialization for `CompactMap` and `CompactSet` with optimized format

pom.xml

@@ -5,7 +5,7 @@
     <groupId>com.cedarsoftware</groupId>
     <artifactId>json-io</artifactId>
     <packaging>bundle</packaging>
-    <version>4.51.0</version>
+    <version>4.52.0</version>
     <description>Java JSON serialization</description>
     <url>https://github.com/jdereg/json-io</url>
 
@@ -26,7 +26,7 @@
         <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss.SSSZ</maven.build.timestamp.format>
         <!-- remove source encoding warnings from maven output -->
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <version.java-util>3.2.0</version.java-util>
+        <version.java-util>3.3.0</version.java-util>
         <!-- testing only -->
         <version.junit-jupiter-params>5.11.4</version.junit-jupiter-params>
         <version.assertj-core>3.27.3</version.assertj-core>

src/main/java/com/cedarsoftware/io/JsonReader.java

@@ -326,7 +326,6 @@ private boolean isRootArray(Object value) {
      * Handles the case where the top-level element is an array (either a real Java array,
      * or a JsonObject that’s flagged as an array).
      */
-    @SuppressWarnings("unchecked")
     private Object handleArrayRoot(Type rootType, Object returnValue) {
         JsonObject rootObj;
 
@@ -479,7 +478,6 @@ private <T> void verifyRootType(Type rootType) {
      * @return the resolved and, if necessary, converted object graph, or the raw {@code JsonObject}, depending on the mode
      *         and convertibility.
      */
-    @SuppressWarnings("unchecked")
     private Object handleObjectRoot(Type rootType, JsonObject jsonObj) {
         boolean returnJson = readOptions.isReturningJsonObjects();
 

src/main/java/com/cedarsoftware/io/JsonWriter.java

@@ -24,6 +24,8 @@
 
 import com.cedarsoftware.io.reflect.Accessor;
 import com.cedarsoftware.util.ClassUtilities;
+import com.cedarsoftware.util.CompactMap;
+import com.cedarsoftware.util.CompactSet;
 import com.cedarsoftware.util.FastWriter;
 
 import static com.cedarsoftware.io.JsonValue.ENUM;
@@ -240,9 +242,6 @@ private void tab(Writer output, int delta) throws IOException
      */
     public boolean writeUsingCustomWriter(Object o, boolean showType, Writer output) {
         Class<?> c = o.getClass();
-        if (writeOptions.isNotCustomWrittenClass(c)) {
-            return false;
-        }
 
         try {
             return writeCustom(c, o, !writeOptions.isNeverShowingType() && showType, output);
@@ -251,6 +250,29 @@ public boolean writeUsingCustomWriter(Object o, boolean showType, Writer output)
         }
     }
 
+    private boolean isCustomWrittenClass(Class<?> c, Object o) {
+        // Exit early if the class is explicitly marked as not-custom-written.
+        if (writeOptions.isNotCustomWrittenClass(c)) {
+            return false;
+        }
+
+        // Exit early if there is no custom writer.
+        if (writeOptions.getCustomWriter(c) == null) {
+            return false;
+        }
+
+        // Exit early if 'o' is a CompactSet, and it is the default CompactSet.
+        if ((o instanceof CompactSet) && ((CompactSet<?>) o).isDefaultCompactSet()) {
+            return false;
+        }
+
+        // Exit early if 'o' is a CompactMap, and it is the default CompactMap.
+        if ((o instanceof CompactMap) && ((CompactMap<?, ?>) o).isDefaultCompactMap()) {
+            return false;
+        }
+        return true;
+    }
+    
     /**
      * Write the passed in array element to the JSON output, if any only if, there is a custom writer
      * for the class of the instance 'o'.
@@ -262,17 +284,13 @@ public boolean writeUsingCustomWriter(Object o, boolean showType, Writer output)
      */
     public boolean writeArrayElementIfMatching(Class<?> arrayComponentClass, Object o, boolean showType, Writer output)
     {
-        if (!arrayComponentClass.isAssignableFrom(o.getClass()) || writeOptions.isNotCustomWrittenClass(o.getClass()))
-        {
+        if (!arrayComponentClass.isAssignableFrom(o.getClass())) {
             return false;
         }
 
-        try
-        {
+        try {
             return writeCustom(arrayComponentClass, o, showType, output);
-        }
-        catch (IOException e)
-        {
+        } catch (IOException e) {
             throw new JsonIoException("Unable to write custom formatted object as array element:", e);
         }
     }
@@ -286,14 +304,14 @@ public boolean writeArrayElementIfMatching(Class<?> arrayComponentClass, Object
      * @return true if the array element was written, false otherwise.
      */
     protected boolean writeCustom(Class<?> clazz, Object o, boolean showType, Writer output) throws IOException {
+        if (!isCustomWrittenClass(clazz, o)) {
+            return false;
+        }
         if (writeOptions.isNeverShowingType()) {
             showType = false;
         }
-        JsonClassWriter closestWriter = writeOptions.getCustomWriter(o.getClass());
 
-        if (closestWriter == null) {
-            return false;
-        }
+        JsonClassWriter closestWriter = writeOptions.getCustomWriter(o.getClass());
 
         if (writeOptionalReference(o)) {
             return true;

src/main/java/com/cedarsoftware/io/ReadOptionsBuilder.java

@@ -19,7 +19,6 @@
 import java.util.regex.Pattern;
 
 import com.cedarsoftware.io.factory.ArrayFactory;
-import com.cedarsoftware.io.factory.ConvertableFactory;
 import com.cedarsoftware.io.factory.EnumClassFactory;
 import com.cedarsoftware.io.factory.ThrowableFactory;
 import com.cedarsoftware.io.reflect.Injector;
@@ -31,6 +30,7 @@
 import com.cedarsoftware.util.ClassUtilities;
 import com.cedarsoftware.util.ClassValueMap;
 import com.cedarsoftware.util.ClassValueSet;
+import com.cedarsoftware.util.ConcurrentSet;
 import com.cedarsoftware.util.Convention;
 import com.cedarsoftware.util.StringUtilities;
 import com.cedarsoftware.util.convert.CommonValues;
@@ -62,11 +62,13 @@
  */
 public class ReadOptionsBuilder {
 
+    // The BASE_* Maps are regular ConcurrentHashMap's because they are not constantly searched, otherwise they would be ClassValueMaps.
     private static final Map<Class<?>, JsonReader.JsonClassReader> BASE_READERS = new ConcurrentHashMap<>();
     private static final Map<Class<?>, JsonReader.ClassFactory> BASE_CLASS_FACTORIES = new ConcurrentHashMap<>();
     private static final Map<String, String> BASE_ALIAS_MAPPINGS = new ConcurrentHashMap<>();
     private static final Map<Class<?>, Class<?>> BASE_COERCED_TYPES = new ConcurrentHashMap<>();
-    private static final Set<Class<?>> BASE_NON_REFS = ConcurrentHashMap.newKeySet();
+    private static final Set<Class<?>> BASE_NON_REFS = new ConcurrentSet<>();
+    private static final Set<Class<?>> BASE_NOT_CUSTOM_READ = new ConcurrentSet<>();
     private static final Map<Class<?>, Map<String, String>> BASE_NONSTANDARD_SETTERS = new ConcurrentHashMap<>();
     private static final Map<Class<?>, Set<String>> BASE_NOT_IMPORTED_FIELDS = new ConcurrentHashMap<>();
 
@@ -84,6 +86,7 @@ public class ReadOptionsBuilder {
         loadBaseAliasMappings(ReadOptionsBuilder::addPermanentAlias);
         loadBaseCoercedTypes();
         loadBaseNonRefs();
+        loadBaseNotCustomReadClasses();
         loadBaseFieldsNotImported();
         loadBaseNonStandardSetters();
 
@@ -118,6 +121,7 @@ public ReadOptionsBuilder() {
         options.customReaderClasses.putAll(BASE_READERS);
         options.classFactoryMap.putAll(BASE_CLASS_FACTORIES);
         options.nonRefClasses.addAll(BASE_NON_REFS);
+        options.notCustomReadClasses.addAll(BASE_NOT_CUSTOM_READ);
         options.excludedFieldNames.putAll(WriteOptionsBuilder.BASE_EXCLUDED_FIELD_NAMES);
         options.fieldsNotImported.putAll(BASE_NOT_IMPORTED_FIELDS);
     }
@@ -277,6 +281,18 @@ public static void addPermanentNonReferenceableClass(Class<?> clazz) {
         BASE_NON_REFS.add(clazz);
     }
 
+    /**
+     * Add a class permanently (JVM lifecycle) to the Not-Custom reader list. All new ReadOptions instances created
+     * will automatically start with this, and you will not need to add it into the ReadOptions through the
+     * ReadOptionsBuilder each time.
+     *
+     * @param clazz Class to be added to the Not-Custom reader list.  A class that is on this list, will not use
+     *              a Custom Reader or Class Factory when read from the JSON.
+     */
+    public static void addPermanentNotCustomReadClass(Class<?> clazz) {
+        BASE_NOT_CUSTOM_READ.add(clazz);
+    }
+
     /**
      * Add a field to a class that should not be imported. Any class's field added here will be excluded when read from
      * the JSON.  The value will not be set (injected) into the associated Java instance.
@@ -302,19 +318,18 @@ public static void addPermanentNonStandardSetter(Class<?> clazz, String fieldNam
     /**
      * @return ReadOptions - built options
      */
-    @SuppressWarnings("unchecked")
     public ReadOptions build() {
         options.clearCaches();
         options.aliasTypeNames = Collections.unmodifiableMap(options.aliasTypeNames);
-        options.coercedTypes = ((ClassValueMap)options.coercedTypes).unmodifiableView();
+        options.coercedTypes = ((ClassValueMap<Class<?>>)options.coercedTypes).unmodifiableView();
         options.notCustomReadClasses = ((ClassValueSet)options.notCustomReadClasses).unmodifiableView();
-        options.customReaderClasses = ((ClassValueMap)options.customReaderClasses).unmodifiableView();
-        options.classFactoryMap = ((ClassValueMap)options.classFactoryMap).unmodifiableView();
+        options.customReaderClasses = ((ClassValueMap<JsonReader.JsonClassReader>)options.customReaderClasses).unmodifiableView();
+        options.classFactoryMap = ((ClassValueMap<JsonReader.ClassFactory>)options.classFactoryMap).unmodifiableView();
         options.nonRefClasses = ((ClassValueSet)options.nonRefClasses).unmodifiableView();
         options.converterOptions.converterOverrides = Collections.unmodifiableMap(options.converterOptions.converterOverrides);
         options.converterOptions.customOptions = Collections.unmodifiableMap(options.converterOptions.customOptions);
-        options.excludedFieldNames = ((ClassValueMap)options.excludedFieldNames).unmodifiableView();
-        options.fieldsNotImported = ((ClassValueMap)options.fieldsNotImported).unmodifiableView();
+        options.excludedFieldNames = ((ClassValueMap<Set<String>>)options.excludedFieldNames).unmodifiableView();
+        options.fieldsNotImported = ((ClassValueMap<Set<String>>)options.fieldsNotImported).unmodifiableView();
         options.fieldFilters = Collections.unmodifiableList(options.fieldFilters);
         options.injectorFactories = Collections.unmodifiableList(options.injectorFactories);
         options.customOptions = Collections.unmodifiableMap(options.customOptions);
@@ -766,9 +781,7 @@ private static void loadBaseClassFactory() {
                 continue;
             }
 
-            if (factoryClassName.equalsIgnoreCase("Convertable")) {
-                addPermanentClassFactory(clazz, new ConvertableFactory<>(clazz));
-            } else if (factoryClassName.equalsIgnoreCase("ArrayFactory")) {
+            if (factoryClassName.equalsIgnoreCase("ArrayFactory")) {
                 addPermanentClassFactory(clazz, new ArrayFactory<>(clazz));
             } else {
                 try {
@@ -1333,10 +1346,30 @@ private static void loadBaseNonRefs() {
         for (String className : set) {
             Class<?> loadedClass = ClassUtilities.forName(className, classLoader);
 
-            if (loadedClass != null) {
+            if (loadedClass == null) {
+                System.out.println("Class: " + className + " undefined.  Cannot be used as non-referenceable class, listed in config/nonRefs.txt");
+            } else {
                 addPermanentNonReferenceableClass(loadedClass);
+            }
+        }
+    }
+
+    /**
+     * Load the list of classes that are intended to not (never) be read using a custom reader.  This is useful to
+     * terminate a "custom reader" inheritance chain.  For example, if you have a custom reader for a base class, and
+     * you don't want it to be used for a subclass, you can add the subclass to this list.
+     */
+    private static void loadBaseNotCustomReadClasses() {
+        final Set<String> set = MetaUtils.loadSetDefinition("config/notCustomRead.txt");
+        final ClassLoader classLoader = ClassUtilities.getClassLoader(ReadOptionsBuilder.class);
+
+        for (String className : set) {
+            Class<?> loadedClass = ClassUtilities.forName(className, classLoader);
+
+            if (loadedClass == null) {
+                System.out.println("Class: " + className + " undefined.  Cannot be used as to turn off custom reading for this class, listed in config/notCustomRead.txt");
             } else {
-                throw new JsonIoException("Class: " + className + " is undefined.");
+                addPermanentNotCustomReadClass(loadedClass);
             }
         }
     }