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         public Enum[] handleEnumTwo(Enum en1[], Enum en2[]) {
 292
 293                 for (Enum e : en1) {
 294                         System.out.println("Enum1: " + e);
 295                 }
 296                 for (Enum e : en2) {
 297                         System.out.println("Enum2: " + e);
 298                 }
 299
 300                 return en1;
 301         }
 302
 303
 304         public Enum[] handleEnumThree(Enum en1[], Enum en2[], List<Struct> str1, List<Struct> str2) {
 305
 306                 for (Enum e : en1) {
 307                         System.out.println("Enum1: " + e);
 308                 }
 309                 for (Enum e : en2) {
 310                         System.out.println("Enum2: " + e);
 311                 }
 312
 313                 return en1;
 314         }
 315
 316
 317         // Struct
 318         public Struct handleStruct(Struct str) {
 319
 320                 System.out.println("Name: " + str.name);
 321                 System.out.println("Value: " + str.value);
 322                 System.out.println("Year: " + str.year);
 323
 324
 325                 Struct test = new Struct();
 326                 test.name = "Anonymous";
 327                 test.value = 1.33f;
 328                 test.year = 2016;
 329
 330                 str = test;
 331
 332                 return str;
 333         }
 334
 335
 336         public Struct[] handleStructArray(Struct str[]) {
 337
 338                 for (Struct st : str) {
 339                         System.out.println("Name: " + st.name);
 340                         System.out.println("Value: " + st.value);
 341                         System.out.println("Year: " + st.year);
 342                 }
 343
 344                 Struct test = new Struct();
 345                 test.name = "Anonymous";
 346                 test.value = 1.33f;
 347                 test.year = 2016;
 348
 349                 str[0] = test;
 350
 351                 return str;
 352         }
 353
 354
 355         public List<Struct> handleStructList(List<Struct> str) {
 356
 357                 for (Struct st : str) {
 358                         System.out.println("Name: " + st.name);
 359                         System.out.println("Value: " + st.value);
 360                         System.out.println("Year: " + st.year);
 361                 }
 362
 363                 Struct test = new Struct();
 364                 test.name = "Tests";
 365                 test.value = 1.34f;
 366                 test.year = 2017;
 367
 368                 str.add(test);
 369
 370                 return str;
 371         }
 372
 373
 374         public Struct handleStructComplex(int in, char c, Struct str) {
 375
 376                 System.out.println("Name: " + str.name);
 377                 System.out.println("Value: " + str.value);
 378                 System.out.println("Year: " + str.year);
 379
 380                 System.out.println("Integer: " + in);
 381                 System.out.println("Char: " + c);
 382
 383                 Struct test = new Struct();
 384                 test.name = "Anonymous";
 385                 test.value = 1.33f;
 386                 test.year = 2016;
 387
 388                 str = test;
 389
 390                 return str;
 391         }
 392
 393
 394         public List<Struct> handleStructComplex2(int in, char c, Struct str[]) {
 395
 396                 for (Struct st : str) {
 397                         System.out.println("Name: " + st.name);
 398                         System.out.println("Value: " + st.value);
 399                         System.out.println("Year: " + st.year);
 400                 }
 401
 402                 System.out.println("Integer: " + in);
 403                 System.out.println("Char: " + c);
 404
 405                 return new ArrayList<Struct>(Arrays.asList(str));
 406         }
 407
 408
 409         public Enum[] handleEnumStruct(Enum en[], List<Struct> str, char c) {
 410
 411                 for (Struct st : str) {
 412                         System.out.println("Name: " + st.name);
 413                         System.out.println("Value: " + st.value);
 414                         System.out.println("Year: " + st.year);
 415                 }
 416
 417                 System.out.println("Char: " + c);
 418
 419                 return en;
 420         }
 421
 422
 423         public List<Struct> handleStructTwo(List<Struct> str1, List<Struct> str2) {
 424
 425                 for (Struct st : str1) {
 426                         System.out.println("Name: " + st.name);
 427                         System.out.println("Value: " + st.value);
 428                         System.out.println("Year: " + st.year);
 429                 }
 430
 431                 return str1;
 432         }
 433
 434
 435         public List<Struct> handleStructThree(List<Struct> str1, List<Struct> str2, List<Struct> str3) {
 436
 437                 for (Struct st : str1) {
 438                         System.out.println("Name: " + st.name);
 439                         System.out.println("Value: " + st.value);
 440                         System.out.println("Year: " + st.year);
 441                 }
 442
 443                 return str2;
 444         }
 445
 446
 447         public Enum[] handleAll(Enum en[], List<Struct> str, char c, List<CallBackInterfaceWithCallBack> _cb) {
 448
 449                 for (CallBackInterfaceWithCallBack cb : _cb) {
 450                         cblist.add(cb);
 451                         System.out.println("Registering callback objects in list!");
 452                 }
 453
 454                 for (Struct st : str) {
 455                         System.out.println("Name: " + st.name);
 456                         System.out.println("Value: " + st.value);
 457                         System.out.println("Year: " + st.year);
 458                 }
 459
 460                 System.out.println("Char: " + c);
 461
 462                 return en;
 463         }
 464
 465
 466         public Enum[] handleCallbackEnum(Enum en[], char c, List<CallBackInterfaceWithCallBack> _cb) {
 467
 468                 for (CallBackInterfaceWithCallBack cb : _cb) {
 469                         cblist.add(cb);
 470                         System.out.println("Registering callback objects in list!");
 471                 }
 472
 473                 System.out.println("Char: " + c);
 474
 475                 return en;
 476         }
 477
 478
 479         public Enum[] handleAllTwo(Enum en1[], Enum en2[], List<Struct> str1, List<Struct> str2, char c, List<CallBackInterfaceWithCallBack> _cb1, List<CallBackInterfaceWithCallBack> _cb2) {
 480
 481                 for (CallBackInterfaceWithCallBack cb : _cb1) {
 482                         cblist.add(cb);
 483                         System.out.println("Registering callback objects in list!");
 484                 }
 485
 486                 for (Struct st : str1) {
 487                         System.out.println("Name: " + st.name);
 488                         System.out.println("Value: " + st.value);
 489                         System.out.println("Year: " + st.year);
 490                 }
 491
 492                 System.out.println("Char: " + c);
 493
 494                 return en1;
 495         }
 496
 497
 498         // Getters
 499         public String sumArray(String[] newA) {
 500
 501                 String sum = "";
 502                 for (String i : newA)
 503                         sum = sum + i;
 504                 return sum;
 505         }
 506
 507
 508         public int setAndGetA(int newA) {
 509
 510                 intA = newA;
 511                 return intA;
 512         }
 513
 514
 515         public int setACAndGetA(String newC, int newA) {
 516
 517                 stringC = newC;
 518                 intA = newA;
 519                 return intA;
 520         }
 521 }