src/CommonAPI/DBus/DBusMessage.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 #include "DBusMessage.h"
   5
   6 #include <cassert>
   7 #include <cstring>
   8
   9 namespace CommonAPI {
  10 namespace DBus {
  11
  12 DBusMessage::DBusMessage():
  13                 libdbusMessage_(NULL) {
  14 }
  15
  16 DBusMessage::DBusMessage(::DBusMessage* libdbusMessage) {
  17         libdbusMessage_ = libdbusMessage != NULL ? dbus_message_ref(libdbusMessage) : NULL;
  18 }
  19
  20 DBusMessage::DBusMessage(::DBusMessage* libdbusMessage, bool increaseReferenceCount) {
  21         assert(libdbusMessage);
  22
  23         libdbusMessage_ = increaseReferenceCount ? dbus_message_ref(libdbusMessage) : libdbusMessage;
  24 }
  25
  26 DBusMessage::DBusMessage(const DBusMessage& src) {
  27         libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
  28 }
  29
  30 DBusMessage::DBusMessage(DBusMessage&& rsrc) {
  31         libdbusMessage_ = rsrc.libdbusMessage_;
  32         rsrc.libdbusMessage_ = NULL;
  33 }
  34
  35 DBusMessage::~DBusMessage() {
  36         if (libdbusMessage_)
  37                 dbus_message_unref(libdbusMessage_);
  38 }
  39
  40 DBusMessage& DBusMessage::operator=(const DBusMessage& src) {
  41         if (this != &src) {
  42                 if (libdbusMessage_)
  43                         dbus_message_unref(libdbusMessage_);
  44
  45                 libdbusMessage_ = src.libdbusMessage_ != NULL ? dbus_message_ref(src.libdbusMessage_) : NULL;
  46         }
  47
  48         return *this;
  49 }
  50
  51 DBusMessage& DBusMessage::operator=(DBusMessage&& rsrc) {
  52         if (this != &rsrc) {
  53                 if (libdbusMessage_)
  54                         dbus_message_unref(libdbusMessage_);
  55
  56                 libdbusMessage_ = rsrc.libdbusMessage_;
  57                 rsrc.libdbusMessage_ = NULL;
  58         }
  59
  60         return *this;
  61 }
  62
  63 DBusMessage::operator bool() const {
  64         const bool isNotNullDBusMessage = (libdbusMessage_ != NULL);
  65         return isNotNullDBusMessage;
  66 }
  67
  68 DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const char* methodName, const char* signature) {
  69         return DBusMessage::createMethodCall("org.freedesktop.DBus",
  70                                                                                  "/",
  71                                                                                  "org.freedesktop.DBus",
  72                                                                                  methodName,
  73                                                                                  signature);
  74 }
  75
  76 DBusMessage DBusMessage::createOrgFreedesktopOrgMethodCall(const std::string& methodName,
  77                                                                                                                    const std::string& signature) {
  78         assert(!methodName.empty());
  79
  80         return createOrgFreedesktopOrgMethodCall(methodName.c_str(),
  81                                                                                          signature.empty() ? NULL : signature.c_str());
  82 }
  83
  84 DBusMessage DBusMessage::createMethodCall(const char* busName,
  85                                           const char* objectPath,
  86                                           const char* interfaceName,
  87                                           const char* methodName,
  88                                           const char* signature) {
  89         assert(busName);
  90         assert(objectPath);
  91         assert(interfaceName);
  92         assert(methodName);
  93
  94         ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call(busName,
  95                                                                                                                                          objectPath,
  96                                                                                                                                          interfaceName,
  97                                                                                                                                          methodName);
  98         assert(libdbusMessageCall);
  99
 100         if (signature)
 101                 dbus_message_set_signature(libdbusMessageCall, signature);
 102
 103         const bool increaseLibdbusMessageReferenceCount = false;
 104         return DBusMessage(libdbusMessageCall, increaseLibdbusMessageReferenceCount);
 105 }
 106
 107 DBusMessage DBusMessage::createMethodCall(const std::string& busName,
 108                                                                                   const std::string& objectPath,
 109                                                                                   const std::string& interfaceName,
 110                                                                                   const std::string& methodName,
 111                                                                                   const std::string& signature) {
 112         assert(!busName.empty());
 113         assert(!objectPath.empty());
 114         assert(!interfaceName.empty());
 115         assert(!methodName.empty());
 116
 117         return createMethodCall(busName.c_str(),
 118                                                         objectPath.c_str(),
 119                                                         interfaceName.c_str(),
 120                                                         methodName.c_str(),
 121                                                         signature.empty() ? NULL : signature.c_str());
 122 }
 123
 124 DBusMessage DBusMessage::createMethodReturn(const char* signature) const {
 125         ::DBusMessage* libdbusMessageReturn = dbus_message_new_method_return(libdbusMessage_);
 126         assert(libdbusMessageReturn);
 127
 128         if (signature)
 129                 dbus_message_set_signature(libdbusMessageReturn, signature);
 130
 131         const bool increaseLibdbusMessageReferenceCount = false;
 132         return DBusMessage(libdbusMessageReturn, increaseLibdbusMessageReferenceCount);
 133 }
 134
 135 DBusMessage DBusMessage::createMethodReturn(const std::string& signature) const {
 136         return createMethodReturn(signature.empty() ? NULL : signature.c_str());
 137 }
 138
 139 DBusMessage DBusMessage::createSignal(const char* objectPath,
 140                                       const char* interfaceName,
 141                                       const char* signalName,
 142                                       const char* signature) {
 143         assert(objectPath);
 144         assert(interfaceName);
 145         assert(signalName);
 146
 147         ::DBusMessage* libdbusMessageSignal = dbus_message_new_signal(objectPath,
 148                                                                                                                                   interfaceName,
 149                                                                                                                                   signalName);
 150         assert(libdbusMessageSignal);
 151
 152         if (signature)
 153                 dbus_message_set_signature(libdbusMessageSignal, signature);
 154
 155         const bool increaseLibdbusMessageReferenceCount = false;
 156         return DBusMessage(libdbusMessageSignal, increaseLibdbusMessageReferenceCount);
 157 }
 158
 159 DBusMessage DBusMessage::createSignal(const std::string& objectPath,
 160                                                                           const std::string& interfaceName,
 161                                                                           const std::string& signalName,
 162                                                                           const std::string& signature) {
 163         assert(!objectPath.empty());
 164         assert(!interfaceName.empty());
 165         assert(!signalName.empty());
 166
 167         return createSignal(objectPath.c_str(),
 168                                                 interfaceName.c_str(),
 169                                                 signalName.c_str(),
 170                                                 signature.empty() ? NULL : signature.c_str());
 171 }
 172
 173 const char* DBusMessage::getObjectPath() const {
 174         return dbus_message_get_path(libdbusMessage_);
 175 }
 176
 177 const char* DBusMessage::getSenderName() const {
 178         return dbus_message_get_sender(libdbusMessage_);
 179 }
 180
 181 const char* DBusMessage::getInterfaceName() const {
 182         return dbus_message_get_interface(libdbusMessage_);
 183 }
 184
 185 const char* DBusMessage::getMemberName() const {
 186         return dbus_message_get_member(libdbusMessage_);
 187 }
 188
 189 const char* DBusMessage::getSignatureString() const {
 190         return dbus_message_get_signature(libdbusMessage_);
 191 }
 192
 193 const char* DBusMessage::getErrorName() const {
 194         assert(isErrorType());
 195
 196         return dbus_message_get_error_name(libdbusMessage_);
 197 }
 198
 199 bool DBusMessage::hasMemberName(const char* memberName) const {
 200     const char* dbusMessageMemberName = getMemberName();
 201
 202     assert(memberName);
 203     assert(dbusMessageMemberName);
 204
 205     return !strcmp(dbusMessageMemberName, memberName);
 206 }
 207
 208 bool DBusMessage::hasSignature(const char* signature) const {
 209         const char* dbusMessageSignature = getSignatureString();
 210
 211         assert(signature);
 212         assert(dbusMessageSignature);
 213
 214         return !strcmp(dbusMessageSignature, signature);
 215 }
 216
 217 const DBusMessage::Type DBusMessage::getType() const {
 218         const int libdbusType = dbus_message_get_type(libdbusMessage_);
 219         return static_cast<Type>(libdbusType);
 220 }
 221
 222 char* DBusMessage::getBodyData() const {
 223         return dbus_message_get_body(libdbusMessage_);
 224 }
 225
 226 int DBusMessage::getBodyLength() const {
 227         return dbus_message_get_body_length(libdbusMessage_);
 228 }
 229
 230 int DBusMessage::getBodySize() const {
 231         return dbus_message_get_body_allocated(libdbusMessage_);
 232 }
 233
 234 bool DBusMessage::setBodyLength(const int bodyLength) {
 235         return dbus_message_set_body_length(libdbusMessage_, bodyLength);
 236 }
 237
 238 } // namespace DBus
 239 } // namespace CommonAPI