java/org/eclipse/lsp4j/jsonrpc/json/adapters/EitherTypeAdapter.java - lsp4j - Git at Google

 /******************************************************************************
  * Copyright (c) 2016-2018 TypeFox and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0,
  * or the Eclipse Distribution License v. 1.0 which is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
  ******************************************************************************/
 package org.eclipse.lsp4j.jsonrpc.json.adapters;

 import java.io.IOException;
 import java.lang.reflect.Type;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.function.Predicate;

 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.jsonrpc.messages.Either3;
 import org.eclipse.lsp4j.jsonrpc.messages.Tuple;

 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonParser;
 import com.google.gson.TypeAdapter;
 import com.google.gson.TypeAdapterFactory;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonToken;
 import com.google.gson.stream.JsonWriter;

 /**
  * Type adapter for {@link Either} and {@link Either3}.
  */
 public class EitherTypeAdapter<L, R> extends TypeAdapter<Either<L, R>> {

 	public static class Factory implements TypeAdapterFactory {

 		@SuppressWarnings({ "rawtypes", "unchecked" })
 		@Override
 		public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
 			if (!TypeUtils.isEither(typeToken.getType())) {
 				return null;
 			}
 			return new EitherTypeAdapter(gson, typeToken);
 		}

 	}

 	/**
 	 * A predicate that is usedful for checking alternatives in case both the left and the right type
 	 * are JSON object types.
 	 */
 	public static class PropertyChecker implements Predicate<JsonElement> {

 		private final String propertyName;
 		private final String expectedValue;
 		private final Class<? extends JsonElement> expectedType;

 		public PropertyChecker(String propertyName) {
 			this.propertyName = propertyName;
 			this.expectedValue = null;
 			this.expectedType = null;
 		}

 		public PropertyChecker(String propertyName, String expectedValue) {
 			this.propertyName = propertyName;
 			this.expectedValue = expectedValue;
 			this.expectedType = null;
 		}

 		public PropertyChecker(String propertyName, Class<? extends JsonElement> expectedType) {
 			this.propertyName = propertyName;
 			this.expectedType = expectedType;
 			this.expectedValue = null;
 		}

 		@Override
 		public boolean test(JsonElement element) {
 			if (element.isJsonObject()) {
 				JsonObject object = element.getAsJsonObject();
 				JsonElement value = object.get(propertyName);
 				if (expectedValue != null)
 					return value != null && value.isJsonPrimitive() && expectedValue.equals(value.getAsString());
 				else if (expectedType != null)
 					return expectedType.isInstance(value);
 				else
 					return value != null;
 			}
 			return false;
 		}

 	}

 	/**
 	 * A predicate for the case that a type alternative is a list.
 	 */
 	public static class ListChecker implements Predicate<JsonElement> {

 		private final Predicate<JsonElement> elementChecker;
 		private final boolean resultIfEmpty;

 		public ListChecker(Predicate<JsonElement> elementChecker) {
 			this(elementChecker, false);
 		}

 		public ListChecker(Predicate<JsonElement> elementChecker, boolean resultIfEmpty) {
 			this.elementChecker = elementChecker;
 			this.resultIfEmpty = resultIfEmpty;
 		}

 		@Override
 		public boolean test(JsonElement t) {
 			if (elementChecker.test(t))
 				return true;
 			if (t.isJsonArray()) {
 				JsonArray array = t.getAsJsonArray();
 				if (array.size() == 0)
 					return resultIfEmpty;
 				for (JsonElement e : array) {
 					if (elementChecker.test(e))
 						return true;
 				}
 			}
 			return false;
 		}

 	}

 	protected final TypeToken<Either<L, R>> typeToken;
 	protected final EitherTypeArgument<L> left;
 	protected final EitherTypeArgument<R> right;
 	protected final Predicate<JsonElement> leftChecker;
 	protected final Predicate<JsonElement> rightChecker;

 	public EitherTypeAdapter(Gson gson, TypeToken<Either<L, R>> typeToken) {
 		this(gson, typeToken, null, null);
 	}

 	public EitherTypeAdapter(Gson gson, TypeToken<Either<L, R>> typeToken, Predicate<JsonElement> leftChecker, Predicate<JsonElement> rightChecker) {
 		this.typeToken = typeToken;
 		Type[] elementTypes = TypeUtils.getElementTypes(typeToken, Either.class);
 		this.left = new EitherTypeArgument<L>(gson, elementTypes[0]);
 		this.right = new EitherTypeArgument<R>(gson, elementTypes[1]);
 		this.leftChecker = leftChecker;
 		this.rightChecker = rightChecker;
 	}

 	@Override
 	public void write(JsonWriter out, Either<L, R> value) throws IOException {
 		if (value == null) {
 			out.nullValue();
 		} else if (value.isLeft()) {
 			left.write(out, value.getLeft());
 		} else {
 			right.write(out, value.getRight());
 		}
 	}

 	@Override
 	public Either<L, R> read(JsonReader in) throws IOException {
 		JsonToken next = in.peek();
 		if (next == JsonToken.NULL) {
 			in.nextNull();
 			return null;
 		}
 		return create(next, in);
 	}

 	protected Either<L, R> create(JsonToken nextToken, JsonReader in) throws IOException {
 		boolean matchesLeft = left.isAssignable(nextToken);
 		boolean matchesRight = right.isAssignable(nextToken);
 		if (matchesLeft && matchesRight) {
 			if (leftChecker != null || rightChecker != null) {
 				JsonElement element = JsonParser.parseReader(in);
 				if (leftChecker != null && leftChecker.test(element))
 					// Parse the left alternative from the JSON element tree
 					return createLeft(left.read(element));
 				if (rightChecker != null && rightChecker.test(element))
 					// Parse the right alternative from the JSON element tree
 					return createRight(right.read(element));
 			}
 			throw new JsonParseException("Ambiguous Either type: token " + nextToken + " matches both alternatives.");
 		} else if (matchesLeft) {
 			// Parse the left alternative from the JSON stream
 			return createLeft(left.read(in));
 		} else if (matchesRight) {
 			// Parse the right alternative from the JSON stream
 			return createRight(right.read(in));
 		} else if (leftChecker != null || rightChecker != null) {
 			// If result is not the list but directly the only item in the list
 			JsonElement element = JsonParser.parseReader(in);
 			if (leftChecker != null && leftChecker.test(element))
 				// Parse the left alternative from the JSON element tree
 				return createLeft(left.read(element));
 			if (rightChecker != null && rightChecker.test(element))
 				// Parse the right alternative from the JSON element tree
 				return createRight(right.read(element));
 		}
 		throw new JsonParseException("Unexpected token " + nextToken + ": expected " + left + " | " + right + " tokens.");
 	}

 	@SuppressWarnings("unchecked")
 	protected Either<L, R> createLeft(L obj) throws IOException {
 		if (Either3.class.isAssignableFrom(typeToken.getRawType()))
 			return (Either<L, R>) Either3.forLeft3(obj);
 		return Either.forLeft(obj);
 	}

 	@SuppressWarnings("unchecked")
 	protected Either<L, R> createRight(R obj) throws IOException {
 		if (Either3.class.isAssignableFrom(typeToken.getRawType()))
 			return (Either<L, R>) Either3.forRight3((Either<?, ?>) obj);
 		return Either.forRight(obj);
 	}

 	protected static class EitherTypeArgument<T> {

 		protected final TypeToken<T> typeToken;
 		protected final TypeAdapter<T> adapter;
 		protected final Collection<JsonToken> expectedTokens;

 		@SuppressWarnings("unchecked")
 		public EitherTypeArgument(Gson gson, Type type) {
 			this.typeToken = (TypeToken<T>) TypeToken.get(type);
 			this.adapter = (type == Object.class) ? (TypeAdapter<T>) new JsonElementTypeAdapter(gson) : gson.getAdapter(this.typeToken);
 			this.expectedTokens = new HashSet<>();
 			for (Type expectedType : TypeUtils.getExpectedTypes(type)) {
 				Class<?> rawType = TypeToken.get(expectedType).getRawType();
 				JsonToken expectedToken = getExpectedToken(rawType);
 				expectedTokens.add(expectedToken);
 			}
 		}

 		protected JsonToken getExpectedToken(Class<?> rawType) {
 			if (rawType.isArray() || Collection.class.isAssignableFrom(rawType) || Tuple.class.isAssignableFrom(rawType)) {
 				return JsonToken.BEGIN_ARRAY;
 			}
 			if (Boolean.class.isAssignableFrom(rawType)) {
 				return JsonToken.BOOLEAN;
 			}
 			if (Number.class.isAssignableFrom(rawType) || Enum.class.isAssignableFrom(rawType)) {
 				return JsonToken.NUMBER;
 			}
 			if (Character.class.isAssignableFrom(rawType) || String.class.isAssignableFrom(rawType)) {
 				return JsonToken.STRING;
 			}
 			return JsonToken.BEGIN_OBJECT;
 		}

 		public boolean isAssignable(JsonToken jsonToken) {
 			return this.expectedTokens.contains(jsonToken);
 		}

 		public void write(JsonWriter out, T value) throws IOException {
 			this.adapter.write(out, value);
 		}

 		public T read(JsonReader in) throws IOException {
 			return this.adapter.read(in);
 		}

 		public T read(JsonElement element) throws IOException {
 			return this.adapter.fromJsonTree(element);
 		}

 		@Override
 		public String toString() {
 			StringBuilder builder = new StringBuilder();
 			for (JsonToken expectedToken : expectedTokens) {
 				if (builder.length() != 0) {
 					builder.append(" | ");
 				}
 				builder.append(expectedToken);
 			}
 			return builder.toString();
 		}

 	}

 }
	/******************************************************************************
	* Copyright (c) 2016-2018 TypeFox and others.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0,
	* or the Eclipse Distribution License v. 1.0 which is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
	******************************************************************************/
	package org.eclipse.lsp4j.jsonrpc.json.adapters;

	import java.io.IOException;
	import java.lang.reflect.Type;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.function.Predicate;

	import org.eclipse.lsp4j.jsonrpc.messages.Either;
	import org.eclipse.lsp4j.jsonrpc.messages.Either3;
	import org.eclipse.lsp4j.jsonrpc.messages.Tuple;

	import com.google.gson.Gson;
	import com.google.gson.JsonArray;
	import com.google.gson.JsonElement;
	import com.google.gson.JsonObject;
	import com.google.gson.JsonParseException;
	import com.google.gson.JsonParser;
	import com.google.gson.TypeAdapter;
	import com.google.gson.TypeAdapterFactory;
	import com.google.gson.reflect.TypeToken;
	import com.google.gson.stream.JsonReader;
	import com.google.gson.stream.JsonToken;
	import com.google.gson.stream.JsonWriter;

	/**
	* Type adapter for {@link Either} and {@link Either3}.
	*/
	public class EitherTypeAdapter<L, R> extends TypeAdapter<Either<L, R>> {

	public static class Factory implements TypeAdapterFactory {

	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
	public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
	if (!TypeUtils.isEither(typeToken.getType())) {
	return null;
	}
	return new EitherTypeAdapter(gson, typeToken);
	}

	}

	/**
	* A predicate that is usedful for checking alternatives in case both the left and the right type
	* are JSON object types.
	*/
	public static class PropertyChecker implements Predicate<JsonElement> {

	private final String propertyName;
	private final String expectedValue;
	private final Class<? extends JsonElement> expectedType;

	public PropertyChecker(String propertyName) {
	this.propertyName = propertyName;
	this.expectedValue = null;
	this.expectedType = null;
	}

	public PropertyChecker(String propertyName, String expectedValue) {
	this.propertyName = propertyName;
	this.expectedValue = expectedValue;
	this.expectedType = null;
	}

	public PropertyChecker(String propertyName, Class<? extends JsonElement> expectedType) {
	this.propertyName = propertyName;
	this.expectedType = expectedType;
	this.expectedValue = null;
	}

	@Override
	public boolean test(JsonElement element) {
	if (element.isJsonObject()) {
	JsonObject object = element.getAsJsonObject();
	JsonElement value = object.get(propertyName);
	if (expectedValue != null)
	return value != null && value.isJsonPrimitive() && expectedValue.equals(value.getAsString());
	else if (expectedType != null)
	return expectedType.isInstance(value);
	else
	return value != null;
	}
	return false;
	}

	}

	/**
	* A predicate for the case that a type alternative is a list.
	*/
	public static class ListChecker implements Predicate<JsonElement> {

	private final Predicate<JsonElement> elementChecker;
	private final boolean resultIfEmpty;

	public ListChecker(Predicate<JsonElement> elementChecker) {
	this(elementChecker, false);
	}

	public ListChecker(Predicate<JsonElement> elementChecker, boolean resultIfEmpty) {
	this.elementChecker = elementChecker;
	this.resultIfEmpty = resultIfEmpty;
	}

	@Override
	public boolean test(JsonElement t) {
	if (elementChecker.test(t))
	return true;
	if (t.isJsonArray()) {
	JsonArray array = t.getAsJsonArray();
	if (array.size() == 0)
	return resultIfEmpty;
	for (JsonElement e : array) {
	if (elementChecker.test(e))
	return true;
	}
	}
	return false;
	}

	}

	protected final TypeToken<Either<L, R>> typeToken;
	protected final EitherTypeArgument<L> left;
	protected final EitherTypeArgument<R> right;
	protected final Predicate<JsonElement> leftChecker;
	protected final Predicate<JsonElement> rightChecker;

	public EitherTypeAdapter(Gson gson, TypeToken<Either<L, R>> typeToken) {
	this(gson, typeToken, null, null);
	}

	public EitherTypeAdapter(Gson gson, TypeToken<Either<L, R>> typeToken, Predicate<JsonElement> leftChecker, Predicate<JsonElement> rightChecker) {
	this.typeToken = typeToken;
	Type[] elementTypes = TypeUtils.getElementTypes(typeToken, Either.class);
	this.left = new EitherTypeArgument<L>(gson, elementTypes[0]);
	this.right = new EitherTypeArgument<R>(gson, elementTypes[1]);
	this.leftChecker = leftChecker;
	this.rightChecker = rightChecker;
	}

	@Override
	public void write(JsonWriter out, Either<L, R> value) throws IOException {
	if (value == null) {
	out.nullValue();
	} else if (value.isLeft()) {
	left.write(out, value.getLeft());
	} else {
	right.write(out, value.getRight());
	}
	}

	@Override
	public Either<L, R> read(JsonReader in) throws IOException {
	JsonToken next = in.peek();
	if (next == JsonToken.NULL) {
	in.nextNull();
	return null;
	}
	return create(next, in);
	}

	protected Either<L, R> create(JsonToken nextToken, JsonReader in) throws IOException {
	boolean matchesLeft = left.isAssignable(nextToken);
	boolean matchesRight = right.isAssignable(nextToken);
	if (matchesLeft && matchesRight) {
	if (leftChecker != null \|\| rightChecker != null) {
	JsonElement element = JsonParser.parseReader(in);
	if (leftChecker != null && leftChecker.test(element))
	// Parse the left alternative from the JSON element tree
	return createLeft(left.read(element));
	if (rightChecker != null && rightChecker.test(element))
	// Parse the right alternative from the JSON element tree
	return createRight(right.read(element));
	}
	throw new JsonParseException("Ambiguous Either type: token " + nextToken + " matches both alternatives.");
	} else if (matchesLeft) {
	// Parse the left alternative from the JSON stream
	return createLeft(left.read(in));
	} else if (matchesRight) {
	// Parse the right alternative from the JSON stream
	return createRight(right.read(in));
	} else if (leftChecker != null \|\| rightChecker != null) {
	// If result is not the list but directly the only item in the list
	JsonElement element = JsonParser.parseReader(in);
	if (leftChecker != null && leftChecker.test(element))
	// Parse the left alternative from the JSON element tree
	return createLeft(left.read(element));
	if (rightChecker != null && rightChecker.test(element))
	// Parse the right alternative from the JSON element tree
	return createRight(right.read(element));
	}
	throw new JsonParseException("Unexpected token " + nextToken + ": expected " + left + " \| " + right + " tokens.");
	}

	@SuppressWarnings("unchecked")
	protected Either<L, R> createLeft(L obj) throws IOException {
	if (Either3.class.isAssignableFrom(typeToken.getRawType()))
	return (Either<L, R>) Either3.forLeft3(obj);
	return Either.forLeft(obj);
	}

	@SuppressWarnings("unchecked")
	protected Either<L, R> createRight(R obj) throws IOException {
	if (Either3.class.isAssignableFrom(typeToken.getRawType()))
	return (Either<L, R>) Either3.forRight3((Either<?, ?>) obj);
	return Either.forRight(obj);
	}

	protected static class EitherTypeArgument<T> {

	protected final TypeToken<T> typeToken;
	protected final TypeAdapter<T> adapter;
	protected final Collection<JsonToken> expectedTokens;

	@SuppressWarnings("unchecked")
	public EitherTypeArgument(Gson gson, Type type) {
	this.typeToken = (TypeToken<T>) TypeToken.get(type);
	this.adapter = (type == Object.class) ? (TypeAdapter<T>) new JsonElementTypeAdapter(gson) : gson.getAdapter(this.typeToken);
	this.expectedTokens = new HashSet<>();
	for (Type expectedType : TypeUtils.getExpectedTypes(type)) {
	Class<?> rawType = TypeToken.get(expectedType).getRawType();
	JsonToken expectedToken = getExpectedToken(rawType);
	expectedTokens.add(expectedToken);
	}
	}

	protected JsonToken getExpectedToken(Class<?> rawType) {
	if (rawType.isArray() \|\| Collection.class.isAssignableFrom(rawType) \|\| Tuple.class.isAssignableFrom(rawType)) {
	return JsonToken.BEGIN_ARRAY;
	}
	if (Boolean.class.isAssignableFrom(rawType)) {
	return JsonToken.BOOLEAN;
	}
	if (Number.class.isAssignableFrom(rawType) \|\| Enum.class.isAssignableFrom(rawType)) {
	return JsonToken.NUMBER;
	}
	if (Character.class.isAssignableFrom(rawType) \|\| String.class.isAssignableFrom(rawType)) {
	return JsonToken.STRING;
	}
	return JsonToken.BEGIN_OBJECT;
	}

	public boolean isAssignable(JsonToken jsonToken) {
	return this.expectedTokens.contains(jsonToken);
	}

	public void write(JsonWriter out, T value) throws IOException {
	this.adapter.write(out, value);
	}

	public T read(JsonReader in) throws IOException {
	return this.adapter.read(in);
	}

	public T read(JsonElement element) throws IOException {
	return this.adapter.fromJsonTree(element);
	}

	@Override
	public String toString() {
	StringBuilder builder = new StringBuilder();
	for (JsonToken expectedToken : expectedTokens) {
	if (builder.length() != 0) {
	builder.append(" \| ");
	}
	builder.append(expectedToken);
	}
	return builder.toString();
	}

	}

	}