643 lines
24 KiB
Java
643 lines
24 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.google.gson.Gson
|
|
* com.google.gson.GsonBuilder
|
|
* com.google.gson.JsonArray
|
|
* com.google.gson.JsonDeserializationContext
|
|
* com.google.gson.JsonElement
|
|
* com.google.gson.JsonObject
|
|
* com.google.gson.JsonParseException
|
|
* com.google.gson.JsonPrimitive
|
|
* com.google.gson.JsonSyntaxException
|
|
* com.google.gson.Strictness
|
|
* com.google.gson.internal.Streams
|
|
* com.google.gson.reflect.TypeToken
|
|
* com.google.gson.stream.JsonReader
|
|
* com.google.gson.stream.JsonWriter
|
|
* org.apache.commons.lang3.StringUtils
|
|
* org.jetbrains.annotations.Contract
|
|
* org.jspecify.annotations.Nullable
|
|
*/
|
|
package net.minecraft.util;
|
|
|
|
import com.google.gson.Gson;
|
|
import com.google.gson.GsonBuilder;
|
|
import com.google.gson.JsonArray;
|
|
import com.google.gson.JsonDeserializationContext;
|
|
import com.google.gson.JsonElement;
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.JsonParseException;
|
|
import com.google.gson.JsonPrimitive;
|
|
import com.google.gson.JsonSyntaxException;
|
|
import com.google.gson.Strictness;
|
|
import com.google.gson.internal.Streams;
|
|
import com.google.gson.reflect.TypeToken;
|
|
import com.google.gson.stream.JsonReader;
|
|
import com.google.gson.stream.JsonWriter;
|
|
import java.io.IOException;
|
|
import java.io.Reader;
|
|
import java.io.StringReader;
|
|
import java.io.StringWriter;
|
|
import java.io.UncheckedIOException;
|
|
import java.io.Writer;
|
|
import java.math.BigDecimal;
|
|
import java.math.BigInteger;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Comparator;
|
|
import java.util.Map;
|
|
import net.minecraft.core.Holder;
|
|
import net.minecraft.core.registries.BuiltInRegistries;
|
|
import net.minecraft.resources.Identifier;
|
|
import net.minecraft.world.item.Item;
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.jetbrains.annotations.Contract;
|
|
import org.jspecify.annotations.Nullable;
|
|
|
|
public class GsonHelper {
|
|
private static final Gson GSON = new GsonBuilder().create();
|
|
|
|
public static boolean isStringValue(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidPrimitive(node, name)) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive(name).isString();
|
|
}
|
|
|
|
public static boolean isStringValue(JsonElement node) {
|
|
if (!node.isJsonPrimitive()) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive().isString();
|
|
}
|
|
|
|
public static boolean isNumberValue(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidPrimitive(node, name)) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive(name).isNumber();
|
|
}
|
|
|
|
public static boolean isNumberValue(JsonElement node) {
|
|
if (!node.isJsonPrimitive()) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive().isNumber();
|
|
}
|
|
|
|
public static boolean isBooleanValue(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidPrimitive(node, name)) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive(name).isBoolean();
|
|
}
|
|
|
|
public static boolean isBooleanValue(JsonElement node) {
|
|
if (!node.isJsonPrimitive()) {
|
|
return false;
|
|
}
|
|
return node.getAsJsonPrimitive().isBoolean();
|
|
}
|
|
|
|
public static boolean isArrayNode(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidNode(node, name)) {
|
|
return false;
|
|
}
|
|
return node.get(name).isJsonArray();
|
|
}
|
|
|
|
public static boolean isObjectNode(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidNode(node, name)) {
|
|
return false;
|
|
}
|
|
return node.get(name).isJsonObject();
|
|
}
|
|
|
|
public static boolean isValidPrimitive(JsonObject node, String name) {
|
|
if (!GsonHelper.isValidNode(node, name)) {
|
|
return false;
|
|
}
|
|
return node.get(name).isJsonPrimitive();
|
|
}
|
|
|
|
public static boolean isValidNode(@Nullable JsonObject node, String name) {
|
|
if (node == null) {
|
|
return false;
|
|
}
|
|
return node.get(name) != null;
|
|
}
|
|
|
|
public static JsonElement getNonNull(JsonObject object, String name) {
|
|
JsonElement result = object.get(name);
|
|
if (result == null || result.isJsonNull()) {
|
|
throw new JsonSyntaxException("Missing field " + name);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static String convertToString(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive()) {
|
|
return element.getAsString();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a string, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static String getAsString(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToString(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a string");
|
|
}
|
|
|
|
@Contract(value="_,_,!null->!null;_,_,null->_")
|
|
public static @Nullable String getAsString(JsonObject object, String name, @Nullable String def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToString(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static Holder<Item> convertToItem(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive()) {
|
|
String itemName = element.getAsString();
|
|
return BuiltInRegistries.ITEM.get(Identifier.parse(itemName)).orElseThrow(() -> new JsonSyntaxException("Expected " + name + " to be an item, was unknown string '" + itemName + "'"));
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be an item, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static Holder<Item> getAsItem(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToItem(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find an item");
|
|
}
|
|
|
|
@Contract(value="_,_,!null->!null;_,_,null->_")
|
|
public static @Nullable Holder<Item> getAsItem(JsonObject object, String name, @Nullable Holder<Item> def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToItem(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static boolean convertToBoolean(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive()) {
|
|
return element.getAsBoolean();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Boolean, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static boolean getAsBoolean(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBoolean(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Boolean");
|
|
}
|
|
|
|
public static boolean getAsBoolean(JsonObject object, String name, boolean def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBoolean(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static double convertToDouble(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsDouble();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Double, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static double getAsDouble(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToDouble(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Double");
|
|
}
|
|
|
|
public static double getAsDouble(JsonObject object, String name, double def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToDouble(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static float convertToFloat(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsFloat();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Float, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static float getAsFloat(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToFloat(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Float");
|
|
}
|
|
|
|
public static float getAsFloat(JsonObject object, String name, float def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToFloat(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static long convertToLong(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsLong();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Long, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static long getAsLong(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToLong(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Long");
|
|
}
|
|
|
|
public static long getAsLong(JsonObject object, String name, long def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToLong(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static int convertToInt(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsInt();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Int, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static int getAsInt(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToInt(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Int");
|
|
}
|
|
|
|
public static int getAsInt(JsonObject object, String name, int def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToInt(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static byte convertToByte(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsByte();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Byte, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static byte getAsByte(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToByte(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Byte");
|
|
}
|
|
|
|
public static byte getAsByte(JsonObject object, String name, byte def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToByte(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static char convertToCharacter(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsCharacter();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Character, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static char getAsCharacter(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToCharacter(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Character");
|
|
}
|
|
|
|
public static char getAsCharacter(JsonObject object, String name, char def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToCharacter(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static BigDecimal convertToBigDecimal(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsBigDecimal();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a BigDecimal, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static BigDecimal getAsBigDecimal(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBigDecimal(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a BigDecimal");
|
|
}
|
|
|
|
public static BigDecimal getAsBigDecimal(JsonObject object, String name, BigDecimal def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBigDecimal(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static BigInteger convertToBigInteger(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsBigInteger();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a BigInteger, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static BigInteger getAsBigInteger(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBigInteger(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a BigInteger");
|
|
}
|
|
|
|
public static BigInteger getAsBigInteger(JsonObject object, String name, BigInteger def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToBigInteger(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static short convertToShort(JsonElement element, String name) {
|
|
if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isNumber()) {
|
|
return element.getAsShort();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a Short, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static short getAsShort(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToShort(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a Short");
|
|
}
|
|
|
|
public static short getAsShort(JsonObject object, String name, short def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToShort(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static JsonObject convertToJsonObject(JsonElement element, String name) {
|
|
if (element.isJsonObject()) {
|
|
return element.getAsJsonObject();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a JsonObject, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static JsonObject getAsJsonObject(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToJsonObject(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a JsonObject");
|
|
}
|
|
|
|
@Contract(value="_,_,!null->!null;_,_,null->_")
|
|
public static @Nullable JsonObject getAsJsonObject(JsonObject object, String name, @Nullable JsonObject def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToJsonObject(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static JsonArray convertToJsonArray(JsonElement element, String name) {
|
|
if (element.isJsonArray()) {
|
|
return element.getAsJsonArray();
|
|
}
|
|
throw new JsonSyntaxException("Expected " + name + " to be a JsonArray, was " + GsonHelper.getType(element));
|
|
}
|
|
|
|
public static JsonArray getAsJsonArray(JsonObject object, String name) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToJsonArray(object.get(name), name);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name + ", expected to find a JsonArray");
|
|
}
|
|
|
|
@Contract(value="_,_,!null->!null;_,_,null->_")
|
|
public static @Nullable JsonArray getAsJsonArray(JsonObject object, String name, @Nullable JsonArray def) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToJsonArray(object.get(name), name);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static <T> T convertToObject(@Nullable JsonElement element, String name, JsonDeserializationContext context, Class<? extends T> clazz) {
|
|
if (element != null) {
|
|
return (T)context.deserialize(element, clazz);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name);
|
|
}
|
|
|
|
public static <T> T getAsObject(JsonObject object, String name, JsonDeserializationContext context, Class<? extends T> clazz) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToObject(object.get(name), name, context, clazz);
|
|
}
|
|
throw new JsonSyntaxException("Missing " + name);
|
|
}
|
|
|
|
@Contract(value="_,_,!null,_,_->!null;_,_,null,_,_->_")
|
|
public static <T> @Nullable T getAsObject(JsonObject object, String name, @Nullable T def, JsonDeserializationContext context, Class<? extends T> clazz) {
|
|
if (object.has(name)) {
|
|
return GsonHelper.convertToObject(object.get(name), name, context, clazz);
|
|
}
|
|
return def;
|
|
}
|
|
|
|
public static String getType(@Nullable JsonElement element) {
|
|
String value = StringUtils.abbreviateMiddle((String)String.valueOf(element), (String)"...", (int)10);
|
|
if (element == null) {
|
|
return "null (missing)";
|
|
}
|
|
if (element.isJsonNull()) {
|
|
return "null (json)";
|
|
}
|
|
if (element.isJsonArray()) {
|
|
return "an array (" + value + ")";
|
|
}
|
|
if (element.isJsonObject()) {
|
|
return "an object (" + value + ")";
|
|
}
|
|
if (element.isJsonPrimitive()) {
|
|
JsonPrimitive primitive = element.getAsJsonPrimitive();
|
|
if (primitive.isNumber()) {
|
|
return "a number (" + value + ")";
|
|
}
|
|
if (primitive.isBoolean()) {
|
|
return "a boolean (" + value + ")";
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public static <T> T fromJson(Gson gson, Reader reader, Class<T> type) {
|
|
try {
|
|
JsonReader jsonReader = new JsonReader(reader);
|
|
jsonReader.setStrictness(Strictness.STRICT);
|
|
Object result = gson.getAdapter(type).read(jsonReader);
|
|
if (result == null) {
|
|
throw new JsonParseException("JSON data was null or empty");
|
|
}
|
|
return (T)result;
|
|
}
|
|
catch (IOException e) {
|
|
throw new JsonParseException((Throwable)e);
|
|
}
|
|
}
|
|
|
|
public static <T> @Nullable T fromNullableJson(Gson gson, Reader reader, TypeToken<T> type) {
|
|
try {
|
|
JsonReader jsonReader = new JsonReader(reader);
|
|
jsonReader.setStrictness(Strictness.STRICT);
|
|
return (T)gson.getAdapter(type).read(jsonReader);
|
|
}
|
|
catch (IOException e) {
|
|
throw new JsonParseException((Throwable)e);
|
|
}
|
|
}
|
|
|
|
public static <T> T fromJson(Gson gson, Reader reader, TypeToken<T> type) {
|
|
T result = GsonHelper.fromNullableJson(gson, reader, type);
|
|
if (result == null) {
|
|
throw new JsonParseException("JSON data was null or empty");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static <T> @Nullable T fromNullableJson(Gson gson, String string, TypeToken<T> type) {
|
|
return GsonHelper.fromNullableJson(gson, new StringReader(string), type);
|
|
}
|
|
|
|
public static <T> T fromJson(Gson gson, String string, Class<T> type) {
|
|
return GsonHelper.fromJson(gson, (Reader)new StringReader(string), type);
|
|
}
|
|
|
|
public static JsonObject parse(String string) {
|
|
return GsonHelper.parse(new StringReader(string));
|
|
}
|
|
|
|
public static JsonObject parse(Reader reader) {
|
|
return GsonHelper.fromJson(GSON, reader, JsonObject.class);
|
|
}
|
|
|
|
public static JsonArray parseArray(String string) {
|
|
return GsonHelper.parseArray(new StringReader(string));
|
|
}
|
|
|
|
public static JsonArray parseArray(Reader reader) {
|
|
return GsonHelper.fromJson(GSON, reader, JsonArray.class);
|
|
}
|
|
|
|
public static String toStableString(JsonElement jsonElement) {
|
|
StringWriter stringWriter = new StringWriter();
|
|
JsonWriter jsonWriter = new JsonWriter((Writer)stringWriter);
|
|
try {
|
|
GsonHelper.writeValue(jsonWriter, jsonElement, Comparator.naturalOrder());
|
|
}
|
|
catch (IOException e) {
|
|
throw new AssertionError((Object)e);
|
|
}
|
|
return stringWriter.toString();
|
|
}
|
|
|
|
public static void writeValue(JsonWriter out, @Nullable JsonElement value, @Nullable Comparator<String> keyComparator) throws IOException {
|
|
if (value == null || value.isJsonNull()) {
|
|
out.nullValue();
|
|
} else if (value.isJsonPrimitive()) {
|
|
JsonPrimitive primitive = value.getAsJsonPrimitive();
|
|
if (primitive.isNumber()) {
|
|
out.value(primitive.getAsNumber());
|
|
} else if (primitive.isBoolean()) {
|
|
out.value(primitive.getAsBoolean());
|
|
} else {
|
|
out.value(primitive.getAsString());
|
|
}
|
|
} else if (value.isJsonArray()) {
|
|
out.beginArray();
|
|
for (JsonElement e : value.getAsJsonArray()) {
|
|
GsonHelper.writeValue(out, e, keyComparator);
|
|
}
|
|
out.endArray();
|
|
} else if (value.isJsonObject()) {
|
|
out.beginObject();
|
|
for (Map.Entry<String, JsonElement> e : GsonHelper.sortByKeyIfNeeded(value.getAsJsonObject().entrySet(), keyComparator)) {
|
|
out.name(e.getKey());
|
|
GsonHelper.writeValue(out, e.getValue(), keyComparator);
|
|
}
|
|
out.endObject();
|
|
} else {
|
|
throw new IllegalArgumentException("Couldn't write " + String.valueOf(value.getClass()));
|
|
}
|
|
}
|
|
|
|
private static Collection<Map.Entry<String, JsonElement>> sortByKeyIfNeeded(Collection<Map.Entry<String, JsonElement>> elements, @Nullable Comparator<String> keyComparator) {
|
|
if (keyComparator == null) {
|
|
return elements;
|
|
}
|
|
ArrayList<Map.Entry<String, JsonElement>> sorted = new ArrayList<Map.Entry<String, JsonElement>>(elements);
|
|
sorted.sort(Map.Entry.comparingByKey(keyComparator));
|
|
return sorted;
|
|
}
|
|
|
|
public static boolean encodesLongerThan(JsonElement element, int limit) {
|
|
try {
|
|
Streams.write((JsonElement)element, (JsonWriter)new JsonWriter(Streams.writerForAppendable((Appendable)new CountedAppendable(limit))));
|
|
}
|
|
catch (IllegalStateException e) {
|
|
return true;
|
|
}
|
|
catch (IOException e) {
|
|
throw new UncheckedIOException(e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static class CountedAppendable
|
|
implements Appendable {
|
|
private int totalCount;
|
|
private final int limit;
|
|
|
|
public CountedAppendable(int limit) {
|
|
this.limit = limit;
|
|
}
|
|
|
|
private Appendable accountChars(int count) {
|
|
this.totalCount += count;
|
|
if (this.totalCount > this.limit) {
|
|
throw new IllegalStateException("Character count over limit: " + this.totalCount + " > " + this.limit);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Appendable append(CharSequence csq) {
|
|
return this.accountChars(csq.length());
|
|
}
|
|
|
|
@Override
|
|
public Appendable append(CharSequence csq, int start, int end) {
|
|
return this.accountChars(end - start);
|
|
}
|
|
|
|
@Override
|
|
public Appendable append(char c) {
|
|
return this.accountChars(1);
|
|
}
|
|
}
|
|
}
|
|
|