ossrv_pub/dbus/inc/dbus-message.h
changeset 0 e4d67989cc36
equal deleted inserted replaced
-1:000000000000 0:e4d67989cc36
       
     1 /* -*- mode: C; c-file-style: "gnu" -*- */
       
     2 /* dbus-message.h DBusMessage object
       
     3  *
       
     4  * Copyright (C) 2002, 2003, 2005 Red Hat Inc.
       
     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
       
     6  * Licensed under the Academic Free License version 2.1
       
     7  * 
       
     8  * This program is free software; you can redistribute it and/or modify
       
     9  * it under the terms of the GNU General Public License as published by
       
    10  * the Free Software Foundation; either version 2 of the License, or
       
    11  * (at your option) any later version.
       
    12  *
       
    13  * This program is distributed in the hope that it will be useful,
       
    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
       
    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
       
    16  * GNU General Public License for more details.
       
    17  * 
       
    18  * You should have received a copy of the GNU General Public License
       
    19  * along with this program; if not, write to the Free Software
       
    20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
       
    21  *
       
    22  */
       
    23 #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
       
    24 #error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
       
    25 #endif
       
    26 
       
    27 #ifndef DBUS_MESSAGE_H
       
    28 #define DBUS_MESSAGE_H
       
    29 
       
    30 #include <dbus/dbus-macros.h>
       
    31 #include <dbus/dbus-types.h>
       
    32 #include "dbus/dbus-arch-deps.h"
       
    33 #include <dbus/dbus-memory.h>
       
    34 #include <dbus/dbus-errors.h>
       
    35 #include <stdarg.h>
       
    36 
       
    37 DBUS_BEGIN_DECLS
       
    38 
       
    39 /**
       
    40  * @addtogroup DBusMessage
       
    41  * @{
       
    42  */
       
    43 
       
    44 typedef struct DBusMessage DBusMessage;
       
    45 /** Opaque type representing a message iterator. Can be copied by value, and contains no allocated memory so never needs to be freed and can be allocated on the stack. */
       
    46 typedef struct DBusMessageIter DBusMessageIter;
       
    47 
       
    48 /**
       
    49  * DBusMessageIter struct; contains no public fields. 
       
    50  */
       
    51 struct DBusMessageIter
       
    52 { 
       
    53   void *dummy1;         /**< Don't use this */
       
    54   void *dummy2;         /**< Don't use this */
       
    55   dbus_uint32_t dummy3; /**< Don't use this */
       
    56   int dummy4;           /**< Don't use this */
       
    57   int dummy5;           /**< Don't use this */
       
    58   int dummy6;           /**< Don't use this */
       
    59   int dummy7;           /**< Don't use this */
       
    60   int dummy8;           /**< Don't use this */
       
    61   int dummy9;           /**< Don't use this */
       
    62   int dummy10;          /**< Don't use this */
       
    63   int dummy11;          /**< Don't use this */
       
    64   int pad1;             /**< Don't use this */
       
    65   int pad2;             /**< Don't use this */
       
    66   void *pad3;           /**< Don't use this */
       
    67 };
       
    68 
       
    69 #ifdef __SYMBIAN32__
       
    70 IMPORT_C
       
    71 #endif
       
    72 DBusMessage* dbus_message_new               (int          message_type);
       
    73 
       
    74 #ifdef __SYMBIAN32__
       
    75 IMPORT_C
       
    76 #endif
       
    77 DBusMessage* dbus_message_new_method_call   (const char  *bus_name,
       
    78                                              const char  *path,
       
    79                                              const char  *interface,
       
    80                                              const char  *method);
       
    81 
       
    82 #ifdef __SYMBIAN32__
       
    83 IMPORT_C
       
    84 #endif
       
    85 DBusMessage* dbus_message_new_method_return (DBusMessage *method_call);
       
    86 
       
    87 #ifdef __SYMBIAN32__
       
    88 IMPORT_C
       
    89 #endif
       
    90 DBusMessage* dbus_message_new_signal        (const char  *path,
       
    91                                              const char  *interface,
       
    92                                              const char  *name);
       
    93 #ifdef __SYMBIAN32__
       
    94 IMPORT_C
       
    95 #endif
       
    96 DBusMessage* dbus_message_new_error         (DBusMessage *reply_to,
       
    97                                              const char  *error_name,
       
    98                                              const char  *error_message);
       
    99                                              
       
   100 #ifdef __SYMBIAN32__
       
   101 IMPORT_C
       
   102 #endif
       
   103 DBusMessage* dbus_message_new_error_printf  (DBusMessage *reply_to,
       
   104                                              const char  *error_name,
       
   105                                              const char  *error_format,
       
   106 					     ...);
       
   107 
       
   108 #ifdef __SYMBIAN32__
       
   109 IMPORT_C
       
   110 #endif
       
   111 DBusMessage* dbus_message_copy              (const DBusMessage *message);
       
   112 
       
   113 #ifdef __SYMBIAN32__
       
   114 IMPORT_C
       
   115 #endif
       
   116 DBusMessage*  dbus_message_ref              (DBusMessage   *message);
       
   117 
       
   118 #ifdef __SYMBIAN32__
       
   119 IMPORT_C
       
   120 #endif
       
   121 void          dbus_message_unref            (DBusMessage   *message);
       
   122 
       
   123 #ifdef __SYMBIAN32__
       
   124 IMPORT_C
       
   125 #endif
       
   126 int           dbus_message_get_type         (DBusMessage   *message);
       
   127 
       
   128 #ifdef __SYMBIAN32__
       
   129 IMPORT_C
       
   130 #endif
       
   131 dbus_bool_t   dbus_message_set_path         (DBusMessage   *message,
       
   132                                              const char    *object_path);
       
   133 #ifdef __SYMBIAN32__
       
   134 IMPORT_C
       
   135 #endif
       
   136 const char*   dbus_message_get_path         (DBusMessage   *message);
       
   137 
       
   138 #ifdef __SYMBIAN32__
       
   139 IMPORT_C
       
   140 #endif
       
   141 dbus_bool_t   dbus_message_has_path         (DBusMessage   *message, 
       
   142                                              const char    *object_path);  
       
   143 #ifdef __SYMBIAN32__
       
   144 IMPORT_C
       
   145 #endif
       
   146 dbus_bool_t   dbus_message_set_interface    (DBusMessage   *message,
       
   147                                              const char    *interface);       
       
   148 
       
   149 #ifdef __SYMBIAN32__
       
   150 IMPORT_C
       
   151 #endif
       
   152 const char*   dbus_message_get_interface    (DBusMessage   *message);
       
   153 
       
   154 #ifdef __SYMBIAN32__
       
   155 IMPORT_C
       
   156 #endif
       
   157 dbus_bool_t   dbus_message_has_interface    (DBusMessage   *message, 
       
   158                                              const char    *interface);
       
   159 #ifdef __SYMBIAN32__
       
   160 IMPORT_C
       
   161 #endif
       
   162 dbus_bool_t   dbus_message_set_member       (DBusMessage   *message,
       
   163                                              const char    *member);
       
   164 
       
   165 #ifdef __SYMBIAN32__
       
   166 IMPORT_C
       
   167 #endif
       
   168 const char*   dbus_message_get_member       (DBusMessage   *message);
       
   169 
       
   170 #ifdef __SYMBIAN32__
       
   171 IMPORT_C
       
   172 #endif
       
   173 dbus_bool_t   dbus_message_has_member       (DBusMessage   *message, 
       
   174                                              const char    *member);
       
   175 #ifdef __SYMBIAN32__
       
   176 IMPORT_C
       
   177 #endif
       
   178 dbus_bool_t   dbus_message_set_error_name   (DBusMessage   *message,
       
   179                                              const char    *name);
       
   180 #ifdef __SYMBIAN32__
       
   181 IMPORT_C
       
   182 #endif
       
   183 const char*   dbus_message_get_error_name   (DBusMessage   *message);
       
   184 #ifdef __SYMBIAN32__
       
   185 IMPORT_C
       
   186 #endif
       
   187 dbus_bool_t   dbus_message_set_destination  (DBusMessage   *message,
       
   188                                              const char    *destination);
       
   189 #ifdef __SYMBIAN32__
       
   190 IMPORT_C
       
   191 #endif
       
   192 const char*   dbus_message_get_destination  (DBusMessage   *message);
       
   193 
       
   194 #ifdef __SYMBIAN32__
       
   195 IMPORT_C
       
   196 #endif
       
   197 dbus_bool_t   dbus_message_set_sender       (DBusMessage   *message,
       
   198                                              const char    *sender);
       
   199 #ifdef __SYMBIAN32__
       
   200 IMPORT_C
       
   201 #endif
       
   202 const char*   dbus_message_get_sender       (DBusMessage   *message);
       
   203 
       
   204 #ifdef __SYMBIAN32__
       
   205 IMPORT_C
       
   206 #endif
       
   207 const char*   dbus_message_get_signature    (DBusMessage   *message);
       
   208 
       
   209 #ifdef __SYMBIAN32__
       
   210 IMPORT_C
       
   211 #endif
       
   212 void          dbus_message_set_no_reply     (DBusMessage   *message,
       
   213                                              dbus_bool_t    no_reply);
       
   214 #ifdef __SYMBIAN32__
       
   215 IMPORT_C
       
   216 #endif
       
   217 dbus_bool_t   dbus_message_get_no_reply     (DBusMessage   *message);
       
   218 
       
   219 #ifdef __SYMBIAN32__
       
   220 IMPORT_C
       
   221 #endif
       
   222 dbus_bool_t   dbus_message_is_method_call   (DBusMessage   *message,
       
   223                                              const char    *interface,
       
   224                                              const char    *method);
       
   225 #ifdef __SYMBIAN32__
       
   226 IMPORT_C
       
   227 #endif
       
   228 dbus_bool_t   dbus_message_is_signal        (DBusMessage   *message,
       
   229                                              const char    *interface,
       
   230                                              const char    *signal_name);
       
   231                                              
       
   232 #ifdef __SYMBIAN32__
       
   233 IMPORT_C
       
   234 #endif
       
   235 dbus_bool_t   dbus_message_is_error         (DBusMessage   *message,
       
   236                                              const char    *error_name);
       
   237 #ifdef __SYMBIAN32__
       
   238 IMPORT_C
       
   239 #endif
       
   240 dbus_bool_t   dbus_message_has_destination  (DBusMessage   *message,
       
   241                                              const char    *bus_name);
       
   242 #ifdef __SYMBIAN32__
       
   243 IMPORT_C
       
   244 #endif
       
   245 dbus_bool_t   dbus_message_has_sender       (DBusMessage   *message,
       
   246                                              const char    *unique_bus_name);
       
   247 #ifdef __SYMBIAN32__
       
   248 IMPORT_C
       
   249 #endif
       
   250 dbus_bool_t   dbus_message_has_signature    (DBusMessage   *message,
       
   251                                              const char    *signature);
       
   252 #ifdef __SYMBIAN32__
       
   253 IMPORT_C 
       
   254 #endif
       
   255 dbus_uint32_t dbus_message_get_serial       (DBusMessage   *message);
       
   256 #ifdef __SYMBIAN32__
       
   257 IMPORT_C
       
   258 #endif
       
   259 dbus_bool_t   dbus_message_set_reply_serial (DBusMessage   *message,
       
   260                                              dbus_uint32_t  reply_serial);
       
   261 
       
   262 #ifdef __SYMBIAN32__
       
   263 IMPORT_C
       
   264 #endif
       
   265 dbus_uint32_t dbus_message_get_reply_serial (DBusMessage   *message);
       
   266 
       
   267 #ifdef __SYMBIAN32__
       
   268 IMPORT_C
       
   269 #endif
       
   270 void          dbus_message_set_auto_start   (DBusMessage   *message,
       
   271                                              dbus_bool_t    auto_start);
       
   272 #ifdef __SYMBIAN32__
       
   273 IMPORT_C
       
   274 #endif
       
   275 dbus_bool_t   dbus_message_get_auto_start   (DBusMessage   *message);
       
   276 
       
   277 #ifdef __SYMBIAN32__
       
   278 IMPORT_C
       
   279 #endif
       
   280 dbus_bool_t   dbus_message_get_path_decomposed (DBusMessage   *message,
       
   281                                                 char        ***path);
       
   282 
       
   283 #ifdef __SYMBIAN32__
       
   284 IMPORT_C
       
   285 #endif
       
   286 dbus_bool_t dbus_message_append_args          (DBusMessage     *message,
       
   287 					       int              first_arg_type,
       
   288 					       ...);
       
   289 #ifdef __SYMBIAN32__
       
   290 IMPORT_C
       
   291 #endif
       
   292 dbus_bool_t dbus_message_append_args_valist   (DBusMessage     *message,
       
   293 					       int              first_arg_type,
       
   294 					       va_list          var_args);
       
   295 
       
   296 #ifdef __SYMBIAN32__
       
   297 IMPORT_C
       
   298 #endif
       
   299 dbus_bool_t dbus_message_get_args             (DBusMessage     *message,
       
   300 					       DBusError       *error,
       
   301 					       int              first_arg_type,
       
   302 					       ...);
       
   303 #ifdef __SYMBIAN32__
       
   304 IMPORT_C
       
   305 #endif
       
   306 dbus_bool_t dbus_message_get_args_valist      (DBusMessage     *message,
       
   307 					       DBusError       *error,
       
   308 					       int              first_arg_type,
       
   309 					       va_list          var_args);
       
   310 
       
   311 
       
   312 #ifdef __SYMBIAN32__
       
   313 IMPORT_C
       
   314 #endif
       
   315 dbus_bool_t dbus_message_iter_init             (DBusMessage     *message,
       
   316                                                 DBusMessageIter *iter);
       
   317                                                 
       
   318 #ifdef __SYMBIAN32__
       
   319 IMPORT_C
       
   320 #endif
       
   321 dbus_bool_t dbus_message_iter_has_next         (DBusMessageIter *iter);
       
   322 
       
   323 #ifdef __SYMBIAN32__
       
   324 IMPORT_C
       
   325 #endif
       
   326 dbus_bool_t dbus_message_iter_next             (DBusMessageIter *iter);
       
   327 
       
   328 #ifdef __SYMBIAN32__
       
   329 IMPORT_C
       
   330 #endif
       
   331 char*       dbus_message_iter_get_signature    (DBusMessageIter *iter);
       
   332 
       
   333 #ifdef __SYMBIAN32__
       
   334 IMPORT_C
       
   335 #endif
       
   336 int         dbus_message_iter_get_arg_type     (DBusMessageIter *iter);
       
   337 
       
   338 #ifdef __SYMBIAN32__
       
   339 IMPORT_C
       
   340 #endif
       
   341 int         dbus_message_iter_get_element_type (DBusMessageIter *iter);
       
   342 
       
   343 #ifdef __SYMBIAN32__
       
   344 IMPORT_C
       
   345 #endif
       
   346 void        dbus_message_iter_recurse          (DBusMessageIter *iter,
       
   347                                                 DBusMessageIter *sub);
       
   348 #ifdef __SYMBIAN32__
       
   349 IMPORT_C
       
   350 #endif
       
   351 void        dbus_message_iter_get_basic        (DBusMessageIter *iter,
       
   352                                                 void            *value);
       
   353                                                 
       
   354 #ifndef DBUS_DISABLE_DEPRECATED
       
   355 /* This function returns the wire protocol size of the array in bytes,
       
   356  * you do not want to know that probably
       
   357  */
       
   358 
       
   359 #ifdef __SYMBIAN32__
       
   360 IMPORT_C
       
   361 #endif
       
   362 int         dbus_message_iter_get_array_len    (DBusMessageIter *iter) DBUS_GNUC_DEPRECATED;
       
   363 #endif
       
   364 
       
   365 #ifdef __SYMBIAN32__
       
   366 IMPORT_C
       
   367 #endif
       
   368 void        dbus_message_iter_get_fixed_array  (DBusMessageIter *iter,
       
   369                                                 void            *value,
       
   370                                                 int             *n_elements);
       
   371 
       
   372 #ifdef __SYMBIAN32__
       
   373 IMPORT_C
       
   374 #endif
       
   375 void        dbus_message_iter_init_append        (DBusMessage     *message,
       
   376                                                   DBusMessageIter *iter);
       
   377 #ifdef __SYMBIAN32__
       
   378 IMPORT_C
       
   379 #endif
       
   380 dbus_bool_t dbus_message_iter_append_basic       (DBusMessageIter *iter,
       
   381                                                   int              type,
       
   382                                                   const void      *value);
       
   383 #ifdef __SYMBIAN32__
       
   384 IMPORT_C
       
   385 #endif
       
   386 dbus_bool_t dbus_message_iter_append_fixed_array (DBusMessageIter *iter,
       
   387                                                   int              element_type,
       
   388                                                   const void      *value,
       
   389                                                   int              n_elements);
       
   390 #ifdef __SYMBIAN32__
       
   391 IMPORT_C
       
   392 #endif
       
   393 dbus_bool_t dbus_message_iter_open_container     (DBusMessageIter *iter,
       
   394                                                   int              type,
       
   395                                                   const char      *contained_signature,
       
   396                                                   DBusMessageIter *sub);
       
   397 #ifdef __SYMBIAN32__
       
   398 IMPORT_C
       
   399 #endif
       
   400 dbus_bool_t dbus_message_iter_close_container    (DBusMessageIter *iter,
       
   401                                                   DBusMessageIter *sub);
       
   402 
       
   403 
       
   404 #ifdef __SYMBIAN32__
       
   405 IMPORT_C
       
   406 #endif
       
   407 dbus_bool_t  dbus_set_error_from_message  (DBusError    *error,
       
   408                                            DBusMessage  *message);
       
   409 
       
   410 
       
   411 #ifdef __SYMBIAN32__
       
   412 IMPORT_C
       
   413 #endif
       
   414 dbus_bool_t dbus_message_allocate_data_slot (dbus_int32_t     *slot_p);
       
   415 #ifdef __SYMBIAN32__
       
   416 IMPORT_C
       
   417 #endif
       
   418 void        dbus_message_free_data_slot     (dbus_int32_t     *slot_p);
       
   419 #ifdef __SYMBIAN32__
       
   420 IMPORT_C
       
   421 #endif
       
   422 dbus_bool_t dbus_message_set_data           (DBusMessage      *message,
       
   423                                              dbus_int32_t      slot,
       
   424                                              void             *data,
       
   425                                              DBusFreeFunction  free_data_func);
       
   426 #ifdef __SYMBIAN32__
       
   427 IMPORT_C
       
   428 #endif
       
   429 void*       dbus_message_get_data           (DBusMessage      *message,
       
   430                                              dbus_int32_t      slot);
       
   431 
       
   432 #ifdef __SYMBIAN32__
       
   433 IMPORT_C
       
   434 #endif
       
   435 int dbus_message_type_from_string (const char *type_str);
       
   436 #ifdef __SYMBIAN32__
       
   437 IMPORT_C
       
   438 #endif
       
   439 const char * dbus_message_type_to_string (int type);
       
   440 
       
   441 /** @} */
       
   442 
       
   443 DBUS_END_DECLS
       
   444 
       
   445 #endif /* DBUS_MESSAGE_H */