glib/gvariant.h

   1 /*
   2  * Copyright © 2007, 2008 Ryan Lortie
   3  * Copyright © 2009, 2010 Codethink Limited
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the licence, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Ryan Lortie <desrt@desrt.ca>
  21  */
  22
  23 #if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
  24 #error "Only <glib.h> can be included directly."
  25 #endif
  26
  27 #ifndef __G_VARIANT_H__
  28 #define __G_VARIANT_H__
  29
  30 #include <glib/gvarianttype.h>
  31 #include <glib/gstring.h>
  32
  33 G_BEGIN_DECLS
  34
  35 typedef struct _GVariant        GVariant;
  36
  37 typedef enum
  38 {
  39   G_VARIANT_CLASS_BOOLEAN       = 'b',
  40   G_VARIANT_CLASS_BYTE          = 'y',
  41   G_VARIANT_CLASS_INT16         = 'n',
  42   G_VARIANT_CLASS_UINT16        = 'q',
  43   G_VARIANT_CLASS_INT32         = 'i',
  44   G_VARIANT_CLASS_UINT32        = 'u',
  45   G_VARIANT_CLASS_INT64         = 'x',
  46   G_VARIANT_CLASS_UINT64        = 't',
  47   G_VARIANT_CLASS_HANDLE        = 'h',
  48   G_VARIANT_CLASS_DOUBLE        = 'd',
  49   G_VARIANT_CLASS_STRING        = 's',
  50   G_VARIANT_CLASS_OBJECT_PATH   = 'o',
  51   G_VARIANT_CLASS_SIGNATURE     = 'g',
  52   G_VARIANT_CLASS_VARIANT       = 'v',
  53   G_VARIANT_CLASS_MAYBE         = 'm',
  54   G_VARIANT_CLASS_ARRAY         = 'a',
  55   G_VARIANT_CLASS_TUPLE         = '(',
  56   G_VARIANT_CLASS_DICT_ENTRY    = '{'
  57 } GVariantClass;
  58
  59 void                            g_variant_unref                         (GVariant             *value);
  60 GVariant *                      g_variant_ref                           (GVariant             *value);
  61 GVariant *                      g_variant_ref_sink                      (GVariant             *value);
  62 gboolean                        g_variant_is_floating                   (GVariant             *value);
  63 GVariant *                      g_variant_take_ref                      (GVariant             *value);
  64
  65 const GVariantType *            g_variant_get_type                      (GVariant             *value);
  66 const gchar *                   g_variant_get_type_string               (GVariant             *value);
  67 gboolean                        g_variant_is_of_type                    (GVariant             *value,
  68                                                                          const GVariantType   *type);
  69 gboolean                        g_variant_is_container                  (GVariant             *value);
  70 GVariantClass                   g_variant_classify                      (GVariant             *value);
  71 GVariant *                      g_variant_new_boolean                   (gboolean              value);
  72 GVariant *                      g_variant_new_byte                      (guchar                value);
  73 GVariant *                      g_variant_new_int16                     (gint16                value);
  74 GVariant *                      g_variant_new_uint16                    (guint16               value);
  75 GVariant *                      g_variant_new_int32                     (gint32                value);
  76 GVariant *                      g_variant_new_uint32                    (guint32               value);
  77 GVariant *                      g_variant_new_int64                     (gint64                value);
  78 GVariant *                      g_variant_new_uint64                    (guint64               value);
  79 GVariant *                      g_variant_new_handle                    (gint32                value);
  80 GVariant *                      g_variant_new_double                    (gdouble               value);
  81 GVariant *                      g_variant_new_string                    (const gchar          *string);
  82 GVariant *                      g_variant_new_object_path               (const gchar          *object_path);
  83 gboolean                        g_variant_is_object_path                (const gchar          *string);
  84 GVariant *                      g_variant_new_signature                 (const gchar          *signature);
  85 gboolean                        g_variant_is_signature                  (const gchar          *string);
  86 GVariant *                      g_variant_new_variant                   (GVariant             *value);
  87 GVariant *                      g_variant_new_strv                      (const gchar * const  *strv,
  88                                                                          gssize                length);
  89 GLIB_AVAILABLE_IN_2_30
  90 GVariant *                      g_variant_new_objv                      (const gchar * const  *strv,
  91                                                                          gssize                length);
  92 GVariant *                      g_variant_new_bytestring                (const gchar          *string);
  93 GVariant *                      g_variant_new_bytestring_array          (const gchar * const  *strv,
  94                                                                          gssize                length);
  95 GVariant *                      g_variant_new_fixed_array               (const GVariantType   *element_type,
  96                                                                          gconstpointer         elements,
  97                                                                          gsize                 n_elements,
  98                                                                          gsize                 element_size);
  99 gboolean                        g_variant_get_boolean                   (GVariant             *value);
 100 guchar                          g_variant_get_byte                      (GVariant             *value);
 101 gint16                          g_variant_get_int16                     (GVariant             *value);
 102 guint16                         g_variant_get_uint16                    (GVariant             *value);
 103 gint32                          g_variant_get_int32                     (GVariant             *value);
 104 guint32                         g_variant_get_uint32                    (GVariant             *value);
 105 gint64                          g_variant_get_int64                     (GVariant             *value);
 106 guint64                         g_variant_get_uint64                    (GVariant             *value);
 107 gint32                          g_variant_get_handle                    (GVariant             *value);
 108 gdouble                         g_variant_get_double                    (GVariant             *value);
 109 GVariant *                      g_variant_get_variant                   (GVariant             *value);
 110 const gchar *                   g_variant_get_string                    (GVariant             *value,
 111                                                                          gsize                *length);
 112 gchar *                         g_variant_dup_string                    (GVariant             *value,
 113                                                                          gsize                *length);
 114 const gchar **                  g_variant_get_strv                      (GVariant             *value,
 115                                                                          gsize                *length);
 116 gchar **                        g_variant_dup_strv                      (GVariant             *value,
 117                                                                          gsize                *length);
 118 GLIB_AVAILABLE_IN_2_30
 119 const gchar **                  g_variant_get_objv                      (GVariant             *value,
 120                                                                          gsize                *length);
 121 gchar **                        g_variant_dup_objv                      (GVariant             *value,
 122                                                                          gsize                *length);
 123 const gchar *                   g_variant_get_bytestring                (GVariant             *value);
 124 gchar *                         g_variant_dup_bytestring                (GVariant             *value,
 125                                                                          gsize                *length);
 126 const gchar **                  g_variant_get_bytestring_array          (GVariant             *value,
 127                                                                          gsize                *length);
 128 gchar **                        g_variant_dup_bytestring_array          (GVariant             *value,
 129                                                                          gsize                *length);
 130
 131 GVariant *                      g_variant_new_maybe                     (const GVariantType   *child_type,
 132                                                                          GVariant             *child);
 133 GVariant *                      g_variant_new_array                     (const GVariantType   *child_type,
 134                                                                          GVariant * const     *children,
 135                                                                          gsize                 n_children);
 136 GVariant *                      g_variant_new_tuple                     (GVariant * const     *children,
 137                                                                          gsize                 n_children);
 138 GVariant *                      g_variant_new_dict_entry                (GVariant             *key,
 139                                                                          GVariant             *value);
 140
 141 GVariant *                      g_variant_get_maybe                     (GVariant             *value);
 142 gsize                           g_variant_n_children                    (GVariant             *value);
 143 void                            g_variant_get_child                     (GVariant             *value,
 144                                                                          gsize                 index_,
 145                                                                          const gchar          *format_string,
 146                                                                          ...);
 147 GVariant *                      g_variant_get_child_value               (GVariant             *value,
 148                                                                          gsize                 index_);
 149 gboolean                        g_variant_lookup                        (GVariant             *dictionary,
 150                                                                          const gchar          *key,
 151                                                                          const gchar          *format_string,
 152                                                                          ...);
 153 GVariant *                      g_variant_lookup_value                  (GVariant             *dictionary,
 154                                                                          const gchar          *key,
 155                                                                          const GVariantType   *expected_type);
 156 gconstpointer                   g_variant_get_fixed_array               (GVariant             *value,
 157                                                                          gsize                *n_elements,
 158                                                                          gsize                 element_size);
 159
 160 gsize                           g_variant_get_size                      (GVariant             *value);
 161 gconstpointer                   g_variant_get_data                      (GVariant             *value);
 162 void                            g_variant_store                         (GVariant             *value,
 163                                                                          gpointer              data);
 164
 165 gchar *                         g_variant_print                         (GVariant             *value,
 166                                                                          gboolean              type_annotate);
 167 GString *                       g_variant_print_string                  (GVariant             *value,
 168                                                                          GString              *string,
 169                                                                          gboolean              type_annotate);
 170
 171 guint                           g_variant_hash                          (gconstpointer         value);
 172 gboolean                        g_variant_equal                         (gconstpointer         one,
 173                                                                          gconstpointer         two);
 174
 175 GVariant *                      g_variant_get_normal_form               (GVariant             *value);
 176 gboolean                        g_variant_is_normal_form                (GVariant             *value);
 177 GVariant *                      g_variant_byteswap                      (GVariant             *value);
 178 GVariant *                      g_variant_new_from_data                 (const GVariantType   *type,
 179                                                                          gconstpointer         data,
 180                                                                          gsize                 size,
 181                                                                          gboolean              trusted,
 182                                                                          GDestroyNotify        notify,
 183                                                                          gpointer              user_data);
 184
 185 typedef struct _GVariantIter GVariantIter;
 186 struct _GVariantIter {
 187   /*< private >*/
 188   gsize x[16];
 189 };
 190
 191 GVariantIter *                  g_variant_iter_new                      (GVariant             *value);
 192 gsize                           g_variant_iter_init                     (GVariantIter         *iter,
 193                                                                          GVariant             *value);
 194 GVariantIter *                  g_variant_iter_copy                     (GVariantIter         *iter);
 195 gsize                           g_variant_iter_n_children               (GVariantIter         *iter);
 196 void                            g_variant_iter_free                     (GVariantIter         *iter);
 197 GVariant *                      g_variant_iter_next_value               (GVariantIter         *iter);
 198 gboolean                        g_variant_iter_next                     (GVariantIter         *iter,
 199                                                                          const gchar          *format_string,
 200                                                                          ...);
 201 gboolean                        g_variant_iter_loop                     (GVariantIter         *iter,
 202                                                                          const gchar          *format_string,
 203                                                                          ...);
 204
 205
 206 typedef struct _GVariantBuilder GVariantBuilder;
 207 struct _GVariantBuilder {
 208   /*< private >*/
 209   gsize x[16];
 210 };
 211
 212 typedef enum
 213 {
 214   G_VARIANT_PARSE_ERROR_FAILED,
 215   G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED,
 216   G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE,
 217   G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED,
 218   G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END,
 219   G_VARIANT_PARSE_ERROR_INVALID_CHARACTER,
 220   G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING,
 221   G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH,
 222   G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE,
 223   G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING,
 224   G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE,
 225   G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE,
 226   G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG,
 227   G_VARIANT_PARSE_ERROR_TYPE_ERROR,
 228   G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN,
 229   G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD,
 230   G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT,
 231   G_VARIANT_PARSE_ERROR_VALUE_EXPECTED
 232 } GVariantParseError;
 233 #define G_VARIANT_PARSE_ERROR (g_variant_parser_get_error_quark ())
 234
 235 GQuark                          g_variant_parser_get_error_quark        (void);
 236
 237 GVariantBuilder *               g_variant_builder_new                   (const GVariantType   *type);
 238 void                            g_variant_builder_unref                 (GVariantBuilder      *builder);
 239 GVariantBuilder *               g_variant_builder_ref                   (GVariantBuilder      *builder);
 240 void                            g_variant_builder_init                  (GVariantBuilder      *builder,
 241                                                                          const GVariantType   *type);
 242 GVariant *                      g_variant_builder_end                   (GVariantBuilder      *builder);
 243 void                            g_variant_builder_clear                 (GVariantBuilder      *builder);
 244 void                            g_variant_builder_open                  (GVariantBuilder      *builder,
 245                                                                          const GVariantType   *type);
 246 void                            g_variant_builder_close                 (GVariantBuilder      *builder);
 247 void                            g_variant_builder_add_value             (GVariantBuilder      *builder,
 248                                                                          GVariant             *value);
 249 void                            g_variant_builder_add                   (GVariantBuilder      *builder,
 250                                                                          const gchar          *format_string,
 251                                                                          ...);
 252 void                            g_variant_builder_add_parsed            (GVariantBuilder      *builder,
 253                                                                          const gchar          *format,
 254                                                                          ...);
 255
 256 GVariant *                      g_variant_new                           (const gchar          *format_string,
 257                                                                          ...);
 258 void                            g_variant_get                           (GVariant             *value,
 259                                                                          const gchar          *format_string,
 260                                                                          ...);
 261 GVariant *                      g_variant_new_va                        (const gchar          *format_string,
 262                                                                          const gchar         **endptr,
 263                                                                          va_list              *app);
 264 void                            g_variant_get_va                        (GVariant             *value,
 265                                                                          const gchar          *format_string,
 266                                                                          const gchar         **endptr,
 267                                                                          va_list              *app);
 268 gboolean                        g_variant_check_format_string           (GVariant             *value,
 269                                                                          const gchar          *format_string,
 270                                                                          gboolean              copy_only);
 271
 272 GVariant *                      g_variant_parse                         (const GVariantType   *type,
 273                                                                          const gchar          *text,
 274                                                                          const gchar          *limit,
 275                                                                          const gchar         **endptr,
 276                                                                          GError              **error);
 277 GVariant *                      g_variant_new_parsed                    (const gchar          *format,
 278                                                                          ...);
 279 GVariant *                      g_variant_new_parsed_va                 (const gchar          *format,
 280                                                                          va_list              *app);
 281
 282 gint                            g_variant_compare                       (gconstpointer one,
 283                                                                          gconstpointer two);
 284 G_END_DECLS
 285
 286 #endif /* __G_VARIANT_H__ */