Add support enum with associated value

compiler/src/main/java/com/readdle/codegen/SwiftValueDescriptor.java

@@ -67,13 +67,6 @@ class SwiftValueDescriptor {
             enclosingElement = enclosingElement.getEnclosingElement();
         }
 
-
-        // Check if it's an abstract class
-        if (classElement.getModifiers().contains(Modifier.ABSTRACT)) {
-            throw new IllegalArgumentException(String.format("The class %s is abstract. You can't annotate abstract classes with @%s",
-                    classElement.getQualifiedName().toString(), SwiftValue.class.getSimpleName()));
-        }
-
         boolean hasEmptyConstructor = false;
 
         // Check if an empty constructor is given

sample/src/androidTest/java/com/readdle/swiftjava/sample/SampleEnumWithValueTests.kt

@@ -0,0 +1,182 @@
+package com.readdle.swiftjava.sample
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.readdle.codegen.anotation.JavaSwift
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class SampleEnumWithValueTests {
+
+    @Before
+    fun setUp() {
+        System.loadLibrary("SampleAppCore")
+        JavaSwift.init()
+    }
+
+    @Test
+    fun testNone() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.None)
+        Assert.assertTrue(value is SampleEnumWithValue.None)
+    }
+
+    @Test
+    fun testStringValue() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.StringValue("42"))
+        Assert.assertEquals((value as SampleEnumWithValue.StringValue).value, "42")
+    }
+
+    @Test
+    fun testIntegerValue() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.IntegerValue(42))
+        Assert.assertEquals((value as SampleEnumWithValue.IntegerValue).value, 42)
+    }
+
+    @Test
+    fun testInt8Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int8Value(42))
+        Assert.assertEquals((value as SampleEnumWithValue.Int8Value).value.toInt(), 42)
+    }
+
+    @Test
+    fun testInt16Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int16Value(42))
+        Assert.assertEquals((value as SampleEnumWithValue.Int16Value).value.toInt(), 42)
+    }
+
+    @Test
+    fun testInt32Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int32Value(42))
+        Assert.assertEquals((value as SampleEnumWithValue.Int32Value).value, 42)
+    }
+
+    @Test
+    fun testInt64Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Int64Value(42))
+        Assert.assertEquals((value as SampleEnumWithValue.Int64Value).value, 42)
+    }
+
+    @Test
+    fun testUIntValue() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.UintValue(42U))
+        Assert.assertEquals((value as SampleEnumWithValue.UintValue).value, 42U)
+    }
+
+    @Test
+    fun testUInt8Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint8Value(42U))
+        Assert.assertEquals((value as SampleEnumWithValue.Uint8Value).value.toUInt(), 42U)
+    }
+
+    @Test
+    fun testUInt16Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint16Value(42U))
+        Assert.assertEquals((value as SampleEnumWithValue.Uint16Value).value.toUInt(), 42U)
+    }
+
+    @Test
+    fun testUInt32Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint32Value(42U))
+        Assert.assertEquals((value as SampleEnumWithValue.Uint32Value).value, 42U)
+    }
+
+    @Test
+    fun testUInt64Value() {
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Uint64Value(42U))
+        Assert.assertEquals((value as SampleEnumWithValue.Uint64Value).value.toUInt(), 42U)
+    }
+
+    @Test
+    fun testObjectArrayValue() {
+        val array = arrayListOf(SampleValue.getRandomValue())
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.ObjectArrayValue(array))
+        Assert.assertEquals((value as SampleEnumWithValue.ObjectArrayValue).value, array)
+    }
+
+    @Test
+    fun testStringArrayValue() {
+        val array = arrayListOf("42")
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.StringArrayValue(array))
+        Assert.assertEquals((value as SampleEnumWithValue.StringArrayValue).value, array)
+    }
+
+    @Test
+    fun testNumberArrayValue() {
+        val array = arrayListOf(42)
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.NumberArrayValue(array))
+        Assert.assertEquals((value as SampleEnumWithValue.NumberArrayValue).value, array)
+    }
+
+    @Test
+    fun testArrayInArrayValue() {
+        val array = arrayListOf(arrayListOf(42))
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.ArrayInArrayValue(array))
+        Assert.assertEquals((value as SampleEnumWithValue.ArrayInArrayValue).value, array)
+    }
+
+    @Test
+    fun testDictInArrayValue() {
+        val array = arrayListOf(hashMapOf(42 to 42))
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictInArrayValue(array))
+        Assert.assertEquals((value as SampleEnumWithValue.DictInArrayValue).value, array)
+    }
+
+    @Test
+    fun testDictSampleClassValue() {
+        val dict = hashMapOf("abc" to SampleValue.getRandomValue())
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictSampleClassValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.DictSampleClassValue).value, dict)
+    }
+
+    @Test
+    fun testDictStringsValue() {
+        val dict = hashMapOf("abc" to "42")
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictStringsValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.DictStringsValue).value, dict)
+    }
+
+    @Test
+    fun testDictNumbersValue() {
+        val dict = hashMapOf(42 to 42)
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictNumbersValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.DictNumbersValue).value, dict)
+    }
+
+    @Test
+    fun testDict64NumbersValue() {
+        val dict = hashMapOf(10 to 10)
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.Dict64NumbersValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.Dict64NumbersValue).value, dict)
+    }
+
+    @Test
+    fun testDictInDictValue() {
+        val dict = hashMapOf(10 to hashMapOf(10 to 10))
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.DictInDictValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.DictInDictValue).value, dict)
+    }
+
+    @Test
+    fun testArrayInDictValue() {
+        val dict = hashMapOf(10 to arrayListOf(10, 10))
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.ArrayInDictValue(dict))
+        Assert.assertEquals((value as SampleEnumWithValue.ArrayInDictValue).value, dict)
+    }
+
+    @Test
+    fun testSetValue() {
+        val set = hashSetOf(42)
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.SetValue(set))
+        Assert.assertEquals((value as SampleEnumWithValue.SetValue).value, set)
+    }
+
+    @Test
+    fun testSetValuesValue() {
+        val set = hashSetOf(SampleValue.getRandomValue())
+        val value = SampleEnumWithValue.copy(SampleEnumWithValue.SetValuesValue(set))
+        Assert.assertEquals((value as SampleEnumWithValue.SetValuesValue).value, set)
+    }
+
+}

sample/src/main/java/com/readdle/swiftjava/sample/SampleEnumWithValue.kt

@@ -0,0 +1,41 @@
+package com.readdle.swiftjava.sample
+
+import com.readdle.codegen.anotation.SwiftFunc
+import com.readdle.codegen.anotation.SwiftValue
+
+@SwiftValue
+sealed class SampleEnumWithValue {
+
+    object None : SampleEnumWithValue()
+    data class StringValue(val value: String) : SampleEnumWithValue()
+    data class IntegerValue(val value: Int) : SampleEnumWithValue()
+    data class Int8Value(val value: Byte) : SampleEnumWithValue()
+    data class Int16Value(val value: Short) : SampleEnumWithValue()
+    data class Int32Value(val value: Int) : SampleEnumWithValue()
+    data class Int64Value(val value: Long) : SampleEnumWithValue()
+    data class UintValue(val value: UInt) : SampleEnumWithValue()
+    data class Uint8Value(val value: UByte) : SampleEnumWithValue()
+    data class Uint16Value(val value: UShort) : SampleEnumWithValue()
+    data class Uint32Value(val value: UInt) : SampleEnumWithValue()
+    data class Uint64Value(val value: ULong) : SampleEnumWithValue()
+    data class ObjectArrayValue(val value: ArrayList<SampleValue>) : SampleEnumWithValue()
+    data class StringArrayValue(val value: ArrayList<String>) : SampleEnumWithValue()
+    data class NumberArrayValue(val value: ArrayList<Int>) : SampleEnumWithValue()
+    data class ArrayInArrayValue(val value: ArrayList<ArrayList<Int>>) : SampleEnumWithValue()
+    data class DictInArrayValue(val value: ArrayList<HashMap<Int, Int>>) : SampleEnumWithValue()
+    data class DictSampleClassValue(val value: HashMap<String, SampleValue>) : SampleEnumWithValue()
+    data class DictStringsValue(val value: HashMap<String, String>) : SampleEnumWithValue()
+    data class DictNumbersValue(val value: HashMap<Int, Int>) : SampleEnumWithValue()
+    data class Dict64NumbersValue(val value: HashMap<Int, Int>) : SampleEnumWithValue()
+    data class DictInDictValue(val value: HashMap<Int, HashMap<Int, Int>>) : SampleEnumWithValue()
+    data class ArrayInDictValue(val value: HashMap<Int, ArrayList<Int>>) : SampleEnumWithValue()
+    data class SetValue(val value: HashSet<Int>) : SampleEnumWithValue()
+    data class SetValuesValue(val value: HashSet<SampleValue>) : SampleEnumWithValue()
+
+    companion object {
+
+        @JvmStatic
+        @SwiftFunc("copy(value:)")
+        external fun copy(value: SampleEnumWithValue): SampleEnumWithValue
+    }
+}

sample/src/main/swift/Package.resolved

@@ -6,8 +6,8 @@
         "repositoryURL": "https://github.com/readdle/java_swift.git",
         "state": {
           "branch": null,
-          "revision": "c1ed735ca2e82d961511ee6e938157f78c31278b",
-          "version": "2.2.0"
+          "revision": "f50fd0845ef22caa955444e72b25b72a59cf7b71",
+          "version": "2.2.2"
         }
       },
       {
@@ -42,8 +42,8 @@
         "repositoryURL": "https://github.com/readdle/swift-java-coder.git",
         "state": {
           "branch": null,
-          "revision": "b0b66fa90d7b04c7214da15a17ec5ba14df61c8d",
-          "version": "1.1.0"
+          "revision": "d65e2ca83c524e9fde6ff90d291115c57a268217",
+          "version": "1.1.1"
         }
       }
     ]

sample/src/main/swift/Package.swift

@@ -15,7 +15,7 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/readdle/java_swift.git", .upToNextMinor(from: "2.2.0")),
         .package(url: "https://github.com/readdle/swift-java.git", .upToNextMinor(from: "0.3.0")),
-        .package(url: "https://github.com/readdle/swift-java-coder.git", .upToNextMinor(from: "1.1.0")),
+        .package(url: "https://github.com/readdle/swift-java-coder.git", .upToNextMinor(from: "1.1.1")),
         .package(url: "https://github.com/readdle/swift-anycodable.git", .upToNextMinor(from: "1.0.3")),
     ],
     targets: [

sample/src/main/swift/Sources/SampleAppCore/SampleEnumWithValue.swift

@@ -0,0 +1,47 @@
+//
+// Created by Andrew Druk on 06.05.2024.
+//
+
+import Foundation
+
+public enum SampleEnumWithValue: Codable {
+    case none
+    case stringValue(value: String)
+    case integerValue(value: Int)
+    case int8Value(value: Int8)
+    case int16Value(value: Int16)
+    case int32Value(value: Int32)
+    case int64Value(value: Int64)
+    case uintValue(value: UInt)
+    case uint8Value(value: UInt8)
+    case uint16Value(value: UInt16)
+    case uint32Value(value: UInt32)
+    case uint64Value(value: UInt64)
+    case optionalIntegerValue(value: Int?)
+    case optionalInt8Value(value: Int8?)
+    case optionalInt16Value(value: Int16?)
+    case optionalInt32Value(value: Int32?)
+    case optionalInt64Value(value: Int64?)
+    case optionalUintValue(value: UInt?)
+    case optionalUint8Value(value: UInt8?)
+    case optionalUint16Value(value: UInt16?)
+    case optionalUint32Value(value: UInt32?)
+    case optionalUint64Value(value: UInt64?)
+    case objectArrayValue(value: [SampleValue])
+    case stringArrayValue(value: [String])
+    case numberArrayValue(value: [Int])
+    case arrayInArrayValue(value: [[Int]])
+    case dictInArrayValue(value: [[Int: Int]])
+    case dictSampleClassValue(value: [String: SampleValue])
+    case dictStringsValue(value: [String: String])
+    case dictNumbersValue(value: [Int: Int])
+    case dict64NumbersValue(value: [Int: Int])
+    case dictInDictValue(value: [Int: [Int: Int]])
+    case arrayInDictValue(value: [Int: [Int]])
+    case setValue(value: Set<Int>)
+    case setValuesValue(value: Set<SampleValue>)
+
+    public static func copy(value: SampleEnumWithValue) -> SampleEnumWithValue {
+        return value
+    }
+}