dbus-cplusplus/include/dbus-c++/message.h

/*
 *
 *  D-Bus++ - C++ bindings for D-Bus
 *
 *  Copyright (C) 2005-2007  Paolo Durante <shackan@gmail.com>
 *
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifndef __DBUSXX_MESSAGE_H
#define __DBUSXX_MESSAGE_H

#include <string>
#include <map>

#include "api.h"
#include "util.h"

namespace DBus
{

class Message;
class ErrorMessage;
class SignalMessage;
class ReturnMessage;
class Error;
class Connection;

class DXXAPI MessageIter
{
public:

  MessageIter() {}

  int type();

  bool at_end();

  bool has_next();

  MessageIter &operator ++();

  MessageIter operator ++(int);

  bool append_byte(unsigned char byte);

  unsigned char get_byte();

  bool append_bool(bool b);

  bool get_bool();

  bool append_int16(signed short i);

  signed short get_int16();

  bool append_uint16(unsigned short u);

  unsigned short get_uint16();

  bool append_int32(signed int i);

  signed int get_int32();

  bool append_uint32(unsigned int u);

  unsigned int get_uint32();

  bool append_int64(signed long long i);

  signed long long get_int64();

  bool append_uint64(unsigned long long i);

  unsigned long long get_uint64();

  bool append_double(double d);

  double get_double();

  bool append_string(const char *chars);

  const char *get_string();

  bool append_path(const char *chars);

  const char *get_path();

  bool append_signature(const char *chars);

  const char *get_signature();

  char *signature() const; //returned string must be manually free()'d

  MessageIter recurse();

  bool append_array(char type, const void *ptr, size_t length);

  int array_type();

  int get_array(void *ptr);

  bool is_array();

  bool is_dict();

  MessageIter new_array(const char *sig);

  MessageIter new_variant(const char *sig);

  MessageIter new_struct();

  MessageIter new_dict_entry();

  void close_container(MessageIter &container);

  void copy_data(MessageIter &to);

  Message &msg() const
  {
    return *_msg;
  }

private:

  DXXAPILOCAL MessageIter(Message &msg) : _msg(&msg) {}

  DXXAPILOCAL bool append_basic(int type_id, void *value);

  DXXAPILOCAL void get_basic(int type_id, void *ptr);

private:

  /* I'm sorry, but don't want to include dbus.h in the public api
   */
  unsigned char _iter[sizeof(void *) * 3 + sizeof(int) * 11];

  Message *_msg;

  friend class Message;
};

class DXXAPI Message
{
public:

  struct Private;

  Message(Private *, bool incref = true);

  Message(const Message &m);

  ~Message();

  Message &operator = (const Message &m);

  Message copy();

  int type() const;

  int serial() const;

  int reply_serial() const;

  bool reply_serial(int);

  const char *sender() const;

  bool sender(const char *s);

  const char *destination() const;

  bool destination(const char *s);

  bool is_error() const;

  bool is_signal(const char *interface, const char *member) const;

  MessageIter reader() const;

  MessageIter writer();

  bool append(int first_type, ...);

  void terminate();

protected:

  Message();

protected:

  RefPtrI<Private> _pvt;

  /*	classes who need to read `_pvt` directly
  */
  friend class ErrorMessage;
  friend class ReturnMessage;
  friend class MessageIter;
  friend class Error;
  friend class Connection;
};

/*
*/

class DXXAPI ErrorMessage : public Message
{
public:

  ErrorMessage();

  ErrorMessage(const Message &, const char *name, const char *message);

  const char *name() const;

  bool name(const char *n);

  bool operator == (const ErrorMessage &) const;
};

/*
*/

class DXXAPI SignalMessage : public Message
{
public:

  SignalMessage(const char *name);

  SignalMessage(const char *path, const char *interface, const char *name);

  const char *interface() const;

  bool interface(const char *i);

  const char *member() const;

  bool member(const char *m);

  const char *path() const;

  char **path_split() const;

  bool path(const char *p);

  bool operator == (const SignalMessage &) const;
};

/*
*/

class DXXAPI CallMessage : public Message
{
public:

  CallMessage();

  CallMessage(const char *dest, const char *path, const char *iface, const char *method);

  const char *interface() const;

  bool interface(const char *i);

  const char *member() const;

  bool member(const char *m);

  const char *path() const;

  char **path_split() const;

  bool path(const char *p);

  const char *signature() const;

  bool operator == (const CallMessage &) const;
};

/*
*/

class DXXAPI ReturnMessage : public Message
{
public:

  ReturnMessage(const CallMessage &callee);

  const char *signature() const;
};

} /* namespace DBus */

#endif//__DBUSXX_MESSAGE_H