Kotlin如何选择要调用的泛型重载函数？

我正在尝试编写序列化函数，以便能够序列化Kotlin中的任何向量（=ArrayList），以及扩展具有

toBinary（）函数的
serialize
类的基元类型和类。
我还有一个自定义的
WriteDataStream
类（下面的代码）来用正确的格式、endianness等序列化字段

我是Kotlin的新手，但有C++的经验。在C++中，我使用模板和模板特化来轻松地解决这个问题，但是用KoTLIN我已经挣扎了几天，没有成功。

我有一个自定义向量类
MyVector
，它扩展了
ArrayList
，并添加了一个最大大小。我想用任何泛型类型
T
对它进行序列化，包括像
MyVector
这样的内部向量

My
WriteDataStream
包含以下内容：

inline fun <reified T> write(vector: MyVector<T>) {
    this.writeSize(vector.size.toULong(), vector.MAX_SIZE)
    for (element in vector) {
        write<T>(element)
    }
}

inline fun <reified T: Serialize> write(value: T) {
    writeSerialize(value as Serialize)
}

inline fun <reified T> write(value: T) {
    when (T::class) {
        UByte::class -> {
            writeUInt8(value as UByte)
        }
        UShort::class -> {
            writeUInt16(value as UShort)
        }
        UInt::class -> {
            writeUInt32(value as UInt)
        }
        ULong::class -> {
            writeUInt64(value as ULong)
        }
        Byte::class -> {
            writeInt8(value as Byte)
        }
        Short::class -> {
            writeInt16(value as Short)
        }
        Int::class -> {
            writeInt32(value as Int)
        }
        Long::class -> {
            writeInt64(value as Long)
        }
        Boolean::class -> {
            writeBoolean(value as Boolean)
        }
        Float::class -> {
            writeFloat(value as Float)
        }
        Double::class -> {
            writeDouble(value as Double)
        }
        else -> {
            error("Default serialization:" + T::class.qualifiedName)
        }
    }
}

<>在C++中，编译器总是使用最适合的函数。
有没有办法克服Kotlin的这一限制？
我尝试过使用和不使用具体化类型，也尝试过非泛型函数：
inline-fun-write（value:Serialize）
，但没有成功。唯一有效的方法是在完全通用的
内联fun write（value:T）
中为类“instance of”序列化添加一个案例，但这并不是一个好的解决方案

谢谢你
 

您是Java实现泛型的受害者，更具体地说，是
C++
使用所谓的类型扩展来实现泛型，这意味着如果您声明
MyType及其组件是对象

对于
对象
而言，最好的方法匹配是
公共最终无效写入（对象值）
，而不是带有
字符串
或在您的情况下是
序列化
的方法

@Test
fun writeVectorOfStructure() {
    class TestStructure: Serialize() {
        override fun toBinary(stream: WriteDataStream) {
            stream.writeUInt32(17U)
            stream.writeUInt8(3U)
            stream.writeDouble(555.555)
        }
    }
    val value = MyVector<TestStructure>(MAX_SIZE, arrayListOf(TestStructure(), TestStructure()))
    writeStream.write(value)
    val bytes: UByteArray = writeStream.byteArray()
    Assert.assertEquals(bytes.size, 28) // = 2 (for size) + 2*(4+1+8) = 28 bytes
}

inline fun <reified T: Serialize> write(value: T)
        

inline fun <reified T> write(value: T)

class SomeType {
    inline fun <reified T: String> write(value: T) {}
    inline fun <reified T> write(value: T) {}

    inline fun <reified T: Any> write(vector: List<T>) {
        for (element in vector) {
            write(element)
        }
    }
}

public final class SomeType {
   public final void write(@NotNull String value) {}
   public final void write(Object value) {}

   public final void write(@NotNull List vector) {
      boolean var6;
      for(Iterator var4 = vector.iterator(); var4.hasNext(); var6 = false) {
         Object element = var4.next();
      }
   }
}