I get "Either none or all type parameters can be wildcard in Map<String, Competition2>" when pass this Map class as parameter. This worked in the previous version. Without kotson gson can handle it well.

I just wanted you to know, that the name of the library "Kotson", when pronounced, unfortunately sounds exactly like the german verb "kotzen" which means "to puke" or "to vomit".

This makes it kinda hard to stay serious when coding with your team mates because everytime the name is mentioned, someone has to laugh. Additionally, this seems to amplify, everytime it happens :)

I'm trying to deserialize a custom data-class with various members.

I just tried gson.fromJson<MyType>(...) without any custom deserializers, but I keep getting a strange segfault (libc, not an exception that I can catch).

When I call gson.fromJson<MyType>('{}') i get the correct type (with defaults set).

Here is my code:

    OutputStreamWriter(GZIPOutputStream(FileOutputStream("financials-0.0.1.json.gz"))).use {
        GsonBuilder()
                .registerTypeAdapter<Instant> {
                    serialize {
                        it.src.epochSecond.toJson()
                    }
                }
                .registerTypeAdapter<LocalDate> {
                    serialize {
                        it.src.toString().toJson()
                    }
                }
                .create().toJson(financials, it)

For some reason, it seems to be intermittently ignoring the Instant custom serializer and serializing an Instant field to {"seconds":1452211200,"nanos":0}

Sorry I can't reliably reproduce it, but can you think of any reason this could occur?

When I attempt to use the new versions of Kotlin and Kotson, I get the error "Kotlin library 'kotson-1.5.0.jar' has an unsupported format. Please update the library or plugin". Any idea what's going on?

Does this support Kotlin's default values? With Gson when deserializing, if a value does not exist, it becomes null. Since this is supposed to support Kotson, does that value now get set to default value if it does not exist?

since v2.2.0 I get this build warnings and the build fails:

Warning: com.github.salomonbrys.kotson.RegistrationBuilder$_registerTypeAdapter$1: can't find enclosing method 'void _registerTypeAdapter()' in program class com.github.salomonbrys.kotson.RegistrationBuilder
Warning: com.github.salomonbrys.kotson.TypeAdapterBuilder$build$1: can't find referenced method 'kotlin.jvm.functions.Function1 access$get_readFunction$p(com.github.salomonbrys.kotson.TypeAdapterBuilder)' in program class com.github.salomonbrys.kotson.TypeAdapterBuilder
Warning: com.github.salomonbrys.kotson.TypeAdapterBuilder$build$1: can't find referenced method 'kotlin.jvm.functions.Function2 access$get_writeFunction$p(com.github.salomonbrys.kotson.TypeAdapterBuilder)' in program class com.github.salomonbrys.kotson.TypeAdapterBuilder
Warning: com.github.salomonbrys.kotson.TypeAdapterBuilder$build$1: can't find enclosing method 'com.google.gson.TypeAdapter build()' in program class com.github.salomonbrys.kotson.TypeAdapterBuilder

Please, consider upgrade Kotlin version. Any code compiled with previous versions of Kotlin is not compatible with 1.0.

http://blog.jetbrains.com/kotlin/2015/10/kotlin-1-0-beta-candidate-is-out/

Say, I have data class User(val clientId: Int, val firstName: String)

Both properties can never be null, that is how it should be. But if I get JSON { clientId: null, firstName: null }, my User will have nulls in it without throwing any errors and it will break everything. Now, you might think that I should have nullable properties if my data coming in JSON may can contain them... But the design of back-end is such that if the user is not found, all the data properties are nulls. I would rather try/catch the error, like so:

 fun parseUser(response: Response): User? =
      try {
        mapper.fromJson<User>(response.body().string())
      } catch (e: Exception) {
        null
      }

The idea is that I don't need the User object at all if BE returned all properties as nulls.

Is there an elegant way to handle this situation? Note that I have much more fields in User model than I presented, all but one of them is never null, unless user is not found.

This is an issue to track the integration of the Stream TypeAdapter API into Kotson.

The JsonSerializer documentation states:

New applications should prefer TypeAdapter, whose streaming API is more efficient than this interface's tree API.

Kotson version 2.2.0-beta1 has been pushed to Maven Central and exposes this API.

Feel free to test it and report any concern or issue here ;)

Hi, just noticed an issue while using nested types e.g.

data class User(val id: String)

val a = gson.fromJson<List<List<User>>>("[\n" +
            "  [\n" +
            "    {\n" +
            "      \"id\": \"u-abcd\"\n" +
            "    }\n" +
            "  ]\n" +
            "]\n")

Expecting a to be of type ArrayList<ArrayList<User>>> however I'm getting ArrayList<ArrayList<LinkedTreeMap<etc... as per Gson>>> It looks like it's not getting past the 'first' level generic type.

When the Gson's native fromJson method returns null (ex. when the JSON string is empty), a

java.lang.IllegalStateException: fromJson(json, typeToken<T>()) must not be null

exception is thrown due to the extension function being defined as Gson.fromJson(json: String): T. I developed a workaround for it (note the nullable type T)

inline fun <reified T: Any> Gson.fromJsonOrNull(json: Reader): T? = fromJson(json, typeToken<T>())

I'm unsure whether this would be the correct approach, thus I'm not submitting a PR.

I'm trying convert a list of object, but when i use toJsonArray(), it gave me

java.lang.IllegalArgumentException
        at com.github.salomonbrys.kotson.BuilderKt.toJsonElement(Builder.kt:24)
        at com.github.salomonbrys.kotson.BuilderKt._jsonArray(Builder.kt:31)
        at com.github.salomonbrys.kotson.BuilderKt.jsonArray(Builder.kt:36)
        at com.github.salomonbrys.kotson.BuilderKt.toJsonArray(Builder.kt:39)

for example, this does not work

`import com.github.salomonbrys.kotson.* import com.google.gson.*

fun main (args: Array ) { val obj:JsonObject = jsonObject( "name" to "kotson", "files" to 4 ) println(" ${obj}") class Person(public val obj: JsonObject) { val name: String by obj.byString("name") val files: Int by obj.byInt("files")
} val person=Gson().fromJson(obj,Person ::class.java) }`

It would be nice if there was a option (or if it was the default behavior) to evaluate delegates when serializing objects.

For example, val jumps by json.byInt would serialize to something like "jumps": 3.

This would extremely helpful when using a class that generated from json using the json delegates (byInt, etc). Right now, using these requires a custom serializer to be serializable properly.

I have a json like this

    val JSON_LIST_STRING = """
{
  "code": "0",
  "msg": "Success",
  "subcode": "0",
  "data": [{
    "test": 10
  }
  ]
}
""".trimIndent()

model like this

    data class TestObject(val test: Int)

public class ApiResult<T> {
    private int code;
    private int subcode;
    private String msg;
    private T data;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean isOk() {
        return code == 0;
    }

    @Override
    public String toString() {
        return "ApiResult{" +
                "code='" + code + '\'' +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }

    public int getSubcode() {
        return subcode;
    }

    public void setSubcode(int subcode) {
        this.subcode = subcode;
    }
}

test code like this

  @Test
    fun testFunListGson() {

        val result = data<List<TestObject>>()
        assertThat(result.data[0].test).isEqualTo(10)
    }

    @Test
    fun testDirectListGson() {

        val result = gson.fromJson<ApiResult<List<TestObject>>>(JSON_LIST_STRING)
        assertThat(result.data[0].test).isEqualTo(10)
    }

    fun <T> data(): ApiResult<T> {
        return gson.fromJson(JSON_LIST_STRING)
    }

Expect testFunListGson will pass, but it failed like this

java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.xxx.GsonTest$TestObject

It looks like it's not getting past the underneath generic type.

Would be nice to map directly to Array of Strings if possible. Might be missing how to do this, but this is my current way of doing so:

    private val _modes by obj.byNullableArray("MODES")
    val modes: Array<String>? by lazy {
        _modes?.map { it.string }?.toTypedArray()
    }