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                 System.out.println("Callback called!");
  80                 for (CallBackInterfaceWithCallBack cb : cblist) {
  81                         sum = sum + cb.printInt();
  82                         cb.needCallback(this);
  83                 }
  84                 return sum;
  85         }
  86
  87
  88         // Single variables
  89         public byte getByte(byte in) {
  90
  91                 return in;
  92         }
  93
  94
  95         public short getShort(short in) {
  96
  97                 return in;
  98         }
  99
 100
 101         public long getLong(long in) {
 102
 103                 return in;
 104         }
 105
 106
 107         public float getFloat(float in) {
 108
 109                 return in;
 110         }
 111
 112
 113         public double getDouble(double in) {
 114
 115                 return in;
 116         }
 117
 118
 119         public boolean getBoolean(boolean in) {
 120
 121                 return in;
 122         }
 123
 124
 125         public char getChar(char in) {
 126
 127                 return in;
 128         }
 129
 130
 131         // Arrays
 132         public byte[] getByteArray(byte[] in) {
 133
 134                 return in;
 135         }
 136
 137
 138         public short[] getShortArray(short[] in) {
 139
 140                 return in;
 141         }
 142
 143
 144         public long[] getLongArray(long[] in) {
 145
 146                 return in;
 147         }
 148
 149
 150         public float[] getFloatArray(float[] in) {
 151
 152                 return in;
 153         }
 154
 155
 156         public double[] getDoubleArray(double[] in) {
 157
 158                 return in;
 159         }
 160
 161
 162         public boolean[] getBooleanArray(boolean[] in) {
 163
 164                 return in;
 165         }
 166
 167
 168         public char[] getCharArray(char[] in) {
 169
 170                 return in;
 171         }
 172
 173
 174         // Lists
 175         public List<Byte> getByteList(List<Byte> in) {
 176
 177                 return in;
 178         }
 179
 180
 181         public List<Short> getShortList(List<Short> in) {
 182
 183                 return in;
 184         }
 185
 186
 187         public List<Long> getLongList(List<Long> in) {
 188
 189                 return in;
 190         }
 191
 192
 193         public List<Float> getFloatList(List<Float> in) {
 194
 195                 return in;
 196         }
 197
 198
 199         public List<Double> getDoubleList(List<Double> in) {
 200
 201                 return in;
 202         }
 203
 204
 205         public List<Boolean> getBooleanList(List<Boolean> in) {
 206
 207                 return in;
 208         }
 209
 210
 211         public List<Character> getCharList(List<Character> in) {
 212
 213                 return in;
 214         }
 215
 216
 217         // Other functions
 218         public int getA() {
 219
 220                 return intA;
 221         }
 222
 223
 224         public void setA(int _int) {
 225
 226                 intA = _int;
 227         }
 228
 229
 230         public void setB(float _float) {
 231
 232                 floatB = _float;
 233         }
 234
 235
 236         public void setC(String _string) {
 237
 238                 stringC = _string;
 239         }
 240
 241
 242         // Enum
 243         public Enum handleEnum(Enum en) {
 244
 245                 System.out.println("Enum: " + en);
 246
 247                 return en;
 248         }
 249
 250
 251         public Enum[] handleEnumArray(Enum[] en) {
 252
 253                 for (Enum e : en) {
 254                         System.out.println("Enum: " + e);
 255                 }
 256
 257                 return en;
 258         }
 259
 260
 261         public List<Enum> handleEnumList(List<Enum> en) {
 262
 263                 for (Enum e : en) {
 264                         System.out.println("Enum: " + e);
 265                 }
 266
 267                 return en;
 268         }
 269
 270
 271         public Enum handleEnumComplex(Enum en, int i, char c) {
 272
 273                 System.out.println("Enum: " + en);
 274                 System.out.println("Integer: " + i);
 275                 System.out.println("Char: " + c);
 276
 277                 return en;
 278         }
 279
 280
 281         public Enum[] handleEnumComplex2(Enum[] en, int in, char c) {
 282
 283                 for (Enum e : en) {
 284                         System.out.println("Enum: " + e);
 285                 }
 286                 System.out.println("Integer: " + in);
 287                 System.out.println("Char: " + c);
 288
 289                 return en;
 290         }
 291
 292
 293         public Enum[] handleEnumTwo(Enum en1[], Enum en2[]) {
 294
 295                 for (Enum e : en1) {
 296                         System.out.println("Enum1: " + e);
 297                 }
 298                 for (Enum e : en2) {
 299                         System.out.println("Enum2: " + e);
 300                 }
 301
 302                 return en1;
 303         }
 304
 305
 306         public Enum[] handleEnumThree(Enum en1[], Enum en2[], List<Struct> str1, List<Struct> str2) {
 307
 308                 for (Enum e : en1) {
 309                         System.out.println("Enum1: " + e);
 310                 }
 311                 for (Enum e : en2) {
 312                         System.out.println("Enum2: " + e);
 313                 }
 314
 315                 return en1;
 316         }
 317
 318
 319         // Struct
 320         public Struct handleStruct(Struct str) {
 321
 322                 System.out.println("Name: " + str.name);
 323                 System.out.println("Value: " + str.value);
 324                 System.out.println("Year: " + str.year);
 325
 326
 327                 Struct test = new Struct();
 328                 test.name = "Anonymous";
 329                 test.value = 1.33f;
 330                 test.year = 2016;
 331
 332                 str = test;
 333
 334                 return str;
 335         }
 336
 337
 338         public Struct[] handleStructArray(Struct str[]) {
 339
 340                 for (Struct st : str) {
 341                         System.out.println("Name: " + st.name);
 342                         System.out.println("Value: " + st.value);
 343                         System.out.println("Year: " + st.year);
 344                 }
 345
 346                 Struct test = new Struct();
 347                 test.name = "Anonymous";
 348                 test.value = 1.33f;
 349                 test.year = 2016;
 350
 351                 str[0] = test;
 352
 353                 return str;
 354         }
 355
 356
 357         public List<Struct> handleStructList(List<Struct> str) {
 358
 359                 for (Struct st : str) {
 360                         System.out.println("Name: " + st.name);
 361                         System.out.println("Value: " + st.value);
 362                         System.out.println("Year: " + st.year);
 363                 }
 364
 365                 Struct test = new Struct();
 366                 test.name = "Tests";
 367                 test.value = 1.34f;
 368                 test.year = 2017;
 369
 370                 str.add(test);
 371
 372                 return str;
 373         }
 374
 375
 376         public Struct handleStructComplex(int in, char c, Struct str) {
 377
 378                 System.out.println("Name: " + str.name);
 379                 System.out.println("Value: " + str.value);
 380                 System.out.println("Year: " + str.year);
 381
 382                 System.out.println("Integer: " + in);
 383                 System.out.println("Char: " + c);
 384
 385                 Struct test = new Struct();
 386                 test.name = "Anonymous";
 387                 test.value = 1.33f;
 388                 test.year = 2016;
 389
 390                 str = test;
 391
 392                 return str;
 393         }
 394
 395
 396         public List<Struct> handleStructComplex2(int in, char c, Struct str[]) {
 397
 398                 for (Struct st : str) {
 399                         System.out.println("Name: " + st.name);
 400                         System.out.println("Value: " + st.value);
 401                         System.out.println("Year: " + st.year);
 402                 }
 403
 404                 System.out.println("Integer: " + in);
 405                 System.out.println("Char: " + c);
 406
 407                 return new ArrayList<Struct>(Arrays.asList(str));
 408         }
 409
 410
 411         public Enum[] handleEnumStruct(Enum en[], List<Struct> str, char c) {
 412
 413                 for (Struct st : str) {
 414                         System.out.println("Name: " + st.name);
 415                         System.out.println("Value: " + st.value);
 416                         System.out.println("Year: " + st.year);
 417                 }
 418
 419                 System.out.println("Char: " + c);
 420
 421                 return en;
 422         }
 423
 424
 425         public List<Struct> handleStructTwo(List<Struct> str1, List<Struct> str2) {
 426
 427                 for (Struct st : str1) {
 428                         System.out.println("Name: " + st.name);
 429                         System.out.println("Value: " + st.value);
 430                         System.out.println("Year: " + st.year);
 431                 }
 432
 433                 return str1;
 434         }
 435
 436
 437         public List<Struct> handleStructThree(List<Struct> str1, List<Struct> str2, List<Struct> str3) {
 438
 439                 for (Struct st : str1) {
 440                         System.out.println("Name: " + st.name);
 441                         System.out.println("Value: " + st.value);
 442                         System.out.println("Year: " + st.year);
 443                 }
 444
 445                 return str2;
 446         }
 447
 448
 449         public Enum[] handleAll(Enum en[], List<Struct> str, char c, List<CallBackInterfaceWithCallBack> _cb) {
 450
 451                 for (CallBackInterfaceWithCallBack cb : _cb) {
 452                         cblist.add(cb);
 453                         System.out.println("Registering callback objects in list!");
 454                 }
 455
 456                 for (Struct st : str) {
 457                         System.out.println("Name: " + st.name);
 458                         System.out.println("Value: " + st.value);
 459                         System.out.println("Year: " + st.year);
 460                 }
 461
 462                 System.out.println("Char: " + c);
 463
 464                 return en;
 465         }
 466
 467
 468         public Enum[] handleCallbackEnum(Enum en[], char c, List<CallBackInterfaceWithCallBack> _cb) {
 469
 470                 for (CallBackInterfaceWithCallBack cb : _cb) {
 471                         cblist.add(cb);
 472                         System.out.println("Registering callback objects in list!");
 473                 }
 474
 475                 System.out.println("Char: " + c);
 476
 477                 return en;
 478         }
 479
 480
 481         public Enum[] handleAllTwo(Enum en1[], Enum en2[], List<Struct> str1, List<Struct> str2, char c, List<CallBackInterfaceWithCallBack> _cb1, List<CallBackInterfaceWithCallBack> _cb2) {
 482
 483                 for (CallBackInterfaceWithCallBack cb : _cb1) {
 484                         cblist.add(cb);
 485                         System.out.println("Registering callback objects in list!");
 486                 }
 487
 488                 for (Struct st : str1) {
 489                         System.out.println("Name: " + st.name);
 490                         System.out.println("Value: " + st.value);
 491                         System.out.println("Year: " + st.year);
 492                 }
 493
 494                 System.out.println("Char: " + c);
 495
 496                 return en1;
 497         }
 498
 499
 500         // Getters
 501         public String sumArray(String[] newA) {
 502
 503                 String sum = "";
 504                 for (String i : newA)
 505                         sum = sum + i;
 506                 return sum;
 507         }
 508
 509
 510         public int setAndGetA(int newA) {
 511
 512                 intA = newA;
 513                 return intA;
 514         }
 515
 516
 517         public int setACAndGetA(String newC, int newA) {
 518
 519                 stringC = newC;
 520                 intA = newA;
 521                 return intA;
 522         }
 523 }