sdks/java/basys.sdk/src/main/java/org/eclipse/basyx/vab/coder/json/serialization/GSONTools.java - basyx/basyx - Git at Google

 /*******************************************************************************
  * Copyright (C) 2021 the Eclipse BaSyx Authors
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  ******************************************************************************/
 package org.eclipse.basyx.vab.coder.json.serialization;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.math.BigInteger;
 import java.util.Base64;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonNull;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonPrimitive;

 /**
  * Provides means for (de-)serialization of Primitives (int, double, string,
  * boolean), Maps, Sets and Lists. <br />
  * Since JSON is not able to differentiate between Sets and Lists, additional
  * information is added. When a Collection of objects is serialized, this
  * information is directly added using an "index" key. <br />
  * However, collections of primitives do not allow adding an "index" key. To
  * handle this, a type tag is added on the same level as the collection. For
  * more details, see <i>TestJson</i>
  *
  * @author rajashek, schnicke
  *
  */
 public class GSONTools implements Serializer {

 	private static Logger logger = LoggerFactory.getLogger(GSONTools.class);

 	// Used string constants
 	public static final String OPERATION = "operation";
 	public static final String LAMBDA = "lambda";
 	public static final String BASYXFUNCTIONTYPE = "_basyxFunctionType";
 	public static final String BASYXINVOCABLE = "_basyxInvocable";
 	public static final String BASYXFUNCTIONVALUE = "_basyxFunctionValue";

 	/**
 	 * JsonParser reference
 	 */
 	protected static JsonParser parser = new JsonParser();

 	/**
 	 * Type factory
 	 */
 	protected GSONToolsFactory toolsFactory = null;

 	/**
 	 * Flag to remove null values from serialized JSON
 	 */
 	private boolean removeNull = true;

 	/**
 	 * Flag to remove empty arrays from serialized JSON
 	 */
 	private boolean removeEmpty = false;

 	/**
 	 * Constructor
 	 */
 	public GSONTools(GSONToolsFactory factory) {
 		// Store factory reference
 		toolsFactory = factory;
 	}

 	/**
 	 * Constructor
 	 */
 	public GSONTools(GSONToolsFactory factory, boolean removeNull, boolean removeEmpty) {
 		this(factory);
 		this.removeNull = removeNull;
 		this.removeEmpty = removeEmpty;
 	}

 	/**
 	 * Set factory instance
 	 */
 	public void setFactory(GSONToolsFactory newFactoryInstance) {
 		// Store factory instance
 		toolsFactory = newFactoryInstance;
 	}

 	@Override
 	public Object deserialize(String str) {
 		JsonElement elem = parser.parse(str);
 		return deserializeJsonElement(elem);
 	}

 	@Override
 	public String serialize(Object obj) {
 		JsonElement elem = serializeObject(obj);
 		// Removing null value if the removeNull flag is on
 		if (removeNull) {
 			// Gson#toJson removes null automatically
 			Gson gson = new Gson();
 			return gson.toJson(elem);
 		} else {
 			return elem.toString();
 		}
 	}

 	/**
 	 * Serialized an arbitrary object to a JsonElement
 	 *
 	 * @param obj
 	 * @return
 	 */
 	@SuppressWarnings("unchecked")
 	private JsonElement serializeObject(Object obj) {
 		if (obj == null) {
 			return JsonNull.INSTANCE;
 		} else if (obj.getClass().isPrimitive() || isWrapperType(obj.getClass()) || obj instanceof String || obj instanceof Number) {
 			return serializePrimitive(obj);
 		} else if (obj instanceof Map<?, ?>) {
 			return serializeMap((Map<String, Object>) obj);
 		} else if (obj instanceof Collection<?>) {
 			return serializeCollection((Collection<Object>) obj);
 		} else if (isFunction(obj)) {
 			return serializeFunction(obj);
 		}
 		throw new RuntimeException("Unknown element!");
 	}

 	/**
 	 * Deserializes a JsonElement to an object
 	 *
 	 * @param elem
 	 * @return
 	 */
 	private Object deserializeJsonElement(JsonElement elem) {
 		if (elem.isJsonPrimitive()) {
 			return deserializeJsonPrimitive(elem.getAsJsonPrimitive());
 		} else if (elem.isJsonObject()) {
 			return deserializeJsonObject(elem.getAsJsonObject());
 		} else if (elem.isJsonArray()) {
 			return deserializeJsonArray(elem.getAsJsonArray());
 		}
 		return null;
 	}

 	/**
 	 * Indicates if a class is a wrapper type, e.g. <i>Integer</i> for <i>int</i>
 	 *
 	 * @param clazz
 	 * @return
 	 */
 	private static boolean isWrapperType(Class<?> clazz) {
 		return clazz.equals(Boolean.class) || clazz.equals(Integer.class) || clazz.equals(Character.class) || clazz.equals(Byte.class) || clazz.equals(Short.class) || clazz.equals(Double.class) || clazz.equals(Long.class)
 				|| clazz.equals(Float.class);
 	}

 	/**
 	 * Deserializes a JsonPrimitive to either string, int, double or boolean
 	 *
 	 * @param primitive
 	 * @return
 	 */
 	private Object deserializeJsonPrimitive(JsonPrimitive primitive) {
 		if (primitive.isNumber()) {
 			if (primitive.getAsString().contains(".")) {
 				return primitive.getAsDouble();
 			} else {
 				// Get value as Big integer
 				BigInteger tmp= primitive.getAsBigInteger();
 				if (BigInteger.valueOf(Integer.MAX_VALUE).compareTo(tmp) >= 0 && BigInteger.valueOf(Integer.MIN_VALUE).compareTo(tmp) <= 0) {
 					// convert to int
 					return primitive.getAsInt();
 				} else if (BigInteger.valueOf(Long.MAX_VALUE).compareTo(tmp) >= 0 && BigInteger.valueOf(Long.MIN_VALUE).compareTo(tmp) <= 0) {
 					// convert to long
 					return primitive.getAsLong();
 				} else {
 					// for types NonNegativeInteger, NonPositiveInteger, NegativeInteger,
 					// PositiveInteger
 					return tmp;
 				}
 			}
 		} else if (primitive.isBoolean()) {
 			return primitive.getAsBoolean();
 		} else {
 			return primitive.getAsString();
 		}
 	}


 	/**
 	 * Serializes either string, number or boolean to a JsonPrimitive
 	 *
 	 * @param primitive
 	 * @return
 	 */
 	private JsonPrimitive serializePrimitive(Object primitive) {
 		if (primitive instanceof Number) {
 			return new JsonPrimitive((Number) primitive);
 		} else if (primitive instanceof Boolean) {
 			return new JsonPrimitive((Boolean) primitive);
 		} else {
 			return new JsonPrimitive((String) primitive);
 		}
 	}

 	/**
 	 * Deserializes a JsonObject to either a map, an operations or an arbitrary
 	 * serializable object
 	 *
 	 * @param map
 	 * @return
 	 */
 	private Object deserializeJsonObject(JsonObject map) {
 		if (map.has(BASYXFUNCTIONTYPE)) {
 			String functionType = map.get(BASYXFUNCTIONTYPE).getAsString();
 			if (functionType.equals(OPERATION)) {
 				return BASYXINVOCABLE;
 			} else if (functionType.equals(LAMBDA)) {
 				return deserializeObjectFromString(map.get(BASYXFUNCTIONVALUE).getAsString());
 			} else {
 				throw new RuntimeException("Unknown function type " + functionType + "!");
 			}
 		} else {
 			return deserializeObject(map);
 		}
 	}

 	/**
 	 * Deserializes a JsonObject to a map
 	 *
 	 * @param map
 	 * @return
 	 */
 	private Map<String, Object> deserializeObject(JsonObject map) {
 		Map<String, Object> ret = toolsFactory.createMap();
 		for (String k : map.keySet()) {
 			ret.put(k, deserializeJsonElement(map.get(k)));
 		}
 		return ret;
 	}

 	/**
 	 * Serializes a Map to a JsonObject
 	 *
 	 * @param map
 	 * @return
 	 */
 	private JsonObject serializeMap(Map<String, Object> map) {
 		JsonObject obj = new JsonObject();
 		for (Entry<String, Object> entry : map.entrySet()) {
 			Object value = entry.getValue();
 			// Remove empty list if removeEmpty flag is on
             if (!removeEmpty || !(value instanceof Collection<?> && ((Collection<?>)value).isEmpty())) {
             	obj.add(entry.getKey(), serializeObject(value));
         	}
 		}
 		return obj;
 	}

 	/**
 	 * Deserializes a JsonArray to a Collection<br/>
 	 * Remark: internally, a List will be used for deserialization & it is assumed, that
 	 * the order in the json equals the correct intended order for the list.
 	 * => The ordering will be preserved in the returned collection
 	 *
 	 * @param array
 	 * @return
 	 */
 	private Collection<Object> deserializeJsonArray(JsonArray array) {
 		Collection<Object> list = toolsFactory.createCollection();
 		for (JsonElement element : array) {
 			list.add(deserializeJsonElement(element));
 		}
 		return list;
 	}

 	/**
 	 * Checks if an object is a lambda function
 	 *
 	 * @param value
 	 * @return
 	 */
 	private boolean isFunction(Object value) {
 		return (value instanceof Supplier<?>)
 				|| (value instanceof Function<?, ?>)
 				|| (value instanceof Consumer<?>)
 				|| (value instanceof BiConsumer<?, ?>);
 	}

 	/**
 	 * Serializes a list to a JsonArray and adds index where appropriate
 	 *
 	 * @param list
 	 * @return
 	 */
 	private JsonArray serializeCollection(Collection<Object> collection) {
 		JsonArray array = new JsonArray();
 		collection.stream().map(this::serializeObject).forEach(array::add);
 		return array;
 	}

 	/**
 	 * Serializes a function if possible
 	 *
 	 * @param function
 	 * @return
 	 */
 	private JsonObject serializeFunction(Object function) {
 		if (function instanceof Serializable) {
 			return serializeSerializableOperation((Serializable) function);
 		} else {
 			return serializeNotSerializableOperation(function);
 		}
 	}

 	/**
 	 * Read an object from Base64 string.
 	 */
 	protected Object deserializeObjectFromString(String s) {
 		Object result = null;
 		byte[] data = Base64.getDecoder().decode(s);
 		InputStream byteStream = new ByteArrayInputStream(data);

 		try (ObjectInputStream stream = new ObjectInputStream(byteStream)) {
 			result = stream.readObject();
 		} catch (IOException | ClassNotFoundException e) {
 			logger.error("Exception in deserializeObjectFromString", e);
 		}
 		return result;
 	}

 	/**
 	 * Write the object to a Base64 string.
 	 */
 	protected String serializeObjectToString(Serializable obj) {
 		ByteArrayOutputStream outStream = new ByteArrayOutputStream();

 		try (ObjectOutputStream oos = new ObjectOutputStream(outStream)) {
 			oos.writeObject(obj);
 		} catch (IOException e) {
 			logger.error("Exception in serializeObjectToString", e);
 		}

 		byte[] data = outStream.toByteArray();
 		return Base64.getEncoder().encodeToString(data);
 	}

 	/**
 	 * Serialize an operation descriptor
 	 */
 	private JsonObject serializeSerializableOperation(Serializable value) {
 		JsonObject target = new JsonObject();
 		// Serializable functions will be serialized.
 		target.add(BASYXFUNCTIONTYPE, new JsonPrimitive(LAMBDA));

 		String serialized = serializeObjectToString(value);
 		target.add(BASYXFUNCTIONVALUE, new JsonPrimitive(serialized));

 		return target;
 	}

 	/**
 	 * Serializes a NonSerializableOperation to a String indicating that fact
 	 *
 	 * @param function
 	 * @return
 	 */
 	private JsonObject serializeNotSerializableOperation(Object function) {
 		JsonObject target = new JsonObject();
 		// Not serializable functions will be not be serialized.
 		target.add(BASYXFUNCTIONTYPE, new JsonPrimitive(OPERATION));

 		return target;
 	}
 }
	/*******************************************************************************
	* Copyright (C) 2021 the Eclipse BaSyx Authors
	*
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	******************************************************************************/
	package org.eclipse.basyx.vab.coder.json.serialization;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.Serializable;
	import java.math.BigInteger;
	import java.util.Base64;
	import java.util.Collection;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.function.BiConsumer;
	import java.util.function.Consumer;
	import java.util.function.Function;
	import java.util.function.Supplier;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import com.google.gson.Gson;
	import com.google.gson.JsonArray;
	import com.google.gson.JsonElement;
	import com.google.gson.JsonNull;
	import com.google.gson.JsonObject;
	import com.google.gson.JsonParser;
	import com.google.gson.JsonPrimitive;

	/**
	* Provides means for (de-)serialization of Primitives (int, double, string,
	* boolean), Maps, Sets and Lists. <br />
	* Since JSON is not able to differentiate between Sets and Lists, additional
	* information is added. When a Collection of objects is serialized, this
	* information is directly added using an "index" key. <br />
	* However, collections of primitives do not allow adding an "index" key. To
	* handle this, a type tag is added on the same level as the collection. For
	* more details, see <i>TestJson</i>
	*
	* @author rajashek, schnicke
	*
	*/
	public class GSONTools implements Serializer {

	private static Logger logger = LoggerFactory.getLogger(GSONTools.class);

	// Used string constants
	public static final String OPERATION = "operation";
	public static final String LAMBDA = "lambda";
	public static final String BASYXFUNCTIONTYPE = "_basyxFunctionType";
	public static final String BASYXINVOCABLE = "_basyxInvocable";
	public static final String BASYXFUNCTIONVALUE = "_basyxFunctionValue";

	/**
	* JsonParser reference
	*/
	protected static JsonParser parser = new JsonParser();

	/**
	* Type factory
	*/
	protected GSONToolsFactory toolsFactory = null;

	/**
	* Flag to remove null values from serialized JSON
	*/
	private boolean removeNull = true;

	/**
	* Flag to remove empty arrays from serialized JSON
	*/
	private boolean removeEmpty = false;

	/**
	* Constructor
	*/
	public GSONTools(GSONToolsFactory factory) {
	// Store factory reference
	toolsFactory = factory;
	}

	/**
	* Constructor
	*/
	public GSONTools(GSONToolsFactory factory, boolean removeNull, boolean removeEmpty) {
	this(factory);
	this.removeNull = removeNull;
	this.removeEmpty = removeEmpty;
	}

	/**
	* Set factory instance
	*/
	public void setFactory(GSONToolsFactory newFactoryInstance) {
	// Store factory instance
	toolsFactory = newFactoryInstance;
	}

	@Override
	public Object deserialize(String str) {
	JsonElement elem = parser.parse(str);
	return deserializeJsonElement(elem);
	}

	@Override
	public String serialize(Object obj) {
	JsonElement elem = serializeObject(obj);
	// Removing null value if the removeNull flag is on
	if (removeNull) {
	// Gson#toJson removes null automatically
	Gson gson = new Gson();
	return gson.toJson(elem);
	} else {
	return elem.toString();
	}
	}

	/**
	* Serialized an arbitrary object to a JsonElement
	*
	* @param obj
	* @return
	*/
	@SuppressWarnings("unchecked")
	private JsonElement serializeObject(Object obj) {
	if (obj == null) {
	return JsonNull.INSTANCE;
	} else if (obj.getClass().isPrimitive() \|\| isWrapperType(obj.getClass()) \|\| obj instanceof String \|\| obj instanceof Number) {
	return serializePrimitive(obj);
	} else if (obj instanceof Map<?, ?>) {
	return serializeMap((Map<String, Object>) obj);
	} else if (obj instanceof Collection<?>) {
	return serializeCollection((Collection<Object>) obj);
	} else if (isFunction(obj)) {
	return serializeFunction(obj);
	}
	throw new RuntimeException("Unknown element!");
	}

	/**
	* Deserializes a JsonElement to an object
	*
	* @param elem
	* @return
	*/
	private Object deserializeJsonElement(JsonElement elem) {
	if (elem.isJsonPrimitive()) {
	return deserializeJsonPrimitive(elem.getAsJsonPrimitive());
	} else if (elem.isJsonObject()) {
	return deserializeJsonObject(elem.getAsJsonObject());
	} else if (elem.isJsonArray()) {
	return deserializeJsonArray(elem.getAsJsonArray());
	}
	return null;
	}

	/**
	* Indicates if a class is a wrapper type, e.g. <i>Integer</i> for <i>int</i>
	*
	* @param clazz
	* @return
	*/
	private static boolean isWrapperType(Class<?> clazz) {
	return clazz.equals(Boolean.class) \|\| clazz.equals(Integer.class) \|\| clazz.equals(Character.class) \|\| clazz.equals(Byte.class) \|\| clazz.equals(Short.class) \|\| clazz.equals(Double.class) \|\| clazz.equals(Long.class)
	\|\| clazz.equals(Float.class);
	}

	/**
	* Deserializes a JsonPrimitive to either string, int, double or boolean
	*
	* @param primitive
	* @return
	*/
	private Object deserializeJsonPrimitive(JsonPrimitive primitive) {
	if (primitive.isNumber()) {
	if (primitive.getAsString().contains(".")) {
	return primitive.getAsDouble();
	} else {
	// Get value as Big integer
	BigInteger tmp= primitive.getAsBigInteger();
	if (BigInteger.valueOf(Integer.MAX_VALUE).compareTo(tmp) >= 0 && BigInteger.valueOf(Integer.MIN_VALUE).compareTo(tmp) <= 0) {
	// convert to int
	return primitive.getAsInt();
	} else if (BigInteger.valueOf(Long.MAX_VALUE).compareTo(tmp) >= 0 && BigInteger.valueOf(Long.MIN_VALUE).compareTo(tmp) <= 0) {
	// convert to long
	return primitive.getAsLong();
	} else {
	// for types NonNegativeInteger, NonPositiveInteger, NegativeInteger,
	// PositiveInteger
	return tmp;
	}
	}
	} else if (primitive.isBoolean()) {
	return primitive.getAsBoolean();
	} else {
	return primitive.getAsString();
	}
	}


	/**
	* Serializes either string, number or boolean to a JsonPrimitive
	*
	* @param primitive
	* @return
	*/
	private JsonPrimitive serializePrimitive(Object primitive) {
	if (primitive instanceof Number) {
	return new JsonPrimitive((Number) primitive);
	} else if (primitive instanceof Boolean) {
	return new JsonPrimitive((Boolean) primitive);
	} else {
	return new JsonPrimitive((String) primitive);
	}
	}

	/**
	* Deserializes a JsonObject to either a map, an operations or an arbitrary
	* serializable object
	*
	* @param map
	* @return
	*/
	private Object deserializeJsonObject(JsonObject map) {
	if (map.has(BASYXFUNCTIONTYPE)) {
	String functionType = map.get(BASYXFUNCTIONTYPE).getAsString();
	if (functionType.equals(OPERATION)) {
	return BASYXINVOCABLE;
	} else if (functionType.equals(LAMBDA)) {
	return deserializeObjectFromString(map.get(BASYXFUNCTIONVALUE).getAsString());
	} else {
	throw new RuntimeException("Unknown function type " + functionType + "!");
	}
	} else {
	return deserializeObject(map);
	}
	}

	/**
	* Deserializes a JsonObject to a map
	*
	* @param map
	* @return
	*/
	private Map<String, Object> deserializeObject(JsonObject map) {
	Map<String, Object> ret = toolsFactory.createMap();
	for (String k : map.keySet()) {
	ret.put(k, deserializeJsonElement(map.get(k)));
	}
	return ret;
	}

	/**
	* Serializes a Map to a JsonObject
	*
	* @param map
	* @return
	*/
	private JsonObject serializeMap(Map<String, Object> map) {
	JsonObject obj = new JsonObject();
	for (Entry<String, Object> entry : map.entrySet()) {
	Object value = entry.getValue();
	// Remove empty list if removeEmpty flag is on
	if (!removeEmpty \|\| !(value instanceof Collection<?> && ((Collection<?>)value).isEmpty())) {
	obj.add(entry.getKey(), serializeObject(value));
	}
	}
	return obj;
	}

	/**
	* Deserializes a JsonArray to a Collection<br/>
	* Remark: internally, a List will be used for deserialization & it is assumed, that
	* the order in the json equals the correct intended order for the list.
	* => The ordering will be preserved in the returned collection
	*
	* @param array
	* @return
	*/
	private Collection<Object> deserializeJsonArray(JsonArray array) {
	Collection<Object> list = toolsFactory.createCollection();
	for (JsonElement element : array) {
	list.add(deserializeJsonElement(element));
	}
	return list;
	}

	/**
	* Checks if an object is a lambda function
	*
	* @param value
	* @return
	*/
	private boolean isFunction(Object value) {
	return (value instanceof Supplier<?>)
	\|\| (value instanceof Function<?, ?>)
	\|\| (value instanceof Consumer<?>)
	\|\| (value instanceof BiConsumer<?, ?>);
	}

	/**
	* Serializes a list to a JsonArray and adds index where appropriate
	*
	* @param list
	* @return
	*/
	private JsonArray serializeCollection(Collection<Object> collection) {
	JsonArray array = new JsonArray();
	collection.stream().map(this::serializeObject).forEach(array::add);
	return array;
	}

	/**
	* Serializes a function if possible
	*
	* @param function
	* @return
	*/
	private JsonObject serializeFunction(Object function) {
	if (function instanceof Serializable) {
	return serializeSerializableOperation((Serializable) function);
	} else {
	return serializeNotSerializableOperation(function);
	}
	}

	/**
	* Read an object from Base64 string.
	*/
	protected Object deserializeObjectFromString(String s) {
	Object result = null;
	byte[] data = Base64.getDecoder().decode(s);
	InputStream byteStream = new ByteArrayInputStream(data);

	try (ObjectInputStream stream = new ObjectInputStream(byteStream)) {
	result = stream.readObject();
	} catch (IOException \| ClassNotFoundException e) {
	logger.error("Exception in deserializeObjectFromString", e);
	}
	return result;
	}

	/**
	* Write the object to a Base64 string.
	*/
	protected String serializeObjectToString(Serializable obj) {
	ByteArrayOutputStream outStream = new ByteArrayOutputStream();

	try (ObjectOutputStream oos = new ObjectOutputStream(outStream)) {
	oos.writeObject(obj);
	} catch (IOException e) {
	logger.error("Exception in serializeObjectToString", e);
	}

	byte[] data = outStream.toByteArray();
	return Base64.getEncoder().encodeToString(data);
	}

	/**
	* Serialize an operation descriptor
	*/
	private JsonObject serializeSerializableOperation(Serializable value) {
	JsonObject target = new JsonObject();
	// Serializable functions will be serialized.
	target.add(BASYXFUNCTIONTYPE, new JsonPrimitive(LAMBDA));

	String serialized = serializeObjectToString(value);
	target.add(BASYXFUNCTIONVALUE, new JsonPrimitive(serialized));

	return target;
	}

	/**
	* Serializes a NonSerializableOperation to a String indicating that fact
	*
	* @param function
	* @return
	*/
	private JsonObject serializeNotSerializableOperation(Object function) {
	JsonObject target = new JsonObject();
	// Not serializable functions will be not be serialized.
	target.add(BASYXFUNCTIONTYPE, new JsonPrimitive(OPERATION));

	return target;
	}
	}