Singleton Constructors on JsonObjects

[Speiger]

Problem solved by the feature

I frequently write Json Serializers & Parsers that have an object with a single element with them.
Usually the Single element is also a JSONElement.

So if i want to create a JsonObject wrapper so i don't use primitives or Arrays as the base i have to do the following.

public JsonObject serialize(List<Object> myData) {
     JsonArray serializedData = new JsonArray();
     //Iterate over the list filling the array.
     JsonObject object = new JsonObject();
     object.add("myData", serializedData);
     return object;
}

I hope you see the problem?
I know the Live writing option exist but sometimes i am not creating a JsonObject for writing into a stream.

Feature description

public JsonObject serialize(List<Object> myData) {
     JsonArray serializedData = new JsonArray();
     //Iterate over the list filling the array.
     return new JsonObject("myData", serializedData);
}

This should explain it itself.

Alternatives / workarounds

If this were C# i would use extensions :)

[Marcono1234]

Possibly a duplicate of #2923. Does that match the feature you are requesting?
Except for using a different syntax: JsonObject.of("myData", serializedData)

[Speiger]

@Marcono1234 yep technically does. I don't mind using of functions.

[Speiger]

@Marcono1234 also kinda wished JsonArrays had some unmapping functions. So you don't need to iterate over it directly.

public <T> Iterable<T> map(Function<JsonElement, T> converter) {}

Ones that lazy or ones that hard evaluate.

Also one function i tend to use a lot is this:

public static void iterateObject(JsonElement element, Consumer<JsonObject> objects) {
	if(element.isJsonObject()) objects.accept(element.getAsJsonObject());
	else if(element.isJsonArray()) element.getAsJsonArray().forEach(T -> iterateObject(T, objects));
}

public static void iterratePrimitive(JsonElement element, Consumer<JsonPrimitive> primitives) {
	if(element.isJsonPrimitive()) primitives.accept(element.getAsJsonPrimitive()));
	else if(element.isJsonArray()) element.getAsJsonArray().forEach(T -> iteratePrimitive(T, primitives));
}

I use this for a scripting language where json objects can optionally be arrays or single values.
Giving more flexiblity in how to write json.

Where it can be:

{
    "myObject": {
    }
}

or

{
    "myObject": [
       {}, {}
    ]
}

Maybe that's worth integrating.

[Marcono1234]

These methods might be a bit too specific for a certain use case. It might be better if users implemented this themselves and then customize it to their needs, instead of Gson providing an implementation which is too inflexible.

For example for map, other users might prefer if it returned a List or a Stream. And it can be implemented already using jsonArray.asList().stream().map(...); a bit verbose but maybe not too bad?

Though this is just my personal opinion on this; maybe the project members think differently about it.