src/common/dbus_message_in.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        dbus_message_in.cpp
  18  * @author      Marcin Niesluchowski (m.niesluchow@samsung.com)
  19  * @version     1.0
  20  * @brief       DBus incoming message wrapper class source file
  21  */
  22
  23 #include <dbus_message_in.h>
  24
  25 #include <dpl/test/test_runner.h>
  26
  27 namespace DBus
  28 {
  29
  30 MessageIn::MessageIn(DBusMessage *message, bool ref)
  31     : m_message(message)
  32 {
  33     RUNNER_ASSERT(m_message != nullptr);
  34     if (ref)
  35         dbus_message_ref(m_message);
  36 }
  37
  38 MessageIn::MessageIn(MessageIn &&other)
  39     : m_message(other.m_message)
  40 {
  41     other.m_message = nullptr;
  42 }
  43
  44 MessageIn::~MessageIn()
  45 {
  46     if (m_message != nullptr)
  47         dbus_message_unref(m_message);
  48 }
  49
  50 int MessageIn::getType()
  51 {
  52     return dbus_message_get_type(m_message);
  53 }
  54
  55 bool MessageIn::isMethodCall(const std::string &interface, const std::string &method)
  56 {
  57     dbus_bool_t ret = dbus_message_is_method_call(m_message,
  58                                                   interface.c_str(),
  59                                                   method.c_str());
  60     return ret == TRUE;
  61 }
  62
  63 bool MessageIn::isSignal(const std::string &interface, const std::string &signalName)
  64 {
  65     dbus_bool_t ret = dbus_message_is_signal(m_message,
  66                                              interface.c_str(),
  67                                              signalName.c_str());
  68     return ret == TRUE;
  69 }
  70
  71 bool MessageIn::isError(const std::string &errorName)
  72 {
  73     dbus_bool_t ret = dbus_message_is_error(m_message,
  74                                             errorName.c_str());
  75     return ret == TRUE;
  76 }
  77
  78 MessageIn::Iterator MessageIn::iterInit()
  79 {
  80     return Iterator(this->m_message);
  81 }
  82
  83 MessageIn::Iterator::Iterator(DBusMessage* message)
  84 {
  85     dbus_message_iter_init(message, &m_iterator);
  86 }
  87
  88 MessageIn::Iterator::Iterator(DBusMessageIter *iteratorOver)
  89 {
  90     dbus_message_iter_recurse(iteratorOver, &m_iterator);
  91 }
  92
  93 bool MessageIn::Iterator::next()
  94 {
  95     return dbus_message_iter_next(&m_iterator) != FALSE;
  96 }
  97
  98 void MessageIn::Iterator::expectNext()
  99 {
 100     RUNNER_ASSERT_MSG(next(), "No next argument in message");
 101 }
 102
 103 int MessageIn::Iterator::getArgType()
 104 {
 105     return dbus_message_iter_get_arg_type(&m_iterator);
 106 }
 107
 108 void MessageIn::Iterator::expectArgType(int argType)
 109 {
 110     int argTypeActual = getArgType();
 111     RUNNER_ASSERT_MSG(argTypeActual == argType, "Wrong argument type in message"
 112                                                     << " Actual: " << argTypeActual
 113                                                     << " Expected: " << argType);
 114 }
 115
 116 void MessageIn::Iterator::expectArgTypeValid()
 117 {
 118     RUNNER_ASSERT_MSG(getArgType() != DBUS_TYPE_INVALID, "Invalid argument type in message");
 119 }
 120
 121 char MessageIn::Iterator::getArgChar()
 122 {
 123     return getArg<char>();
 124 }
 125
 126 bool MessageIn::Iterator::getArgBool()
 127 {
 128     dbus_bool_t value;
 129     dbus_message_iter_get_basic(&m_iterator, &value);
 130     return value != FALSE;
 131 }
 132
 133 int16_t MessageIn::Iterator::getArgInt16()
 134 {
 135     return getArg<int16_t>();
 136 }
 137
 138 uint16_t MessageIn::Iterator::getArgUint16()
 139 {
 140     return getArg<uint16_t>();
 141 }
 142
 143 int32_t MessageIn::Iterator::getArgInt32()
 144 {
 145     return getArg<int32_t>();
 146 }
 147
 148 uint32_t MessageIn::Iterator::getArgUint32()
 149 {
 150     return getArg<uint32_t>();
 151 }
 152
 153 int64_t MessageIn::Iterator::getArgInt64()
 154 {
 155     return getArg<int64_t>();
 156 }
 157
 158 uint64_t MessageIn::Iterator::getArgUint64()
 159 {
 160     return getArg<uint64_t>();
 161 }
 162
 163 double MessageIn::Iterator::getArgDouble()
 164 {
 165     return getArg<double>();
 166 }
 167
 168 std::string MessageIn::Iterator::getArgString()
 169 {
 170     char *value;
 171     dbus_message_iter_get_basic(&m_iterator, &value);
 172     return std::string(value);
 173 }
 174
 175 MessageIn::Iterator MessageIn::Iterator::recurse()
 176 {
 177     return Iterator(&(this->m_iterator));
 178 }
 179
 180 } // namespace DBus