iotjava/iotrmi/C++/basics/TestClass.hpp

   1 #ifndef _TESTCLASS_HPP__
   2 #define _TESTCLASS_HPP__
   3
   4 #include <iostream>
   5 #include <thread>
   6 #include <chrono>
   7 #include "TestClassInterface.hpp"
   8 #include "CallBackInterfaceWithCallBack.hpp"
   9
  10 using namespace std;
  11
  12 class TestClass : public TestClassInterface {
  13         public:
  14                 TestClass();
  15                 TestClass(int _int, float _float, string _string);
  16
  17                 char                            getByte(char in);
  18                 short                           getShort(short in);
  19                 int64_t                         getLong(int64_t in);
  20                 float                           getFloat(float in);
  21                 double                          getDouble(double in);
  22                 bool                            getBoolean(bool in);
  23                 char                            getChar(char in);
  24
  25                 vector<char>            getByteArray(vector<char> in);
  26                 vector<short>           getShortArray(vector<short> in);
  27                 vector<int64_t>         getLongArray(vector<int64_t> in);
  28                 vector<float>           getFloatArray(vector<float> in);
  29                 vector<double>          getDoubleArray(vector<double> in);
  30                 vector<bool>            getBooleanArray(vector<bool> in);
  31                 vector<char>            getCharArray(vector<char> in);
  32
  33                 vector<char>            getByteList(vector<char> in);
  34                 vector<short>           getShortList(vector<short> in);
  35                 vector<int64_t>         getLongList(vector<int64_t> in);
  36                 vector<float>           getFloatList(vector<float> in);
  37                 vector<double>          getDoubleList(vector<double> in);
  38                 vector<bool>            getBooleanList(vector<bool> in);
  39                 vector<char>            getCharList(vector<char> in);
  40
  41                 // Callbacks
  42                 void                            registerCallback(CallBackInterfaceWithCallBack* _cb);
  43                 //void                          registerCallback(vector<CallBackInterfaceWithCallBack*> _cb);
  44                 int                                     callBack();
  45
  46                 // Enum
  47                 Enum                            handleEnum(Enum en);
  48                 vector<Enum>            handleEnumArray(vector<Enum> vecEn);
  49                 vector<Enum>            handleEnumList(vector<Enum> vecEn);
  50
  51                 int                                     getA();
  52                 void                            setA(int _int);
  53                 void                            setB(float _float);
  54                 void                            setC(string _string);
  55                 string                          sumArray(vector<string> newA);
  56                 int                                     setAndGetA(int newA);
  57                 int                                     setACAndGetA(string newC, int newA);
  58
  59         private:
  60                 int                                                                             intA;
  61                 float                                                                   floatB;
  62                 string                                                                  stringC;
  63                 vector<CallBackInterfaceWithCallBack*>  cbvec;
  64 };
  65
  66
  67 TestClass::TestClass() {
  68
  69         intA = 1;
  70         floatB = 2;
  71         stringC = "345";
  72         // cbvec doesn't need to be initialized again
  73 }
  74
  75
  76 TestClass::TestClass(int _int, float _float, string _string) {
  77
  78         intA = _int;
  79         floatB = _float;
  80         stringC = _string;
  81         // cbvec doesn't need to be initialized again
  82 }
  83
  84
  85 void TestClass::registerCallback(CallBackInterfaceWithCallBack* _cb) {
  86
  87         cbvec.push_back(_cb);
  88         cout << "Registering callback object!" << endl;
  89 }
  90
  91
  92 /*void TestClass::registerCallback(vector<CallBackInterfaceWithCallBack*> _cb) {
  93
  94         for (CallBackInterface* cb : _cb) {
  95                 cbvec.push_back(cb);
  96                 cout << "Registering callback object!" << endl;
  97         }
  98 }*/
  99
 100
 101 int TestClass::callBack() {
 102
 103         int sum = 0;
 104         for (CallBackInterfaceWithCallBack* cb : cbvec) {
 105                 sum = sum + cb->printInt();
 106         }
 107
 108         return sum;
 109 }
 110
 111
 112 // Single variables
 113 char TestClass::getByte(char in) {
 114
 115         return in;
 116 }
 117
 118
 119 short TestClass::getShort(short in) {
 120
 121         return in;
 122 }
 123
 124
 125 int64_t TestClass::getLong(int64_t in) {
 126
 127         return in;
 128 }
 129
 130
 131 float TestClass::getFloat(float in) {
 132
 133         return in;
 134 }
 135
 136
 137 double TestClass::getDouble(double in) {
 138
 139         return in;
 140 }
 141
 142
 143 bool TestClass::getBoolean(bool in) {
 144
 145         return in;
 146 }
 147
 148
 149 char TestClass::getChar(char in) {
 150
 151         return in;
 152 }
 153
 154
 155 // Arrays
 156 vector<char> TestClass::getByteArray(vector<char> in) {
 157
 158         return in;
 159 }
 160
 161
 162 vector<short> TestClass::getShortArray(vector<short> in) {
 163
 164         return in;
 165 }
 166
 167
 168 vector<int64_t> TestClass::getLongArray(vector<int64_t> in) {
 169
 170         return in;
 171 }
 172
 173
 174 vector<float> TestClass::getFloatArray(vector<float> in) {
 175
 176         return in;
 177 }
 178
 179
 180 vector<double> TestClass::getDoubleArray(vector<double> in) {
 181
 182         return in;
 183 }
 184
 185
 186 vector<bool> TestClass::getBooleanArray(vector<bool> in) {
 187
 188         return in;
 189 }
 190
 191
 192 vector<char> TestClass::getCharArray(vector<char> in) {
 193
 194         return in;
 195 }
 196
 197 // List
 198 vector<char> TestClass::getByteList(vector<char> in) {
 199
 200         return in;
 201 }
 202
 203
 204 vector<short> TestClass::getShortList(vector<short> in) {
 205
 206         return in;
 207 }
 208
 209
 210 vector<int64_t> TestClass::getLongList(vector<int64_t> in) {
 211
 212         return in;
 213 }
 214
 215
 216 vector<float> TestClass::getFloatList(vector<float> in) {
 217
 218         return in;
 219 }
 220
 221
 222 vector<double> TestClass::getDoubleList(vector<double> in) {
 223
 224         return in;
 225 }
 226
 227
 228 vector<bool> TestClass::getBooleanList(vector<bool> in) {
 229
 230         return in;
 231 }
 232
 233
 234 vector<char> TestClass::getCharList(vector<char> in) {
 235
 236         return in;
 237 }
 238
 239
 240 int TestClass::getA() {
 241
 242         return intA;
 243 }
 244
 245
 246 void TestClass::setA(int _int) {
 247
 248         intA = _int;
 249 }
 250
 251
 252 void TestClass::setB(float _float) {
 253
 254         floatB = _float;
 255 }
 256
 257
 258 void TestClass::setC(string _string) {
 259
 260         stringC = _string;
 261 }
 262
 263
 264 // Enum
 265 Enum TestClass::handleEnum(Enum en) {
 266
 267         cout << "Enum: " << en << endl;
 268
 269         return en;
 270 }
 271
 272
 273 vector<Enum> TestClass::handleEnumArray(vector<Enum> vecEn) {
 274
 275         for (Enum en : vecEn) {
 276                 cout << "Enum: " << en << endl;
 277         }
 278
 279         return vecEn;
 280 }
 281
 282
 283 vector<Enum> TestClass::handleEnumList(vector<Enum> vecEn) {
 284
 285         for (Enum en : vecEn) {
 286                 cout << "Enum: " << en << endl;
 287         }
 288
 289         return vecEn;
 290 }
 291
 292
 293 string TestClass::sumArray(vector<string> newA) {
 294
 295         string sum = "";
 296         int len = newA.size();
 297         for(int c = 0; c < len; c++) {
 298                 sum = sum + newA[c];
 299         }
 300         return sum;
 301 }
 302
 303
 304 int TestClass::setAndGetA(int newA) {
 305
 306         intA = newA;
 307         return intA;
 308 }
 309
 310
 311 int TestClass::setACAndGetA(string newC, int newA) {
 312
 313         stringC = newC;
 314         intA = newA;
 315         return intA;
 316 }
 317
 318 #endif
 319