jlbabilino/json

A simple Java library for JSON parsing, exporting, serialization, and deserialization. Supports inheritance and generics

Welcome to JSON!

Links:

• Javadoc
• Documentation

json's Issues

Inherited method issue

When a method in a super class is annotated with a serializing or deserializing annotation, and there is a sub implementation that does not have that annotation, the method marked will not be serialized/deserialized.

JSONFormat visibility issue

The default format option, JSONFormat.DEFAULT_FORMAT_CODE, should be publicly visible.

Add enum deserialization

Add a way to take a string and convert it back to an enum constant

Abstract Determiners should accept regular deserialization parameters

Currently, abstract determiners only accept a JSONEntry as the single parameter that a JSONSerializable class can use to determine what type to deserialize. This should be extended. Here is an example where A is the interface/abstract class, and B and C are classes that extend A:

Original determiner

@DeserializedJSONDeterminer
public static TypeMarker<? extends A> determiner(JSONObject jsonObject) throws JSONDeserializerException {
    if (!jsonObject.containsKey("type")) {
        throw new JSONDeserializerException("Key \"type\" missing.");
    }
    JSONString typeJSONString = (JSONString) jsonObject.get("type");
    String typeString = typeJSONString.getString();
    switch (typeString) {
        case "B":
            return new TypeMarker<B>() {};
        case "C":
            return new TypeMarker<C>() {};
        default:
            throw new JSONDeserializerException("Unrecognized type string");
    }
}

If this new feature were added, the code would simplify to:

@DeserializedJSONDeterminer
public static TypeMarker<? extends A> determiner(@DeserializedJSONObjectValue(key = "type") String typeString) throws JSONDeserializerException {
    switch (typeString) {
        case "B":
            return new TypeMarker<B>() {};
        case "C":
            return new TypeMarker<C>() {};
        default:
            throw new JSONDeserializerException("Unrecognized type string");
    }
}

This could be simplified even further if another feature were added:

@DeserializedJSONDeterminer
public static Class<? extends A> determiner(@DeserializedJSONObjectValue(key = "type") String typeString) throws JSONDeserializerException {
    switch (typeString) {
        case "B":
            return B.class;
        case "C":
            return C.class;
        default:
            throw new JSONDeserializerException("Unrecognized type string");
    }
}

Abstract Determiners should work with Class

Abstract determiners should work with both Class objects and TypeMarkers. Currently, only TypeMarker is supported.

Naming of Deserialization methods

All deserialization methods should be named deserialize(), and since the signature of all four deserialization methods is unique, it won't matter.

Allow private methods and fields to be used with serialization and deserialization

This would be helpful to maintain encapsulation.

Add feature to set order of object items

The SerializedJSONObjectValue annotation should have an extra field called index that by default is set to -1, but can be overwritten to set a custom one. -1 would indicate that the order does not matter. Numbered keys and null values would be used for the items in between indices if the user mistakenly missed an index in the sequence.

JSON Parser visibility issue

JSONParser should be a final class, and the nullEntry() method should be private.

Add deserialization priority feature

The deserialization annotations should have an extra field, required, which, if true, an exception will be thrown if the JSON entry is missing, and, if false, a null value will be passed in instead of causing an error.

Add methods for exporting and parsing files

This isn't super important but would be helpful