Remove fcall and fret

2025-09-12 12:59:30 +00:00 · 2012-06-04 00:19:16 +08:00
parent 4b51d49593
commit 84d8110465
16 changed files with 574 additions and 417 deletions
--- a/lib/searpc-client.c
+++ b/lib/searpc-client.c
@@ -32,11 +32,258 @@ searpc_client_transport_send (SearpcClient *client,
                             fcall_len, ret_len);
 }

+static char *
+fcall_to_str (const char *fname, int n_params, va_list args, gsize *len)
+{
+    JsonArray *array;
+    
+    array = json_array_new ();
+    json_array_add_string_element (array, fname);
+
+    int i = 0;
+    for (; i < n_params; i++) {
+        const char *type = va_arg(args, const char *);
+        void *value = va_arg(args, void *);
+        if (strcmp(type, "int") == 0)
+            json_array_add_int_element (array, (int)value);
+        else if (strcmp(type, "string") == 0)
+            json_array_add_string_or_null_element (array, (char *)value);
+        else {
+            g_warning ("unrecognized parameter type %s\n", type);
+            return NULL;
+        }
+    }
+
+    gchar *data;
+    JsonGenerator *gen = json_generator_new ();
+    JsonNode *root;
+
+    root = json_node_new (JSON_NODE_ARRAY);
+    json_node_take_array (root, array);
+    json_generator_set_root (gen, root);
+
+    g_object_set (gen, "pretty", FALSE, NULL);
+    data = json_generator_to_data (gen, len);
+
+    json_node_free (root);
+    g_object_unref (gen);
+
+    return data;
+}
+
+void
+searpc_client_call (SearpcClient *client, const char *fname,
+                    const char *ret_type, int gobject_type,
+                    void *ret_ptr, GError **error,
+                    int n_params, ...)
+{
+    g_return_if_fail (fname != NULL);
+    g_return_if_fail (ret_type != NULL);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return;
+    }
+
+    if (strcmp(ret_type, "int") == 0)
+        *((int *)ret_ptr) = searpc_client_fret__int (fret, ret_len, error);
+    else if (strcmp(ret_type, "int64") == 0)
+        *((gint64 *)ret_ptr) = searpc_client_fret__int64 (fret, ret_len, error);
+    else if (strcmp(ret_type, "string") == 0)
+        *((char **)ret_ptr) = searpc_client_fret__string (fret, len, error);
+    else if (strcmp(ret_type, "object") == 0)
+        *((GObject **)ret_ptr) = searpc_client_fret__object (gobject_type, fret,
+                                                             ret_len, error);
+    else if (strcmp(ret_type, "objlist") == 0)
+        *((GList **)ret_ptr) = searpc_client_fret__objlist (gobject_type, fret,
+                                                            ret_len, error);
+    else
+        g_warning ("unrecognized return type %s\n", ret_type);
+    
+    g_free (fstr);
+    g_free (fret);
+}
+
+int
+searpc_client_call__int (SearpcClient *client, const char *fname,
+                         GError **error, int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, 0);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return 0;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return 0;
+    }
+
+    int ret = searpc_client_fret__int (fret, ret_len, error);
+    g_free (fstr);
+    g_free (fret);
+    return ret;
+}
+
+gint64
+searpc_client_call__int64 (SearpcClient *client, const char *fname,
+                         GError **error, int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, 0);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return 0;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return 0;
+    }
+
+    gint64 ret = searpc_client_fret__int64 (fret, ret_len, error);
+    g_free (fstr);
+    g_free (fret);
+    return ret;
+}
+
+char *
+searpc_client_call__string (SearpcClient *client, const char *fname,
+                            GError **error, int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, NULL);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return NULL;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return NULL;
+    }
+
+    char *ret = searpc_client_fret__string (fret, ret_len, error);
+    g_free (fstr);
+    g_free (fret);
+    return ret;
+}
+
+GObject *
+searpc_client_call__object (SearpcClient *client, const char *fname,
+                            int object_type,
+                            GError **error, int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, NULL);
+    g_return_val_if_fail (object_type != 0, NULL);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return NULL;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return NULL;
+    }
+
+    GObject *ret = searpc_client_fret__object (object_type, fret, ret_len, error);
+    g_free (fstr);
+    g_free (fret);
+    return ret;
+}
+
+GList*
+searpc_client_call__objlist (SearpcClient *client, const char *fname,
+                             int object_type,
+                             GError **error, int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, NULL);
+    g_return_val_if_fail (object_type != 0, NULL);
+
+    va_list args;
+    gsize len, ret_len;
+    char *fstr;
+
+    va_start (args, n_params);
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    va_end (args);
+    if (!fstr) {
+        g_set_error (error, DFT_DOMAIN, 0, "Invalid Parameter");
+        return NULL;
+    }
+ 
+    char *fret = searpc_client_transport_send (client, fstr, len, &ret_len);
+    if (!fret) {
+        g_free (fstr);
+        g_set_error (error, DFT_DOMAIN, TRANSPORT_ERROR_CODE, TRANSPORT_ERROR);
+        return NULL;
+    }
+
+    GList *ret = searpc_client_fret__objlist (object_type, fret, ret_len, error);
+    g_free (fstr);
+    g_free (fret);
+    return ret;
+}
+
+
 typedef struct {
    SearpcClient *client;
    AsyncCallback callback;
    const gchar *ret_type;
-    int gtype;
+    int gtype;                /* to specify the specific gobject type 
+                                 if ret_type is object or objlist */
    void *cbdata;
 } AsyncCallData;

@@ -77,15 +324,24 @@ searpc_client_generic_callback (char *retstr, size_t len,
    g_free (data);
 }

+
 int
-searpc_client_async_call (SearpcClient *client,
-                          gchar *fcall_str,
-                          size_t fcall_len,
-                          AsyncCallback callback,
-                          const gchar *ret_type,
-                          int gtype,
-                          void *cbdata)
+searpc_client_async_call_v (SearpcClient *client,
+                            const char *fname,
+                            AsyncCallback callback,
+                            const gchar *ret_type,
+                            int gtype,
+                            void *cbdata,
+                            int n_params,
+                            va_list args)
 {
+    gsize len, ret_len;
+    char *fstr;
+
+    fstr = fcall_to_str (fname, n_params, args, &len);
+    if (!fstr)
+        return -1;
+    
    int ret;
    AsyncCallData *data = g_new0(AsyncCallData, 1);
    data->client = client;
@@ -94,7 +350,7 @@ searpc_client_async_call (SearpcClient *client,
    data->gtype = gtype;
    data->cbdata = cbdata;

-    ret = client->async_send (client->async_arg, fcall_str, fcall_len, data);
+    ret = client->async_send (client->async_arg, fstr, len, data);
    if (ret < 0) {
        g_free (data);
        return -1;
@@ -102,30 +358,99 @@ searpc_client_async_call (SearpcClient *client,
    return 0;
 }

-/*
- * serialize function call from array to string
- */
-static char *
-fcall_common (JsonArray *array, gsize *len)
+int
+searpc_client_async_call__int (SearpcClient *client,
+                               const char *fname,
+                               AsyncCallback callback, void *cbdata,
+                               int n_params, ...)
 {
-    gchar *data;
-    JsonGenerator *gen = json_generator_new ();
-    JsonNode *root;
+    g_return_val_if_fail (fname != NULL, -1);

-    root = json_node_new (JSON_NODE_ARRAY);
-    json_node_take_array (root, array);
-    json_generator_set_root (gen, root);
+    va_list args;
+    int ret;

-    g_object_set (gen, "pretty", FALSE, NULL);
-    data = json_generator_to_data (gen, len);
-
-    json_node_free (root);
-    g_object_unref (gen);
-
-    return data;
+    va_start (args, n_params);
+    ret = searpc_client_async_call_v (client, fname, callback, "int", 0, cbdata,
+                                      n_params, args);
+    va_end (args);
+    return ret;
 }

-#include "fcall-impr.h"
+int
+searpc_client_async_call__int64 (SearpcClient *client,
+                                 const char *fname,
+                                 AsyncCallback callback, void *cbdata,
+                                 int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, -1);
+
+    va_list args;
+    int ret;
+
+    va_start (args, n_params);
+    ret = searpc_client_async_call_v (client, fname, callback, "int64", 0, cbdata,
+                                      n_params, args);
+    va_end (args);
+    return ret;
+}
+
+int
+searpc_client_async_call__string (SearpcClient *client,
+                                  const char *fname,
+                                  AsyncCallback callback, void *cbdata,
+                                  int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, -1);
+
+    va_list args;
+    int ret;
+
+    va_start (args, n_params);
+    ret = searpc_client_async_call_v (client, fname, callback, "string", 0, cbdata,
+                                      n_params, args);
+    va_end (args);
+    return ret;
+}
+
+int
+searpc_client_async_call__object (SearpcClient *client,
+                                  const char *fname,
+                                  AsyncCallback callback, 
+                                  int object_type, void *cbdata,
+                                  int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, -1);
+
+    va_list args;
+    int ret;
+
+    va_start (args, n_params);
+    ret = searpc_client_async_call_v (client, fname, callback, "object",
+                                      object_type, cbdata,
+                                      n_params, args);
+    va_end (args);
+    return ret;
+}
+
+int
+searpc_client_async_call__objlist (SearpcClient *client,
+                                   const char *fname,
+                                   AsyncCallback callback, 
+                                   int object_type, void *cbdata,
+                                   int n_params, ...)
+{
+    g_return_val_if_fail (fname != NULL, -1);
+
+    va_list args;
+    int ret;
+
+    va_start (args, n_params);
+    ret = searpc_client_async_call_v (client, fname, callback, "objlist",
+                                      object_type, cbdata,
+                                      n_params, args);
+    va_end (args);
+    return ret;   
+}


 /*