gboolean bucket_store_mapping_client_recv_get_mapping (BucketStoreMappingIf * iface, GHashTable ** _return, BucketStoreMappingException ** e, GError ** error)
{
gint32 rseqid;
gchar * fname;
ThriftMessageType mtype;
ThriftProtocol * protocol = BUCKET_STORE_MAPPING_CLIENT (iface)->input_protocol;
if (thrift_protocol_read_message_begin (protocol, &fname, &mtype, &rseqid, error) < 0)
{
if (fname) g_free (fname);
return FALSE;
}
if (mtype == T_EXCEPTION) {
if (fname) g_free (fname);
ThriftApplicationException *xception = g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);
thrift_struct_read (THRIFT_STRUCT (xception), protocol, NULL);
thrift_protocol_read_message_end (protocol, NULL);
thrift_transport_read_end (protocol->transport, NULL);
g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, xception->type, "application error: %s", xception->message);
g_object_unref (xception);
return FALSE;
} else if (mtype != T_REPLY) {
if (fname) g_free (fname);
thrift_protocol_skip (protocol, T_STRUCT, NULL);
thrift_protocol_read_message_end (protocol, NULL);
thrift_transport_read_end (protocol->transport, NULL);
g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "invalid message type %d, expected T_REPLY", mtype);
return FALSE;
} else if (strncmp (fname, "getMapping", 10) != 0) {
thrift_protocol_skip (protocol, T_STRUCT, NULL);
thrift_protocol_read_message_end (protocol, error);
thrift_transport_read_end (protocol->transport, error);
g_set_error (error, THRIFT_APPLICATION_EXCEPTION_ERROR, THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "wrong method name %s, expected getMapping", fname);
if (fname) g_free (fname);
return FALSE;
}
if (fname) g_free (fname);
{
gint32 ret;
gint32 xfer = 0;
gchar *name = NULL;
ThriftType ftype;
gint16 fid;
guint32 len = 0;
gpointer data = NULL;
/* satisfy -Wall in case these aren't used */
THRIFT_UNUSED_VAR (len);
THRIFT_UNUSED_VAR (data);
/* read the struct begin marker */
if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)
{
if (name) g_free (name);
return 0;
}
xfer += ret;
if (name) g_free (name);
name = NULL;
/* read the struct fields */
while (1)
{
/* read the beginning of a field */
if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)
{
if (name) g_free (name);
return 0;
}
xfer += ret;
if (name) g_free (name);
name = NULL;
/* break if we get a STOP field */
if (ftype == T_STOP)
{
break;
}
switch (fid)
{
case 0:
if (ftype == T_MAP)
{
{
guint32 size;
ThriftType key_type;
ThriftType value_type;
/* read the map begin marker */
if ((ret = thrift_protocol_read_map_begin (protocol, &key_type, &value_type, &size, error)) < 0)
return 0;
xfer += ret;
/* iterate through each of the map's fields */
guint32 i;
for (i = 0; i < size; i++)
{
gint32* key0 = g_new (gint32, 1);
HostPort * val1 = NULL;
if ((ret = thrift_protocol_read_i32 (protocol, &*key0, error)) < 0)
return 0;
xfer += ret;
if ( val1 != NULL)
{
g_object_unref (val1);
}
val1 = g_object_new (TYPE_HOST_PORT, NULL);
if ((ret = thrift_struct_read (THRIFT_STRUCT (val1), protocol, error)) < 0)
{
g_object_unref (val1);
return 0;
}
xfer += ret;
g_hash_table_insert ((GHashTable *)*_return, (gpointer) key0, (gpointer) val1);
}
/* read the map end marker */
if ((ret = thrift_protocol_read_map_end (protocol, error)) < 0)
return 0;
xfer += ret;
}
} else {
if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
return 0;
xfer += ret;
}
break;
case 1:
if (ftype == T_STRUCT)
{
/* This struct is an exception */
if ( *e != NULL)
{
g_object_unref (*e);
}
*e = g_object_new (TYPE_BUCKET_STORE_MAPPING_EXCEPTION, NULL);
if ((ret = thrift_struct_read (THRIFT_STRUCT (*e), protocol, error)) < 0)
{
g_object_unref (*e);
return 0;
}
xfer += ret;
} else {
if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
return 0;
xfer += ret;
}
break;
default:
if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)
return 0;
xfer += ret;
break;
}
if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)
return 0;
xfer += ret;
}
if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)
return 0;
xfer += ret;
}
if (thrift_protocol_read_message_end (protocol, error) < 0)
return FALSE;
if (!thrift_transport_read_end (protocol->transport, error))
return FALSE;
if (*e != NULL)
{
g_set_error (error, BUCKET_STORE_MAPPING_EXCEPTION_ERROR, BUCKET_STORE_MAPPING_EXCEPTION_ERROR_CODE, "BucketStoreMappingException");
return FALSE;
}
return TRUE;
}
gint32
thrift_protocol_skip (ThriftProtocol *protocol, ThriftType type, GError **error)
{
switch (type)
{
case T_BOOL:
{
gboolean boolv;
return thrift_protocol_read_bool (protocol, &boolv, error);
}
case T_BYTE:
{
gint8 bytev;
return thrift_protocol_read_byte (protocol, &bytev, error);
}
case T_I16:
{
gint16 i16;
return thrift_protocol_read_i16 (protocol, &i16, error);
}
case T_I32:
{
gint32 i32;
return thrift_protocol_read_i32 (protocol, &i32, error);
}
case T_I64:
{
gint64 i64;
return thrift_protocol_read_i64 (protocol, &i64, error);
}
case T_DOUBLE:
{
gdouble dub;
return thrift_protocol_read_double (protocol, &dub, error);
}
case T_STRING:
{
gpointer data;
guint32 len;
gint32 ret = thrift_protocol_read_binary (protocol, &data, &len, error);
g_free (data);
return ret;
}
case T_STRUCT:
{
guint32 result = 0;
gchar *name;
gint16 fid;
ThriftType ftype;
result += thrift_protocol_read_struct_begin (protocol, &name, error);
while (1)
{
result += thrift_protocol_read_field_begin (protocol, &name, &ftype,
&fid, error);
if (ftype == T_STOP)
{
break;
}
result += thrift_protocol_skip (protocol, ftype, error);
result += thrift_protocol_read_field_end (protocol, error);
}
result += thrift_protocol_read_struct_end (protocol, error);
return result;
}
case T_SET:
{
guint32 result = 0;
ThriftType elem_type;
guint32 i, size;
result += thrift_protocol_read_set_begin (protocol, &elem_type, &size,
error);
for (i = 0; i < size; i++)
{
result += thrift_protocol_skip (protocol, elem_type, error);
}
result += thrift_protocol_read_set_end (protocol, error);
return result;
}
case T_MAP:
{
guint32 result = 0;
ThriftType elem_type;
ThriftType key_type;
guint32 i, size;
result += thrift_protocol_read_map_begin (protocol, &key_type, &elem_type, &size,
error);
for (i = 0; i < size; i++)
{
result += thrift_protocol_skip (protocol, key_type, error);
result += thrift_protocol_skip (protocol, elem_type, error);
}
result += thrift_protocol_read_map_end (protocol, error);
return result;
}
case T_LIST:
{
guint32 result = 0;
ThriftType elem_type;
guint32 i, size;
result += thrift_protocol_read_list_begin (protocol, &elem_type, &size,
error);
for (i = 0; i < size; i++)
{
result += thrift_protocol_skip (protocol, elem_type, error);
}
result += thrift_protocol_read_list_end (protocol, error);
return result;
}
default:
return 0;
}
}
