- remove DICT type

[platform/upstream/dbus.git] / dbus / dbus-marshal-recursive.h

diff --git a/dbus/dbus-marshal-recursive.h b/dbus/dbus-marshal-recursive.h
index 57b55fc..679dad3 100644 (file)
--- a/dbus/dbus-marshal-recursive.h
+++ b/dbus/dbus-marshal-recursive.h
@@ -31,23 +31,9 @@
 #error "config.h not included here"
 #endif
 
-/* Notes on my plan to implement this:
- * - also have DBusTypeWriter (heh)
- * - TypeReader has accessors for:
- *    . basic type
- *    . array of basic type (efficiency hack)
- *    . another type reader
- * - a dict will appear to be a list of string, whatever, string, whatever
- * - a variant will contain another TypeReader
- * - a struct will be a list of whatever, whatever, whatever
- *
- * So the basic API usage is to go next, next, next; if the
- * item is a basic type or basic array then read the item;
- * if it's another type reader then process it; if it's
- * a container type (struct, array, variant, dict) then
- * recurse.
- * 
- */
+typedef struct DBusTypeReader      DBusTypeReader;
+typedef struct DBusTypeWriter      DBusTypeWriter;
+typedef struct DBusTypeReaderClass DBusTypeReaderClass;
 
 struct DBusTypeReader
 {
@@ -57,8 +43,7 @@ struct DBusTypeReader
   const DBusString *value_str;
   int value_pos;
 
-  /* Hmm - it might be cleaner to do TypeReaderClass *vtable for container type */
-  int container_type;
+  const DBusTypeReaderClass *klass;
   union
   {
     struct {
@@ -68,18 +53,11 @@ struct DBusTypeReader
     } array;
 
     struct {
-      int len_pos;
-
-    } dict;
-
-    struct {
       dbus_uint32_t finished : 1;
     } strct;
   } u;
 };
 
-typedef struct DBusTypeReader DBusTypeReader;
-
 struct DBusTypeWriter
 {
   int byte_order;
@@ -88,7 +66,7 @@ struct DBusTypeWriter
   DBusString *value_str;
   int value_pos;
 
-  dbus_uint32_t inside_array : 1;
+  dbus_uint32_t type_pos_is_expectation : 1; /* type_pos is an insertion point or an expected next type */
 
   int container_type;
   union
@@ -96,18 +74,12 @@ struct DBusTypeWriter
     struct {
       int start_pos; /* first element */
       int len_pos;
-      char *element_type;
+      int element_type_pos; /* position in type_str of array element type */
+      int element_type_len;
     } array;
-
-    struct {
-      int len_pos;
-
-    } dict;
   } u;
 };
 
-typedef struct DBusTypeWriter DBusTypeWriter;
-
 void        _dbus_type_reader_init                (DBusTypeReader    *reader,
                                                    int                byte_order,
                                                    const DBusString  *type_str,
@@ -115,7 +87,7 @@ void        _dbus_type_reader_init                (DBusTypeReader    *reader,
                                                    const DBusString  *value_str,
                                                    int                value_pos);
 int         _dbus_type_reader_get_current_type    (DBusTypeReader    *reader);
-int         _dbus_type_reader_get_array_length    (DBusTypeReader    *reader);
+dbus_bool_t _dbus_type_reader_array_is_empty      (DBusTypeReader    *reader);
 void        _dbus_type_reader_read_basic          (DBusTypeReader    *reader,
                                                    void              *value);
 dbus_bool_t _dbus_type_reader_read_array_of_basic (DBusTypeReader    *reader,
@@ -126,27 +98,30 @@ void        _dbus_type_reader_recurse             (DBusTypeReader    *reader,
                                                    DBusTypeReader    *subreader);
 dbus_bool_t _dbus_type_reader_next                (DBusTypeReader    *reader);
 
-void        _dbus_type_writer_init          (DBusTypeWriter *writer,
-                                             int             byte_order,
-                                             DBusString     *type_str,
-                                             int             type_pos,
-                                             DBusString     *value_str,
-                                             int             value_pos);
-dbus_bool_t _dbus_type_writer_write_basic   (DBusTypeWriter *writer,
-                                             int             type,
-                                             const void     *value);
-dbus_bool_t _dbus_type_writer_write_array   (DBusTypeWriter *writer,
-                                             int             type,
-                                             const void     *array,
-                                             int             array_len);
-dbus_bool_t _dbus_type_writer_recurse       (DBusTypeWriter *writer,
-                                             int             container_type,
-                                             DBusTypeWriter *sub);
-dbus_bool_t _dbus_type_writer_recurse_array (DBusTypeWriter *writer,
-                                             const char     *element_type,
-                                             DBusTypeWriter *sub);
-dbus_bool_t _dbus_type_writer_unrecurse     (DBusTypeWriter *writer,
-                                             DBusTypeWriter *sub);
+void        _dbus_type_writer_init            (DBusTypeWriter *writer,
+                                               int             byte_order,
+                                               DBusString     *type_str,
+                                               int             type_pos,
+                                               DBusString     *value_str,
+                                               int             value_pos);
+dbus_bool_t _dbus_type_writer_write_basic     (DBusTypeWriter *writer,
+                                               int             type,
+                                               const void     *value);
+dbus_bool_t _dbus_type_writer_write_array     (DBusTypeWriter *writer,
+                                               int             type,
+                                               const void     *array,
+                                               int             array_len);
+dbus_bool_t _dbus_type_writer_recurse_struct  (DBusTypeWriter *writer,
+                                               DBusTypeWriter *sub);
+dbus_bool_t _dbus_type_writer_recurse_array   (DBusTypeWriter *writer,
+                                               const char     *element_type,
+                                               DBusTypeWriter *sub);
+dbus_bool_t _dbus_type_writer_recurse_variant (DBusTypeWriter *writer,
+                                               const char     *contained_type,
+                                               DBusTypeWriter *sub);
+dbus_bool_t _dbus_type_writer_unrecurse       (DBusTypeWriter *writer,
+                                               DBusTypeWriter *sub);
+
 
 
 #endif /* DBUS_MARSHAL_RECURSIVE_H */