CommonAPI-DBus/src/test/commonapi/tests/DerivedTypeCollection.h

   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 #ifndef COMMONAPI_TESTS_DERIVED_TYPE_COLLECTION_H_
   5 #define COMMONAPI_TESTS_DERIVED_TYPE_COLLECTION_H_
   6
   7 #include <CommonAPI/InputStream.h>
   8 #include <CommonAPI/OutputStream.h>
   9 #include <CommonAPI/SerializableStruct.h>
  10 #include <CommonAPI/types.h>
  11 #include "PredefinedTypeCollection.h"
  12 #include <cstdint>
  13 #include <unordered_map>
  14 #include <vector>
  15
  16 namespace commonapi {
  17 namespace tests {
  18
  19 namespace DerivedTypeCollection {
  20
  21 enum class TestEnum: int32_t {
  22     E_UNKNOWN = 0,
  23     E_OK = 1,
  24     E_OUT_OF_RANGE = 2,
  25     E_NOT_USED = 3
  26 };
  27
  28 // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
  29 struct TestEnumComparator;
  30
  31 enum class TestEnumMissingValue: int32_t {
  32     E1 = 10,
  33     E2,
  34     E3 = 2
  35 };
  36
  37 // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
  38 struct TestEnumMissingValueComparator;
  39
  40 enum class TestEnumExtended: int32_t {
  41     E_UNKNOWN = TestEnum::E_UNKNOWN,
  42     E_OK = TestEnum::E_OK,
  43     E_OUT_OF_RANGE = TestEnum::E_OUT_OF_RANGE,
  44     E_NOT_USED = TestEnum::E_NOT_USED
  45     ,
  46     E_NEW = 4
  47 };
  48
  49 // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
  50 struct TestEnumExtendedComparator;
  51
  52 enum class TestEnumExtended2: int32_t {
  53     E_UNKNOWN = TestEnum::E_UNKNOWN,
  54     E_OK = TestEnum::E_OK,
  55     E_OUT_OF_RANGE = TestEnum::E_OUT_OF_RANGE,
  56     E_NOT_USED = TestEnum::E_NOT_USED,
  57
  58     E_NEW = TestEnumExtended::E_NEW
  59     ,
  60     E_NEW2 = 5
  61 };
  62
  63 // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1
  64 struct TestEnumExtended2Comparator;
  65
  66 struct TestStruct: CommonAPI::SerializableStruct {
  67     PredefinedTypeCollection::TestString testString;
  68     uint16_t uintValue;
  69
  70     TestStruct() = default;
  71     TestStruct(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue);
  72
  73     virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
  74     virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
  75 };
  76
  77 struct TestStructExtended: TestStruct {
  78     TestEnumExtended2 testEnumExtended2;
  79
  80     TestStructExtended() = default;
  81     TestStructExtended(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue, const TestEnumExtended2& testEnumExtended2);
  82
  83     virtual void readFromInputStream(CommonAPI::InputStream& inputStream);
  84     virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const;
  85 };
  86
  87 typedef std::vector<uint64_t> TestArrayUInt64;
  88
  89 typedef std::vector<TestStruct> TestArrayTestStruct;
  90
  91 typedef std::unordered_map<uint32_t, TestArrayTestStruct> TestMap;
  92
  93 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, TestEnum& enumValue) {
  94     return inputStream.readEnumValue<int32_t>(enumValue);
  95 }
  96
  97 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const TestEnum& enumValue) {
  98     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
  99 }
 100
 101 struct TestEnumComparator {
 102     inline bool operator()(const TestEnum& lhs, const TestEnum& rhs) const {
 103         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
 104     }
 105 };
 106
 107 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, TestEnumMissingValue& enumValue) {
 108     return inputStream.readEnumValue<int32_t>(enumValue);
 109 }
 110
 111 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const TestEnumMissingValue& enumValue) {
 112     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
 113 }
 114
 115 struct TestEnumMissingValueComparator {
 116     inline bool operator()(const TestEnumMissingValue& lhs, const TestEnumMissingValue& rhs) const {
 117         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
 118     }
 119 };
 120
 121 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, TestEnumExtended& enumValue) {
 122     return inputStream.readEnumValue<int32_t>(enumValue);
 123 }
 124
 125 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const TestEnumExtended& enumValue) {
 126     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
 127 }
 128
 129 struct TestEnumExtendedComparator {
 130     inline bool operator()(const TestEnumExtended& lhs, const TestEnumExtended& rhs) const {
 131         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
 132     }
 133 };
 134
 135
 136 inline bool operator==(const TestEnumExtended& lhs, const TestEnum& rhs) {
 137     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 138 }
 139 inline bool operator==(const TestEnum& lhs, const TestEnumExtended& rhs) {
 140     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 141 }
 142 inline bool operator!=(const TestEnumExtended& lhs, const TestEnum& rhs) {
 143     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 144 }
 145 inline bool operator!=(const TestEnum& lhs, const TestEnumExtended& rhs) {
 146     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 147 }
 148 inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, TestEnumExtended2& enumValue) {
 149     return inputStream.readEnumValue<int32_t>(enumValue);
 150 }
 151
 152 inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const TestEnumExtended2& enumValue) {
 153     return outputStream.writeEnumValue(static_cast<int32_t>(enumValue));
 154 }
 155
 156 struct TestEnumExtended2Comparator {
 157     inline bool operator()(const TestEnumExtended2& lhs, const TestEnumExtended2& rhs) const {
 158         return static_cast<int32_t>(lhs) < static_cast<int32_t>(rhs);
 159     }
 160 };
 161
 162
 163 inline bool operator==(const TestEnumExtended2& lhs, const TestEnum& rhs) {
 164     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 165 }
 166 inline bool operator==(const TestEnum& lhs, const TestEnumExtended2& rhs) {
 167     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 168 }
 169 inline bool operator!=(const TestEnumExtended2& lhs, const TestEnum& rhs) {
 170     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 171 }
 172 inline bool operator!=(const TestEnum& lhs, const TestEnumExtended2& rhs) {
 173     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 174 }
 175
 176 inline bool operator==(const TestEnumExtended2& lhs, const TestEnumExtended& rhs) {
 177     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 178 }
 179 inline bool operator==(const TestEnumExtended& lhs, const TestEnumExtended2& rhs) {
 180     return static_cast<int32_t>(lhs) == static_cast<int32_t>(rhs);
 181 }
 182 inline bool operator!=(const TestEnumExtended2& lhs, const TestEnumExtended& rhs) {
 183     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 184 }
 185 inline bool operator!=(const TestEnumExtended& lhs, const TestEnumExtended2& rhs) {
 186     return static_cast<int32_t>(lhs) != static_cast<int32_t>(rhs);
 187 }
 188 bool operator==(const TestStruct& lhs, const TestStruct& rhs);
 189 inline bool operator!=(const TestStruct& lhs, const TestStruct& rhs) {
 190     return !(lhs == rhs);
 191 }
 192 bool operator==(const TestStructExtended& lhs, const TestStructExtended& rhs);
 193 inline bool operator!=(const TestStructExtended& lhs, const TestStructExtended& rhs) {
 194     return !(lhs == rhs);
 195 }
 196
 197
 198 static inline const char* getTypeCollectionName() {
 199     return "commonapi.tests.DerivedTypeCollection";
 200 }
 201
 202
 203 } // namespace DerivedTypeCollection
 204
 205 } // namespace tests
 206 } // namespace commonapi
 207
 208 #endif // COMMONAPI_TESTS_DERIVED_TYPE_COLLECTION_H_