iotjava/iotrmi/Java/basics/TestClass.java

   1 import java.util.Set;
   2 import java.util.List;
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5
   6 public class TestClass implements TestClassInterface {
   7
   8         /**
   9          * Class Properties
  10          */
  11         private int intA;
  12         private float floatB;
  13         private String stringC;
  14         private List<CallBackInterfaceWithCallBack> cblist;
  15
  16         /**
  17          * Constructors
  18          */
  19         public TestClass() {
  20
  21                 intA = 1;
  22                 floatB = 2;
  23                 stringC = "345";
  24                 cblist = new ArrayList<CallBackInterfaceWithCallBack>();
  25         }
  26
  27
  28         public TestClass(int _int, float _float, String _string) {
  29
  30                 intA = _int;
  31                 floatB = _float;
  32                 stringC = _string;
  33                 cblist = new ArrayList<CallBackInterfaceWithCallBack>();
  34         }
  35
  36
  37         // Callback
  38         //public void registerCallback(CallBackInterface _cb) {
  39         public void registerCallback(CallBackInterfaceWithCallBack _cb) {
  40
  41                 cblist.add(_cb);
  42                 System.out.println("Registering callback object!");
  43         }
  44
  45
  46         public void registerCallbackArray(CallBackInterfaceWithCallBack _cb[]) {
  47
  48                 for (CallBackInterfaceWithCallBack cb : _cb) {
  49                         cblist.add(cb);
  50                         System.out.println("Registering callback objects in array!");
  51                 }
  52         }
  53
  54
  55         public void registerCallbackList(List<CallBackInterfaceWithCallBack> _cb) {
  56
  57                 for (CallBackInterfaceWithCallBack cb : _cb) {
  58                         cblist.add(cb);
  59                         System.out.println("Registering callback objects in list!");
  60                 }
  61         }
  62
  63
  64         public void registerCallbackComplex(int in, List<CallBackInterfaceWithCallBack> _cb, double db) {
  65
  66                 for (CallBackInterfaceWithCallBack cb : _cb) {
  67                         cblist.add(cb);
  68                         System.out.println("Registering callback objects in list!");
  69                 }
  70
  71                 System.out.println("Integer: " + in);
  72                 System.out.println("Double: " + db);
  73         }
  74
  75
  76         public int callBack() {
  77
  78                 int sum = 0;
  79                 for (CallBackInterfaceWithCallBack cb : cblist) {
  80                         sum = sum + cb.printInt();
  81                 }
  82                 return sum;
  83         }
  84
  85
  86         // Single variables
  87         public byte getByte(byte in) {
  88
  89                 return in;
  90         }
  91
  92
  93         public short getShort(short in) {
  94
  95                 return in;
  96         }
  97
  98
  99         public long getLong(long in) {
 100
 101                 return in;
 102         }
 103
 104
 105         public float getFloat(float in) {
 106
 107                 return in;
 108         }
 109
 110
 111         public double getDouble(double in) {
 112
 113                 return in;
 114         }
 115
 116
 117         public boolean getBoolean(boolean in) {
 118
 119                 return in;
 120         }
 121
 122
 123         public char getChar(char in) {
 124
 125                 return in;
 126         }
 127
 128
 129         // Arrays
 130         public byte[] getByteArray(byte[] in) {
 131
 132                 return in;
 133         }
 134
 135
 136         public short[] getShortArray(short[] in) {
 137
 138                 return in;
 139         }
 140
 141
 142         public long[] getLongArray(long[] in) {
 143
 144                 return in;
 145         }
 146
 147
 148         public float[] getFloatArray(float[] in) {
 149
 150                 return in;
 151         }
 152
 153
 154         public double[] getDoubleArray(double[] in) {
 155
 156                 return in;
 157         }
 158
 159
 160         public boolean[] getBooleanArray(boolean[] in) {
 161
 162                 return in;
 163         }
 164
 165
 166         public char[] getCharArray(char[] in) {
 167
 168                 return in;
 169         }
 170
 171
 172         // Lists
 173         public List<Byte> getByteList(List<Byte> in) {
 174
 175                 return in;
 176         }
 177
 178
 179         public List<Short> getShortList(List<Short> in) {
 180
 181                 return in;
 182         }
 183
 184
 185         public List<Long> getLongList(List<Long> in) {
 186
 187                 return in;
 188         }
 189
 190
 191         public List<Float> getFloatList(List<Float> in) {
 192
 193                 return in;
 194         }
 195
 196
 197         public List<Double> getDoubleList(List<Double> in) {
 198
 199                 return in;
 200         }
 201
 202
 203         public List<Boolean> getBooleanList(List<Boolean> in) {
 204
 205                 return in;
 206         }
 207
 208
 209         public List<Character> getCharList(List<Character> in) {
 210
 211                 return in;
 212         }
 213
 214
 215         // Other functions
 216         public int getA() {
 217
 218                 return intA;
 219         }
 220
 221
 222         public void setA(int _int) {
 223
 224                 intA = _int;
 225         }
 226
 227
 228         public void setB(float _float) {
 229
 230                 floatB = _float;
 231         }
 232
 233
 234         public void setC(String _string) {
 235
 236                 stringC = _string;
 237         }
 238
 239
 240         // Enum
 241         public Enum handleEnum(Enum en) {
 242
 243                 System.out.println("Enum: " + en);
 244
 245                 return en;
 246         }
 247
 248
 249         public Enum[] handleEnumArray(Enum[] en) {
 250
 251                 for (Enum e : en) {
 252                         System.out.println("Enum: " + e);
 253                 }
 254
 255                 return en;
 256         }
 257
 258
 259         public List<Enum> handleEnumList(List<Enum> en) {
 260
 261                 for (Enum e : en) {
 262                         System.out.println("Enum: " + e);
 263                 }
 264
 265                 return en;
 266         }
 267
 268
 269         public Enum handleEnumComplex(Enum en, int i, char c) {
 270
 271                 System.out.println("Enum: " + en);
 272                 System.out.println("Integer: " + i);
 273                 System.out.println("Char: " + c);
 274
 275                 return en;
 276         }
 277
 278
 279         public Enum[] handleEnumComplex2(Enum[] en, int in, char c) {
 280
 281                 for (Enum e : en) {
 282                         System.out.println("Enum: " + e);
 283                 }
 284                 System.out.println("Integer: " + in);
 285                 System.out.println("Char: " + c);
 286
 287                 return en;
 288         }
 289
 290
 291         // Struct
 292         public Struct handleStruct(Struct str) {
 293
 294                 System.out.println("Name: " + str.name);
 295                 System.out.println("Value: " + str.value);
 296                 System.out.println("Year: " + str.year);
 297
 298
 299                 Struct test = new Struct();
 300                 test.name = "Anonymous";
 301                 test.value = 1.33f;
 302                 test.year = 2016;
 303
 304                 str = test;
 305
 306                 return str;
 307         }
 308
 309
 310         public Struct[] handleStructArray(Struct str[]) {
 311
 312                 for (Struct st : str) {
 313                         System.out.println("Name: " + st.name);
 314                         System.out.println("Value: " + st.value);
 315                         System.out.println("Year: " + st.year);
 316                 }
 317
 318                 Struct test = new Struct();
 319                 test.name = "Anonymous";
 320                 test.value = 1.33f;
 321                 test.year = 2016;
 322
 323                 str[0] = test;
 324
 325                 return str;
 326         }
 327
 328
 329         public List<Struct> handleStructList(List<Struct> str) {
 330
 331                 for (Struct st : str) {
 332                         System.out.println("Name: " + st.name);
 333                         System.out.println("Value: " + st.value);
 334                         System.out.println("Year: " + st.year);
 335                 }
 336
 337                 Struct test = new Struct();
 338                 test.name = "Tests";
 339                 test.value = 1.34f;
 340                 test.year = 2017;
 341
 342                 str.add(test);
 343
 344                 return str;
 345         }
 346
 347
 348         public Struct handleStructComplex(int in, char c, Struct str) {
 349
 350                 System.out.println("Name: " + str.name);
 351                 System.out.println("Value: " + str.value);
 352                 System.out.println("Year: " + str.year);
 353
 354                 System.out.println("Integer: " + in);
 355                 System.out.println("Char: " + c);
 356
 357                 Struct test = new Struct();
 358                 test.name = "Anonymous";
 359                 test.value = 1.33f;
 360                 test.year = 2016;
 361
 362                 str = test;
 363
 364                 return str;
 365         }
 366
 367
 368         public List<Struct> handleStructComplex2(int in, char c, Struct str[]) {
 369
 370                 for (Struct st : str) {
 371                         System.out.println("Name: " + st.name);
 372                         System.out.println("Value: " + st.value);
 373                         System.out.println("Year: " + st.year);
 374                 }
 375
 376                 System.out.println("Integer: " + in);
 377                 System.out.println("Char: " + c);
 378
 379                 return new ArrayList<Struct>(Arrays.asList(str));
 380         }
 381
 382
 383         public Enum[] handleEnumStruct(Enum en[], List<Struct> str, char c) {
 384
 385                 for (Struct st : str) {
 386                         System.out.println("Name: " + st.name);
 387                         System.out.println("Value: " + st.value);
 388                         System.out.println("Year: " + st.year);
 389                 }
 390
 391                 System.out.println("Char: " + c);
 392
 393                 return en;
 394         }
 395
 396
 397         public Enum[] handleAll(Enum en[], List<Struct> str, char c, List<CallBackInterfaceWithCallBack> _cb) {
 398
 399                 for (CallBackInterfaceWithCallBack cb : _cb) {
 400                         cblist.add(cb);
 401                         System.out.println("Registering callback objects in list!");
 402                 }
 403
 404                 for (Struct st : str) {
 405                         System.out.println("Name: " + st.name);
 406                         System.out.println("Value: " + st.value);
 407                         System.out.println("Year: " + st.year);
 408                 }
 409
 410                 System.out.println("Char: " + c);
 411
 412                 return en;
 413         }
 414
 415
 416         // Getters
 417         public String sumArray(String[] newA) {
 418
 419                 String sum = "";
 420                 for (String i : newA)
 421                         sum = sum + i;
 422                 return sum;
 423         }
 424
 425
 426         public int setAndGetA(int newA) {
 427
 428                 intA = newA;
 429                 return intA;
 430         }
 431
 432
 433         public int setACAndGetA(String newC, int newA) {
 434
 435                 stringC = newC;
 436                 intA = newA;
 437                 return intA;
 438         }
 439 }