src/CommonAPI/DBus/DBusInputStream.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 "DBusInputStream.h"
   5
   6 namespace CommonAPI {
   7 namespace DBus {
   8
   9 DBusInputStream::DBusInputStream(const CommonAPI::DBus::DBusMessage& message) :
  10                 message_(message),
  11                 dataBegin_(message.getBodyData()),
  12                 currentDataPosition_(0),
  13                 dataLength_(message.getBodyLength()),
  14                 exception_(nullptr) {
  15 }
  16
  17 DBusInputStream::~DBusInputStream() {
  18 }
  19
  20 const CommonAPI::DBus::DBusError& DBusInputStream::getError() const {
  21     return *exception_;
  22 }
  23
  24 bool DBusInputStream::isErrorSet() const {
  25     return exception_ != nullptr;
  26 }
  27
  28 void DBusInputStream::clearError() {
  29     exception_ = nullptr;
  30 }
  31
  32 void DBusInputStream::alignToBoundary(const size_t alignBoundary) {
  33     const unsigned int alignMask = alignBoundary - 1;
  34     currentDataPosition_ = (currentDataPosition_ + alignMask) & (~alignMask);
  35 }
  36
  37 char* DBusInputStream::readRawData(const size_t numBytesToRead) {
  38     assert((currentDataPosition_ + numBytesToRead) <= dataLength_);
  39
  40     char* dataPtr = (char*) (dataBegin_ + currentDataPosition_);
  41     currentDataPosition_ += numBytesToRead;
  42     return dataPtr;
  43 }
  44
  45 template <>
  46 DBusInputStream& DBusInputStream::readBasicTypeValue<float>(float& val) {
  47     if (sizeof(val) > 1)
  48         alignToBoundary(sizeof(double));
  49
  50     val = (float)(*(reinterpret_cast<double*>(readRawData(sizeof(double)))));
  51     return *this;
  52 }
  53
  54 InputStream& DBusInputStream::readValue(bool& boolValue) {
  55     alignToBoundary(4);
  56     return readBasicTypeValue(boolValue);
  57 }
  58
  59 InputStream& DBusInputStream::readValue(int8_t& int8Value)  { return readBasicTypeValue(int8Value); }
  60 InputStream& DBusInputStream::readValue(int16_t& int16Value)  { return readBasicTypeValue(int16Value); }
  61 InputStream& DBusInputStream::readValue(int32_t& int32Value)  { return readBasicTypeValue(int32Value); }
  62 InputStream& DBusInputStream::readValue(int64_t& int64Value)  { return readBasicTypeValue(int64Value); }
  63
  64 InputStream& DBusInputStream::readValue(uint8_t& uint8Value)  { return readBasicTypeValue(uint8Value); }
  65 InputStream& DBusInputStream::readValue(uint16_t& uint16Value) { return readBasicTypeValue(uint16Value); }
  66 InputStream& DBusInputStream::readValue(uint32_t& uint32Value) { return readBasicTypeValue(uint32Value); }
  67 InputStream& DBusInputStream::readValue(uint64_t& uint64Value) { return readBasicTypeValue(uint64Value); }
  68
  69 InputStream& DBusInputStream::readValue(float& floatValue) { return readBasicTypeValue(floatValue); }
  70 InputStream& DBusInputStream::readValue(double& doubleValue) { return readBasicTypeValue(doubleValue); }
  71
  72 InputStream& DBusInputStream::readValue(std::string& stringValue) {
  73     uint32_t lengthOfString;
  74     readValue(lengthOfString);
  75
  76     // length field does not include terminating 0-byte, therefore length of data to read is +1
  77     char* dataPtr = readRawData(lengthOfString + 1);
  78
  79     // The string contained in a DBus-message is required to be 0-terminated, therefore the following line works
  80     stringValue = dataPtr;
  81
  82     return *this;
  83 }
  84
  85 InputStream& DBusInputStream::readValue(ByteBuffer& byteBufferValue) {
  86     *this >> byteBufferValue;
  87     return *this;
  88 }
  89
  90 InputStream& DBusInputStream::readEnumValue(int8_t& int8BackingTypeValue) { return readValue(int8BackingTypeValue); }
  91 InputStream& DBusInputStream::readEnumValue(int16_t& int16BackingTypeValue) { return readValue(int16BackingTypeValue); }
  92 InputStream& DBusInputStream::readEnumValue(int32_t& int32BackingTypeValue) { return readValue(int32BackingTypeValue); }
  93 InputStream& DBusInputStream::readEnumValue(int64_t& int64BackingTypeValue) { return readValue(int64BackingTypeValue); }
  94 InputStream& DBusInputStream::readEnumValue(uint8_t& uint8BackingTypeValue) { return readValue(uint8BackingTypeValue); }
  95 InputStream& DBusInputStream::readEnumValue(uint16_t& uint16BackingTypeValue) { return readValue(uint16BackingTypeValue); }
  96 InputStream& DBusInputStream::readEnumValue(uint32_t& uint32BackingTypeValue) { return readValue(uint32BackingTypeValue); }
  97 InputStream& DBusInputStream::readEnumValue(uint64_t& uint64BackingTypeValue) { return readValue(uint64BackingTypeValue); }
  98
  99 InputStream& DBusInputStream::readVersionValue(Version& versionValue) {
 100     alignToBoundary(8);
 101     readValue(versionValue.Major);
 102     readValue(versionValue.Minor);
 103     return *this;
 104 }
 105
 106 void DBusInputStream::beginReadSerializableStruct(const SerializableStruct& serializableStruct) {
 107     alignToBoundary(8);
 108 }
 109
 110 void DBusInputStream::endReadSerializableStruct(const SerializableStruct& serializableStruct) { }
 111
 112
 113 void DBusInputStream::beginReadBoolVector() {
 114     beginReadGenericVector();
 115     savedStreamPositions_.push(currentDataPosition_);
 116 }
 117
 118 void DBusInputStream::beginReadInt8Vector() {
 119     beginReadGenericVector();
 120     savedStreamPositions_.push(currentDataPosition_);
 121 }
 122
 123 void DBusInputStream::beginReadInt16Vector() {
 124     beginReadGenericVector();
 125     savedStreamPositions_.push(currentDataPosition_);
 126 }
 127
 128 void DBusInputStream::beginReadInt32Vector() {
 129     beginReadGenericVector();
 130     savedStreamPositions_.push(currentDataPosition_);
 131 }
 132
 133 void DBusInputStream::beginReadInt64Vector() {
 134     beginReadGenericVector();
 135     alignToBoundary(8);
 136     savedStreamPositions_.push(currentDataPosition_);
 137 }
 138
 139 void DBusInputStream::beginReadUInt8Vector() {
 140     beginReadGenericVector();
 141     savedStreamPositions_.push(currentDataPosition_);
 142 }
 143
 144 void DBusInputStream::beginReadUInt16Vector() {
 145     beginReadGenericVector();
 146     savedStreamPositions_.push(currentDataPosition_);
 147 }
 148
 149 void DBusInputStream::beginReadUInt32Vector() {
 150     beginReadGenericVector();
 151     savedStreamPositions_.push(currentDataPosition_);
 152 }
 153
 154 void DBusInputStream::beginReadUInt64Vector() {
 155     beginReadGenericVector();
 156     alignToBoundary(8);
 157     savedStreamPositions_.push(currentDataPosition_);
 158 }
 159
 160 void DBusInputStream::beginReadFloatVector() {
 161     beginReadGenericVector();
 162     alignToBoundary(8);
 163     savedStreamPositions_.push(currentDataPosition_);
 164 }
 165
 166 void DBusInputStream::beginReadDoubleVector() {
 167     beginReadGenericVector();
 168     alignToBoundary(8);
 169     savedStreamPositions_.push(currentDataPosition_);
 170 }
 171
 172 void DBusInputStream::beginReadStringVector() {
 173     beginReadGenericVector();
 174     savedStreamPositions_.push(currentDataPosition_);
 175 }
 176
 177 void DBusInputStream::beginReadByteBufferVector() {
 178     beginReadGenericVector();
 179     savedStreamPositions_.push(currentDataPosition_);
 180 }
 181
 182 void DBusInputStream::beginReadVersionVector() {
 183     beginReadGenericVector();
 184     alignToBoundary(8);
 185     savedStreamPositions_.push(currentDataPosition_);
 186 }
 187
 188 void DBusInputStream::beginReadVectorOfSerializableStructs() {
 189     beginReadGenericVector();
 190     alignToBoundary(8);
 191     savedStreamPositions_.push(currentDataPosition_);
 192 }
 193
 194 void DBusInputStream::beginReadVectorOfVectors() {
 195     beginReadGenericVector();
 196     savedStreamPositions_.push(currentDataPosition_);
 197 }
 198
 199 void DBusInputStream::beginReadVectorOfMaps() {
 200     beginReadGenericVector();
 201     alignToBoundary(8);
 202     savedStreamPositions_.push(currentDataPosition_);
 203 }
 204
 205 bool DBusInputStream::hasMoreVectorElements() {
 206     return bytesToRead_.top() > currentDataPosition_ - savedStreamPositions_.top();
 207 }
 208
 209 void DBusInputStream::endReadVector() {
 210     bytesToRead_.pop();
 211     savedStreamPositions_.pop();
 212 }
 213
 214 void DBusInputStream::beginReadMap() {
 215     uint32_t vectorByteSize;
 216     readBasicTypeValue(vectorByteSize);
 217     bytesToRead_.push(vectorByteSize);
 218     alignToBoundary(8);
 219     savedStreamPositions_.push(currentDataPosition_);
 220 }
 221
 222 bool DBusInputStream::hasMoreMapElements() {
 223     return bytesToRead_.top() > currentDataPosition_ - savedStreamPositions_.top();
 224 }
 225
 226 void DBusInputStream::endReadMap() {
 227     bytesToRead_.pop();
 228     savedStreamPositions_.pop();
 229 }
 230
 231
 232 } // namespace DBus
 233 } // namespace CommonAPI