[gbinder] Add double and float support. MER#1942

include/gbinder_local_reply.h

@@ -71,6 +71,16 @@ gbinder_local_reply_append_int64(
     GBinderLocalReply* reply,
     guint64 value);
 
+GBinderLocalReply*
+gbinder_local_reply_append_float(
+    GBinderLocalReply* reply,
+    gfloat value);
+
+GBinderLocalReply*
+gbinder_local_reply_append_double(
+    GBinderLocalReply* reply,
+    gdouble value);
+
 GBinderLocalReply*
 gbinder_local_reply_append_string8(
     GBinderLocalReply* reply,

include/gbinder_local_request.h

@@ -71,6 +71,16 @@ gbinder_local_request_append_int64(
     GBinderLocalRequest* request,
     guint64 value);
 
+GBinderLocalRequest*
+gbinder_local_request_append_float(
+    GBinderLocalRequest* request,
+    gfloat value);
+
+GBinderLocalRequest*
+gbinder_local_request_append_double(
+    GBinderLocalRequest* request,
+    gdouble value);
+
 GBinderLocalRequest*
 gbinder_local_request_append_string8(
     GBinderLocalRequest* request,

include/gbinder_reader.h

@@ -85,6 +85,16 @@ gbinder_reader_read_uint64(
     GBinderReader* reader,
     guint64* value);
 
+gboolean
+gbinder_reader_read_float(
+    GBinderReader* reader,
+    gfloat* value);
+
+gboolean
+gbinder_reader_read_double(
+    GBinderReader* reader,
+    gdouble* value);
+
 gboolean
 gbinder_reader_read_nullable_object(
     GBinderReader* reader,

include/gbinder_writer.h

@@ -65,6 +65,16 @@ gbinder_writer_append_int64(
     GBinderWriter* writer,
     guint64 value);
 
+void
+gbinder_writer_append_float(
+    GBinderWriter* writer,
+    gfloat value);
+
+void
+gbinder_writer_append_double(
+    GBinderWriter* writer,
+    gdouble value);
+
 void
 gbinder_writer_append_string16(
     GBinderWriter* writer,

src/gbinder_local_reply.c

@@ -193,6 +193,28 @@ gbinder_local_reply_append_int64(
     return self;
 }
 
+GBinderLocalReply*
+gbinder_local_reply_append_float(
+    GBinderLocalReply* self,
+    gfloat value)
+{
+    if (G_LIKELY(self)) {
+        gbinder_writer_data_append_float(&self->data, value);
+    }
+    return self;
+}
+
+GBinderLocalReply*
+gbinder_local_reply_append_double(
+    GBinderLocalReply* self,
+    gdouble value)
+{
+    if (G_LIKELY(self)) {
+        gbinder_writer_data_append_double(&self->data, value);
+    }
+    return self;
+}
+
 GBinderLocalReply*
 gbinder_local_reply_append_string8(
     GBinderLocalReply* self,

src/gbinder_local_request.c

@@ -202,6 +202,28 @@ gbinder_local_request_append_int64(
     return self;
 }
 
+GBinderLocalRequest*
+gbinder_local_request_append_float(
+    GBinderLocalRequest* self,
+    gfloat value)
+{
+    if (G_LIKELY(self)) {
+        gbinder_writer_data_append_float(&self->data, value);
+    }
+    return self;
+}
+
+GBinderLocalRequest*
+gbinder_local_request_append_double(
+    GBinderLocalRequest* self,
+    gdouble value)
+{
+    if (G_LIKELY(self)) {
+        gbinder_writer_data_append_double(&self->data, value);
+    }
+    return self;
+}
+
 GBinderLocalRequest*
 gbinder_local_request_append_string8(
     GBinderLocalRequest* self,

src/gbinder_reader.c

@@ -189,6 +189,46 @@ gbinder_reader_read_uint64(
     }
 }
 
+gboolean
+gbinder_reader_read_float(
+    GBinderReader* reader,
+    gfloat* value)
+{
+    GBinderReaderPriv* p = gbinder_reader_cast(reader);
+
+    if (gbinder_reader_can_read(p, sizeof(*value))) {
+        if (value) {
+            const gfloat* ptr = (void*)p->ptr;
+
+            *value = *ptr;
+        }
+        p->ptr += sizeof(*value);
+        return TRUE;
+    } else {
+        return FALSE;
+    }
+}
+
+gboolean
+gbinder_reader_read_double(
+    GBinderReader* reader,
+    gdouble* value)
+{
+    GBinderReaderPriv* p = gbinder_reader_cast(reader);
+
+    if (gbinder_reader_can_read(p, sizeof(*value))) {
+        if (value) {
+            const gdouble* ptr = (void*)p->ptr;
+
+            *value = *ptr;
+        }
+        p->ptr += sizeof(*value);
+        return TRUE;
+    } else {
+        return FALSE;
+    }
+}
+
 gboolean
 gbinder_reader_read_nullable_object(
     GBinderReader* reader,

src/gbinder_writer.c

@@ -169,6 +169,54 @@ gbinder_writer_data_append_int64(
     *ptr = value;
 }
 
+void
+gbinder_writer_append_float(
+    GBinderWriter* self,
+    gfloat value)
+{
+    GBinderWriterData* data = gbinder_writer_data(self);
+
+    if (G_LIKELY(data)) {
+        gbinder_writer_data_append_float(data, value);
+    }
+}
+
+void
+gbinder_writer_data_append_float(
+    GBinderWriterData* data,
+    gfloat value)
+{
+    gfloat* ptr;
+
+    g_byte_array_set_size(data->bytes, data->bytes->len + sizeof(*ptr));
+    ptr = (void*)(data->bytes->data + (data->bytes->len - sizeof(*ptr)));
+    *ptr = value;
+}
+
+void
+gbinder_writer_append_double(
+    GBinderWriter* self,
+    gdouble value)
+{
+    GBinderWriterData* data = gbinder_writer_data(self);
+
+    if (G_LIKELY(data)) {
+        gbinder_writer_data_append_double(data, value);
+    }
+}
+
+void
+gbinder_writer_data_append_double(
+    GBinderWriterData* data,
+    gdouble value)
+{
+    gdouble* ptr;
+
+    g_byte_array_set_size(data->bytes, data->bytes->len + sizeof(*ptr));
+    ptr = (void*)(data->bytes->data + (data->bytes->len - sizeof(*ptr)));
+    *ptr = value;
+}
+
 void
 gbinder_writer_append_string8(
     GBinderWriter* self,

src/gbinder_writer_p.h

@@ -65,6 +65,16 @@ gbinder_writer_data_append_int64(
     GBinderWriterData* data,
     guint64 value);
 
+void
+gbinder_writer_data_append_float(
+    GBinderWriterData* data,
+    gfloat value);
+
+void
+gbinder_writer_data_append_double(
+    GBinderWriterData* data,
+    gdouble value);
+
 void
 gbinder_writer_data_append_string8(
     GBinderWriterData* data,

unit/unit_local_reply/unit_local_reply.c

@@ -81,6 +81,8 @@ test_null(
 
     g_assert(!gbinder_local_reply_append_int32(NULL, 0));
     g_assert(!gbinder_local_reply_append_int64(NULL, 0));
+    g_assert(!gbinder_local_reply_append_float(NULL, 0));
+    g_assert(!gbinder_local_reply_append_double(NULL, 0));
     g_assert(!gbinder_local_reply_append_string8(NULL, NULL));
     g_assert(!gbinder_local_reply_append_string16(NULL, NULL));
     g_assert(!gbinder_local_reply_append_hidl_string(NULL, NULL));
@@ -209,6 +211,50 @@ test_int64(
     gbinder_local_reply_unref(reply);
 }
 
+/*==========================================================================*
+ * float
+ *==========================================================================*/
+
+static
+void
+test_float(
+    void)
+{
+    const gfloat value = 123456789;
+    GBinderLocalReply* reply = gbinder_local_reply_new(&gbinder_io_32);
+    GBinderOutputData* data;
+
+    gbinder_local_reply_append_float(reply, value);
+    data = gbinder_local_reply_data(reply);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_reply_unref(reply);
+}
+
+/*==========================================================================*
+ * double
+ *==========================================================================*/
+
+static
+void
+test_double(
+    void)
+{
+    const gdouble value = 123456789;
+    GBinderLocalReply* reply = gbinder_local_reply_new(&gbinder_io_32);
+    GBinderOutputData* data;
+
+    gbinder_local_reply_append_double(reply, value);
+    data = gbinder_local_reply_data(reply);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_reply_unref(reply);
+}
+
 /*==========================================================================*
  * string8
  *==========================================================================*/
@@ -405,6 +451,8 @@ int main(int argc, char* argv[])
     g_test_add_func(TEST_PREFIX "bool", test_bool);
     g_test_add_func(TEST_PREFIX "int32", test_int32);
     g_test_add_func(TEST_PREFIX "int64", test_int64);
+    g_test_add_func(TEST_PREFIX "float", test_float);
+    g_test_add_func(TEST_PREFIX "double", test_double);
     g_test_add_func(TEST_PREFIX "string8", test_string8);
     g_test_add_func(TEST_PREFIX "string16", test_string16);
     g_test_add_func(TEST_PREFIX "hidl_string", test_hidl_string);

unit/unit_local_request/unit_local_request.c

@@ -79,6 +79,8 @@ test_null(
     g_assert(!gbinder_local_request_append_bool(NULL, FALSE));
     g_assert(!gbinder_local_request_append_int32(NULL, 0));
     g_assert(!gbinder_local_request_append_int64(NULL, 0));
+    g_assert(!gbinder_local_request_append_float(NULL, 0));
+    g_assert(!gbinder_local_request_append_double(NULL, 0));
     g_assert(!gbinder_local_request_append_string8(NULL, NULL));
     g_assert(!gbinder_local_request_append_string16(NULL, NULL));
     g_assert(!gbinder_local_request_append_hidl_string(NULL, NULL));
@@ -226,6 +228,50 @@ test_int64(
     gbinder_local_request_unref(req);
 }
 
+/*==========================================================================*
+ * float
+ *==========================================================================*/
+
+static
+void
+test_float(
+    void)
+{
+    const gfloat value = 123456789;
+    GBinderLocalRequest* req = gbinder_local_request_new(&gbinder_io_32, NULL);
+    GBinderOutputData* data;
+
+    gbinder_local_request_append_float(req, value);
+    data = gbinder_local_request_data(req);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_request_unref(req);
+}
+
+/*==========================================================================*
+ * double
+ *==========================================================================*/
+
+static
+void
+test_double(
+    void)
+{
+    const gdouble value = 123456789;
+    GBinderLocalRequest* req = gbinder_local_request_new(&gbinder_io_32, NULL);
+    GBinderOutputData* data;
+
+    gbinder_local_request_append_double(req, value);
+    data = gbinder_local_request_data(req);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_request_unref(req);
+}
+
 /*==========================================================================*
  * string8
  *==========================================================================*/
@@ -405,6 +451,8 @@ int main(int argc, char* argv[])
     g_test_add_func(TEST_PREFIX "bool", test_bool);
     g_test_add_func(TEST_PREFIX "int32", test_int32);
     g_test_add_func(TEST_PREFIX "int64", test_int64);
+    g_test_add_func(TEST_PREFIX "float", test_float);
+    g_test_add_func(TEST_PREFIX "double", test_double);
     g_test_add_func(TEST_PREFIX "string8", test_string8);
     g_test_add_func(TEST_PREFIX "string16", test_string16);
     g_test_add_func(TEST_PREFIX "hidl_string", test_hidl_string);

unit/unit_reader/unit_reader.c

@@ -73,6 +73,8 @@ test_empty(
     g_assert(!gbinder_reader_read_uint32(&reader, NULL));
     g_assert(!gbinder_reader_read_int64(&reader, NULL));
     g_assert(!gbinder_reader_read_uint64(&reader, NULL));
+    g_assert(!gbinder_reader_read_float(&reader, NULL));
+    g_assert(!gbinder_reader_read_double(&reader, NULL));
     g_assert(!gbinder_reader_read_object(&reader));
     g_assert(!gbinder_reader_read_nullable_object(&reader, NULL));
     g_assert(!gbinder_reader_read_buffer(&reader));
@@ -244,6 +246,84 @@ test_int64(
     gbinder_driver_unref(driver);
 }
 
+/*==========================================================================*
+ * float
+ *==========================================================================*/
+
+static
+void
+test_float(
+    void)
+{
+    const gfloat in = 42;
+    gfloat out1 = 0;
+    gfloat out2 = 0;
+    GBinderDriver* driver = gbinder_driver_new(GBINDER_DEFAULT_BINDER);
+    GBinderReader reader;
+    GBinderReaderData data;
+
+    g_assert(driver);
+    memset(&data, 0, sizeof(data));
+    data.buffer = gbinder_buffer_new(driver, g_memdup(&in, sizeof(in)),
+        sizeof(in));
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_float(&reader, &out1));
+    g_assert(gbinder_reader_at_end(&reader));
+    g_assert(in == out1);
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_float(&reader, &out2));
+    g_assert(gbinder_reader_at_end(&reader));
+    g_assert(in == (gfloat)out2);
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_float(&reader, NULL));
+    g_assert(gbinder_reader_at_end(&reader));
+
+    gbinder_buffer_free(data.buffer);
+    gbinder_driver_unref(driver);
+}
+
+/*==========================================================================*
+ * double
+ *==========================================================================*/
+
+static
+void
+test_double(
+    void)
+{
+    const gdouble in = 42;
+    gdouble out1 = 0;
+    gdouble out2 = 0;
+    GBinderDriver* driver = gbinder_driver_new(GBINDER_DEFAULT_BINDER);
+    GBinderReader reader;
+    GBinderReaderData data;
+
+    g_assert(driver);
+    memset(&data, 0, sizeof(data));
+    data.buffer = gbinder_buffer_new(driver, g_memdup(&in, sizeof(in)),
+        sizeof(in));
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_double(&reader, &out1));
+    g_assert(gbinder_reader_at_end(&reader));
+    g_assert(in == out1);
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_double(&reader, &out2));
+    g_assert(gbinder_reader_at_end(&reader));
+    g_assert(in == (gdouble)out2);
+
+    gbinder_reader_init(&reader, &data, 0, sizeof(in));
+    g_assert(gbinder_reader_read_double(&reader, NULL));
+    g_assert(gbinder_reader_at_end(&reader));
+
+    gbinder_buffer_free(data.buffer);
+    gbinder_driver_unref(driver);
+}
+
 /*==========================================================================*
  * string8
  *==========================================================================*/
@@ -659,6 +739,8 @@ int main(int argc, char* argv[])
     g_test_add_func(TEST_PREFIX "bool", test_bool);
     g_test_add_func(TEST_PREFIX "int32", test_int32);
     g_test_add_func(TEST_PREFIX "int64", test_int64);
+    g_test_add_func(TEST_PREFIX "float", test_float);
+    g_test_add_func(TEST_PREFIX "double", test_double);
 
     for (i = 0; i < G_N_ELEMENTS(test_string8_tests); i++) {
         const TestStringData* test = test_string8_tests + i;

unit/unit_writer/unit_writer.c

@@ -62,6 +62,10 @@ test_null(
     gbinder_writer_append_int32(&writer, 0);
     gbinder_writer_append_int64(NULL, 0);
     gbinder_writer_append_int64(&writer, 0);
+    gbinder_writer_append_float(NULL, 0);
+    gbinder_writer_append_float(&writer, 0);
+    gbinder_writer_append_double(NULL, 0);
+    gbinder_writer_append_double(&writer, 0);
     gbinder_writer_append_string8(NULL, NULL);
     gbinder_writer_append_string8(&writer, NULL);
     gbinder_writer_append_string8_len(NULL, NULL, 0);
@@ -139,6 +143,54 @@ test_int64(
     gbinder_local_request_unref(req);
 }
 
+/*==========================================================================*
+ * float
+ *==========================================================================*/
+
+static
+void
+test_float(
+    void)
+{
+    const gfloat value = 12345678;
+    GBinderLocalRequest* req = gbinder_local_request_new(&gbinder_io_32, NULL);
+    GBinderOutputData* data;
+    GBinderWriter writer;
+
+    gbinder_local_request_init_writer(req, &writer);
+    gbinder_writer_append_float(&writer, value);
+    data = gbinder_local_request_data(req);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_request_unref(req);
+}
+
+/*==========================================================================*
+ * double
+ *==========================================================================*/
+
+static
+void
+test_double(
+    void)
+{
+    const gdouble value = 12345678;
+    GBinderLocalRequest* req = gbinder_local_request_new(&gbinder_io_32, NULL);
+    GBinderOutputData* data;
+    GBinderWriter writer;
+
+    gbinder_local_request_init_writer(req, &writer);
+    gbinder_writer_append_double(&writer, value);
+    data = gbinder_local_request_data(req);
+    g_assert(!gbinder_output_data_offsets(data));
+    g_assert(!gbinder_output_data_buffers_size(data));
+    g_assert(data->bytes->len == sizeof(value));
+    g_assert(!memcmp(data->bytes->data, &value, data->bytes->len));
+    gbinder_local_request_unref(req);
+}
+
 /*==========================================================================*
  * bool
  *==========================================================================*/
@@ -583,6 +635,8 @@ int main(int argc, char* argv[])
     g_test_add_func(TEST_PREFIX "null", test_null);
     g_test_add_func(TEST_PREFIX "int32", test_int32);
     g_test_add_func(TEST_PREFIX "int64", test_int64);
+    g_test_add_func(TEST_PREFIX "float", test_float);
+    g_test_add_func(TEST_PREFIX "double", test_double);
     g_test_add_func(TEST_PREFIX "bool", test_bool);
     g_test_add_func(TEST_PREFIX "bytes", test_bytes);
     g_test_add_func(TEST_PREFIX "string8", test_string8);