grpc-native: Add float and double encode/decode

Signed-off-by: Johannes Zottele <[email protected]>

Author: Jozott00

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/WireDecoder.kt

@@ -41,6 +41,8 @@ internal interface WireDecoder: AutoCloseable {
     fun readFixed64(): ULong?
     fun readSFixed32(): Int?
     fun readSFixed64(): Long?
+    fun readFloat(): Float?
+    fun readDouble(): Double?
     fun readEnum(): Int?
     fun readString(): String?
     fun readBytes(): ByteArray?

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.kt

@@ -26,6 +26,8 @@ internal interface WireEncoder {
     fun writeFixed64(fieldNr: Int, value: ULong): Boolean
     fun writeSFixed32(fieldNr: Int, value: Int): Boolean
     fun writeSFixed64(fieldNr: Int, value: Long): Boolean
+    fun writeFloat(fieldNr: Int, value: Float): Boolean
+    fun writeDouble(fieldNr: Int, value: Double): Boolean
     fun writeEnum(fieldNr: Int, value: Int): Boolean
     fun writeString(fieldNr: Int, value: String): Boolean
     fun flush()

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireDecoder.native.kt

@@ -10,7 +10,7 @@ import libprotowire.*
 import kotlin.experimental.ExperimentalNativeApi
 
 @OptIn(ExperimentalForeignApi::class, ExperimentalNativeApi::class)
-internal class WireDecoderNative(private val source: Buffer): WireDecoder {
+internal class WireDecoderNative(source: Buffer): WireDecoder {
 
     // wraps the source in a class that allows to pass data from the source buffer to the C++ encoder
     // without copying it to an intermediate byte array.
@@ -144,6 +144,22 @@ internal class WireDecoderNative(private val source: Buffer): WireDecoder {
         return null
     }
 
+    override fun readFloat(): Float? = memScoped {
+        val value = alloc<FloatVar>()
+        if (pw_decoder_read_float(raw, value.ptr)) {
+            return value.value
+        }
+        return null
+    }
+
+    override fun readDouble(): Double? = memScoped {
+        val value = alloc<DoubleVar>()
+        if (pw_decoder_read_double(raw, value.ptr)) {
+            return value.value
+        }
+        return null
+    }
+
     override fun readEnum(): Int? = memScoped {
         val value = alloc<IntVar>()
         if (pw_decoder_read_enum(raw, value.ptr)) {
@@ -164,8 +180,11 @@ internal class WireDecoderNative(private val source: Buffer): WireDecoder {
         }
     }
 
+    // TODO: Should readBytes return a buffer? The current approach is dangerous as one could send a
+    //    huge length (max 2GB) and we would just allocate the array of that length.
     override fun readBytes(): ByteArray? {
         val length = readInt32() ?: return null
+        if (length < 0) return null
         if (length == 0) return ByteArray(0)
         val bytes = ByteArray(length)
         bytes.usePinned {

grpc/grpc-core/src/nativeMain/kotlin/kotlinx/rpc/grpc/internal/WireEncoder.native.kt

@@ -92,6 +92,14 @@ internal class WireEncoderNative(private val sink: Sink): WireEncoder {
         return pw_encoder_write_sfixed64(raw, fieldNr, value)
     }
 
+    override fun writeFloat(fieldNr: Int, value: Float): Boolean {
+        return pw_encoder_write_float(raw, fieldNr, value)
+    }
+
+    override fun writeDouble(fieldNr: Int, value: Double): Boolean {
+        return pw_encoder_write_double(raw, fieldNr, value)
+    }
+
     override fun writeEnum(fieldNr: Int, value: Int): Boolean {
         return pw_encoder_write_enum(raw, fieldNr, value)
     }

grpc/grpc-core/src/nativeTest/kotlin/kotlinx/rpc/grpc/internal/WireCodecTest.kt

@@ -610,4 +610,54 @@ class WireCodecTest {
         assertEquals(1, tag.fieldNr)
         assertEquals(WireType.LENGTH_DELIMITED, tag.wireType)
     }
+
+    @Test
+    fun testDoubleEncodeDecode() {
+        val fieldNr = 21
+        val testValue = 3.14159265359
+        val buffer = Buffer()
+
+        val encoder = WireEncoder(buffer)
+        assertTrue(encoder.writeDouble(fieldNr, testValue))
+        encoder.flush()
+
+        val decoder = WireDecoder(buffer)
+
+        val tag = decoder.readTag()
+        assertNotNull(tag)
+        assertEquals(WireType.FIXED64, tag.wireType)
+        assertEquals(fieldNr, tag.fieldNr)
+
+        val value = decoder.readDouble()
+        assertNotNull(value)
+        assertEquals(testValue, value)
+
+        decoder.close()
+        assertTrue(buffer.exhausted())
+    }
+
+    @Test
+    fun testFloatEncodeDecode() {
+        val fieldNr = 22
+        val testValue = 3.14159f
+        val buffer = Buffer()
+
+        val encoder = WireEncoder(buffer)
+        assertTrue(encoder.writeFloat(fieldNr, testValue))
+        encoder.flush()
+
+        val decoder = WireDecoder(buffer)
+
+        val tag = decoder.readTag()
+        assertNotNull(tag)
+        assertEquals(WireType.FIXED32, tag.wireType)
+        assertEquals(fieldNr, tag.fieldNr)
+
+        val value = decoder.readFloat()
+        assertNotNull(value)
+        assertEquals(testValue, value)
+
+        decoder.close()
+        assertTrue(buffer.exhausted())
+    }
 }

grpc/grpcpp-c/include/protowire.h

@@ -98,6 +98,7 @@ extern "C" {
     // To read an actual bytes field, you must combine read_int32 and this function
     bool pw_decoder_read_raw_bytes(pw_decoder_t *self, void* buffer, int size);
 
+
 #ifdef __cplusplus
     }
 #endif

grpc/grpcpp-c/src/protowire.cpp

@@ -166,6 +166,8 @@ extern "C" {
     WRITE_FIELD_FUNC( fixed64, Fixed64, uint64_t)
     WRITE_FIELD_FUNC( sfixed32, SFixed32, int32_t)
     WRITE_FIELD_FUNC( sfixed64, SFixed64, int64_t)
+    WRITE_FIELD_FUNC( float, Float, float)
+    WRITE_FIELD_FUNC( double, Double, double)
     WRITE_FIELD_FUNC( enum, Enum, int)
 
     bool pw_encoder_write_string(pw_encoder_t *self, int field_no, const char *data, int size) {
@@ -206,6 +208,8 @@ extern "C" {
     READ_VAL_FUNC( fixed64, FIXED64, uint64_t)
     READ_VAL_FUNC( sfixed32, SFIXED32, int32_t)
     READ_VAL_FUNC( sfixed64, SFIXED64, int64_t)
+    READ_VAL_FUNC( float, FLOAT, float)
+    READ_VAL_FUNC( double, DOUBLE, double)
     READ_VAL_FUNC( enum, ENUM, int)
 
     bool pw_decoder_read_string(pw_decoder_t *self, pw_string_t **string_ref) {