facet_generate 0.16.0

Generate Swift, Kotlin and TypeScript from types annotated with `#[derive(Facet)]`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

package com.example

import kotlinx.serialization.*
import kotlinx.serialization.builtins.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*
import kotlinx.serialization.json.*
import kotlinx.serialization.modules.*

@Serializable
data class Bar(val one: String) : KeyPathMutable<Bar> {
    override fun patching(patch: PatchOperation, keyPath: List<KeyPathElement>): Bar {
        if (keyPath.isEmpty()) {
            return this.applying(patch)
        }
        return when (val field = keyPath.firstOrNull()) {
            KeyPathElement.Field("one") -> {
                val newValue = this.one.patching(patch, keyPath.drop(1))
                this.copy(one = newValue)
            }
            else -> throw IllegalStateException("Bar does not support $field key path.")
        }
    }

    private fun applying(patch: PatchOperation): Bar {
        return when (patch) {
            is PatchOperation.Update -> patch.value.asT()
            else -> throw IllegalStateException("Bar does not support splice operations.")
        }
    }
}

@Serializable
data class Foo(val bar: Bar? = null) : KeyPathMutable<Foo> {
    override fun patching(patch: PatchOperation, keyPath: List<KeyPathElement>): Foo {
        if (keyPath.isEmpty()) {
            return this.applying(patch)
        }
        return when (val field = keyPath.firstOrNull()) {
            KeyPathElement.Field("bar") -> {
                val newValue = this.bar.patching(patch, keyPath.drop(1))
                this.copy(bar = newValue)
            }
            else -> throw IllegalStateException("Foo does not support $field key path.")
        }
    }

    private fun applying(patch: PatchOperation): Foo {
        return when (patch) {
            is PatchOperation.Update -> patch.value.asT()
            else -> throw IllegalStateException("Foo does not support splice operations.")
        }
    }
}