Encapsulate JSON logic a little bit more

Not a *lot* more: ideally, the custom encoder+decoder layer would
migrate into the new Json utility class as well in some general form.

But for the moment, this gives a simple entry point into JSON
encoding+decoding usable outside of the Messages class without
needing to import groovy-json classes particularly.

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ctrueden

src/main/java/org/apposed/appose/util/Json.java

@@ -0,0 +1,73 @@
+/*-
+ * #%L
+ * Appose: multi-language interprocess cooperation with shared memory.
+ * %%
+ * Copyright (C) 2023 - 2026 Appose developers.
+ * %%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+package org.apposed.appose.util;
+
+import groovy.json.JsonOutput;
+import groovy.json.JsonSlurper;
+
+/**
+ * Utility class for simple JSON serialization and deserialization.
+ * Encapsulates the Groovy JSON library so that other classes do not
+ * need to import it directly.
+ *
+ * @author Curtis Rueden
+ */
+public final class Json {
+
+	private Json() {
+		// Prevent instantiation of utility class.
+	}
+
+	/**
+	 * Converts an object to a JSON string.
+	 * Supports standard JSON-compatible types:
+	 * {@link java.util.Map}, {@link java.util.List}, {@link String},
+	 * {@link Number}, {@link Boolean}, and {@code null}.
+	 *
+	 * @param obj The object to serialize.
+	 * @return JSON string representation.
+	 */
+	public static String toJson(Object obj) {
+		return JsonOutput.toJson(obj);
+	}
+
+	/**
+	 * Parses a JSON string into a Java object.
+	 * Returns a {@link java.util.Map} for JSON objects,
+	 * a {@link java.util.List} for JSON arrays, or
+	 * a primitive wrapper for scalar values.
+	 *
+	 * @param json The JSON string to parse.
+	 * @return Parsed Java object.
+	 */
+	public static Object parseJson(String json) {
+		return new JsonSlurper().parseText(json);
+	}
+}

src/main/java/org/apposed/appose/util/Messages.java

@@ -30,7 +30,6 @@
 package org.apposed.appose.util;
 
 import groovy.json.JsonGenerator;
-import groovy.json.JsonSlurper;
 import org.apposed.appose.NDArray;
 import org.apposed.appose.SharedMemory;
 
@@ -68,9 +67,9 @@ private Messages() {
 
 	// Registry of class -> (appose_type, encoder) for encoding custom types.
 	private static final Map<Class<?>, String> ENCODER_TYPES = new ConcurrentHashMap<>();
-	private static final Map<Class<?>, Function<Object, Object>> ENCODER_FNS = new ConcurrentHashMap<>();
+	private static final Map<Class<?>, Function<Object, Object>> ENCODERS = new ConcurrentHashMap<>();
 
-	// Registry of appose_type -> factory for decoding custom types.
+	// Registry of appose_type -> decoder for decoding custom types.
 	private static final Map<String, Function<Map<String, Object>, Object>> DECODERS =
 		new ConcurrentHashMap<>();
 
@@ -83,7 +82,7 @@ private Messages() {
 	 * </p>
 	 * <p>
 	 * When decoding, if a JSON object has the given {@code apposeType}, {@code decoder}
-	 * is called with the {@code "data"} field value and should return the
+	 * is called on the  and should return the
 	 * reconstructed object.
 	 * </p>
 	 *
@@ -101,7 +100,7 @@ public static <T> void register(
 		Function<Map<String, Object>, Object> decoder
 	) {
 		ENCODER_TYPES.put(objType, apposeType);
-		ENCODER_FNS.put(objType, (Function<Object, Object>) (Function<?, ?>) encoder);
+		ENCODERS.put(objType, (Function<Object, Object>) (Function<?, ?>) encoder);
 		DECODERS.put(apposeType, decoder);
 	}
 
@@ -158,7 +157,7 @@ public static String encode(Map<?, ?> data) {
 	 */
 	@SuppressWarnings("unchecked")
 	public static Map<String, Object> decode(String json) {
-		return postProcess(new JsonSlurper().parseText(json));
+		return postProcess(Json.parseJson(json));
 	}
 
 	/**
@@ -174,7 +173,6 @@ public static String stackTrace(Throwable t) {
 		return sw.toString();
 	}
 
-
 	// -- Serialization --
 
 	/*
@@ -206,22 +204,22 @@ public static String stackTrace(Throwable t) {
 	*/
 
 	/**
-	 * Checks if a type is natively JSON-serializable by Groovy's built-in JSON encoder.
+	 * Checks if a type is natively JSON-serializable by the built-in
+	 * JSON encoder.
 	 * <p>
 	 * These are the basic JSON types that don't need special handling:
-	 * Map, List, String (and other CharSequences), Number, Boolean, and primitives.
-	 * </p>
-	 * <p>
-	 * Other types either implement {@link ForJson} (and are handled by the ForJson
-	 * converter) or will be auto-proxied as worker_object references when in worker mode.
+	 * Map, List, String (and other CharSequences), Number, Boolean, and
+	 * primitives.
 	 * </p>
 	 * <p>
-	 * Note: This list should remain stable. Types implementing {@link ForJson} are
-	 * handled before the catch-all and do not require changes here.
+	 * Other types are handled by a registered encoder if available
+	 * (see {@link #register(Class, String, Function, Function)}),
+	 * or else will be auto-proxied as {@code worker_object} references
+	 * when in worker mode.
 	 * </p>
 	 *
 	 * @param type The class to check
-	 * @return true if this is a basic JSON type that Groovy can serialize natively
+	 * @return true if this is a basic JSON type that can be serialized natively
 	 */
 	private static boolean isNativelyJsonSerializable(Class<?> type) {
 		return Map.class.isAssignableFrom(type)
@@ -241,7 +239,7 @@ public boolean handles(Class<?> type) {
 
 				@Override
 				public Object convert(Object value, String key) {
-					for (Map.Entry<Class<?>, Function<Object, Object>> entry : ENCODER_FNS.entrySet()) {
+					for (Map.Entry<Class<?>, Function<Object, Object>> entry : ENCODERS.entrySet()) {
 						if (entry.getKey().isAssignableFrom(value.getClass())) {
 							Map<String, Object> map = new LinkedHashMap<>();
 							map.put("appose_type", ENCODER_TYPES.get(entry.getKey()));
@@ -262,7 +260,7 @@ public boolean handles(Class<?> type) {
 					// Only active in worker mode.
 					if (!workerMode) return false;
 
-					// Don't auto-proxy types that Groovy's JSON encoder handles natively.
+					// Don't auto-proxy types that the JSON encoder handles natively.
 					// Registered types are earlier in the chain and will have already claimed theirs.
 					return !isNativelyJsonSerializable(type);
 				}
@@ -306,8 +304,8 @@ private static Object processValue(Object value) {
 					// by Proxies.proxifyWorkerObjects() in Service.Task.handle().
 					return map;
 				}
-				Function<Map<String, Object>, Object> factory = DECODERS.get(appose_type);
-				if (factory != null) return factory.apply(map);
+				Function<Map<String, Object>, Object> decoder = DECODERS.get(appose_type);
+				if (decoder != null) return decoder.apply(map);
 				System.err.println("unknown appose_type \"" + appose_type + "\"");
 			}
 			return map;