include/dbus-c++/message.h

   1 /*
   2  *
   3  *  D-Bus++ - C++ bindings for D-Bus
   4  *
   5  *  Copyright (C) 2005-2009  Paolo Durante <shackan@gmail.com>
   6  *
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2.1 of the License, or (at your option) any later version.
  12  *
  13  *  This library 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 GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Lesser General Public
  19  *  License along with this library; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24
  25 #ifndef __DBUSXX_MESSAGE_H
  26 #define __DBUSXX_MESSAGE_H
  27
  28 #include <string>
  29 #include <map>
  30
  31 #include "api.h"
  32 #include "util.h"
  33
  34 namespace DBus {
  35
  36 class Message;
  37 class ErrorMessage;
  38 class SignalMessage;
  39 class ReturnMessage;
  40 class Error;
  41 class Connection;
  42
  43 class DBUSXXAPI MessageIter
  44 {
  45 public:
  46
  47         MessageIter() {}
  48
  49         int type();
  50
  51         bool at_end();
  52
  53         bool has_next();
  54
  55         MessageIter &operator ++();
  56
  57         MessageIter operator ++(int);
  58
  59         bool append_byte(unsigned char byte);
  60
  61         unsigned char get_byte();
  62
  63         bool append_bool(bool b);
  64
  65         bool get_bool();
  66
  67         bool append_int16(signed short i);
  68
  69         signed short get_int16();
  70
  71         bool append_uint16(unsigned short u);
  72
  73         unsigned short get_uint16();
  74
  75         bool append_int32(signed int i);
  76
  77         signed int get_int32();
  78
  79         bool append_uint32(unsigned int u);
  80
  81         unsigned int get_uint32();
  82
  83         bool append_int64(signed long long i);
  84
  85         signed long long get_int64();
  86
  87         bool append_uint64(unsigned long long i);
  88
  89         unsigned long long get_uint64();
  90
  91         bool append_double(double d);
  92
  93         double get_double();
  94
  95         bool append_string(const char *chars);
  96
  97         const char *get_string();
  98
  99         bool append_path(const char *chars);
 100
 101         const char *get_path();
 102
 103         bool append_signature(const char *chars);
 104
 105         const char *get_signature();
 106
 107         char *signature() const; //returned string must be manually free()'d
 108
 109         MessageIter recurse();
 110
 111         bool append_array(char type, const void *ptr, size_t length);
 112
 113         int array_type();
 114
 115         int get_array(void *ptr);
 116
 117         bool is_array();
 118
 119         bool is_dict();
 120
 121         MessageIter new_array(const char *sig);
 122
 123         MessageIter new_variant(const char *sig);
 124
 125         MessageIter new_struct();
 126
 127         MessageIter new_dict_entry();
 128
 129         void close_container(MessageIter &container);
 130
 131         void copy_data(MessageIter &to);
 132
 133         Message &msg() const
 134         {
 135                 return *_msg;
 136         }
 137
 138 private:
 139
 140         DBUSXXAPILOCAL MessageIter(Message &msg) : _msg(&msg) {}
 141
 142         DBUSXXAPILOCAL bool append_basic(int type_id, void *value);
 143
 144         DBUSXXAPILOCAL void get_basic(int type_id, void *ptr);
 145
 146 private:
 147
 148         /* I'm sorry, but don't want to include dbus.h in the public api
 149          */
 150         unsigned char _iter[sizeof(void *)*3+sizeof(int)*11];
 151
 152         Message *_msg;
 153
 154 friend class Message;
 155 };
 156
 157 class DBUSXXAPI Message
 158 {
 159 public:
 160
 161         struct Private;
 162
 163         Message();
 164
 165         Message(Private *, bool incref = true);
 166
 167         Message(const Message &m);
 168
 169         virtual ~Message();
 170
 171         Message &operator = (const Message &m);
 172
 173         Message copy();
 174
 175         int serial() const;
 176
 177         int reply_serial() const;
 178
 179         bool reply_serial(int);
 180
 181         const char *sender() const;
 182
 183         bool sender(const char *s);
 184
 185         const char *destination() const;
 186
 187         bool destination(const char *s);
 188
 189         bool is_error() const;
 190
 191         bool is_error(const char *error) const;
 192
 193         bool is_signal() const;
 194
 195         bool is_signal(const char *interface, const char *signal) const;
 196
 197         bool is_call() const;
 198
 199         bool is_call(const char *interface, const char *method) const;
 200
 201         bool is_return() const;
 202
 203         MessageIter reader() const;
 204
 205         MessageIter writer();
 206
 207         bool append(int first_type, ...);
 208
 209         void terminate();
 210
 211 protected:
 212
 213         RefPtrI<Private> _pvt;
 214
 215 /*      classes who need to read `_pvt` directly
 216 */
 217 friend class ErrorMessage;
 218 friend class ReturnMessage;
 219 friend class MessageIter;
 220 friend class Error;
 221 friend class Connection;
 222 };
 223
 224 /*
 225 */
 226
 227 class DBUSXXAPI ErrorMessage : public Message
 228 {
 229 public:
 230
 231         ErrorMessage();
 232
 233         ErrorMessage(const Message &, const char *name, const char *message);
 234
 235         const char *name() const;
 236
 237         bool name(const char *n);
 238
 239         bool operator == (const ErrorMessage &) const;
 240 };
 241
 242 /*
 243 */
 244
 245 class DBUSXXAPI SignalMessage : public Message
 246 {
 247 public:
 248
 249         SignalMessage(const char *name);
 250
 251         SignalMessage(const char *path, const char *interface, const char *name);
 252
 253         const char *interface() const;
 254
 255         bool interface(const char *i);
 256
 257         const char *member() const;
 258
 259         bool member(const char *m);
 260
 261         const char *path() const;
 262
 263         char **path_split() const;
 264
 265         bool path(const char *p);
 266
 267         bool operator == (const SignalMessage &) const;
 268 };
 269
 270 /*
 271 */
 272
 273 class DBUSXXAPI CallMessage : public Message
 274 {
 275 public:
 276
 277         CallMessage();
 278
 279         CallMessage(const char *dest, const char *path, const char *iface, const char *method);
 280
 281         const char *interface() const;
 282
 283         bool interface(const char *i);
 284
 285         const char *member() const;
 286
 287         bool member(const char *m);
 288
 289         const char *path() const;
 290
 291         char **path_split() const;
 292
 293         bool path(const char *p);
 294
 295         const char *signature() const;
 296
 297         bool operator == (const CallMessage &) const;
 298 };
 299
 300 /*
 301 */
 302
 303 class DBUSXXAPI ReturnMessage : public Message
 304 {
 305 public:
 306
 307         ReturnMessage(const CallMessage &callee);
 308
 309         const char *signature() const;
 310 };
 311
 312 } /* namespace DBus */
 313
 314 #endif//__DBUSXX_MESSAGE_H