benchmarks/Java/SmartLightsController/LightBulbSmart_Stub.java

   1 package SmartLightsController;
   2
   3 import java.io.IOException;
   4 import java.util.List;
   5 import java.util.ArrayList;
   6 import java.util.Arrays;
   7 import java.util.Map;
   8 import java.util.HashMap;
   9 import java.util.concurrent.atomic.AtomicBoolean;
  10 import iotrmi.Java.IoTRMIComm;
  11 import iotrmi.Java.IoTRMICommClient;
  12 import iotrmi.Java.IoTRMICommServer;
  13 import iotrmi.Java.IoTRMIUtil;
  14
  15 import iotcode.interfaces.*;
  16
  17 public class LightBulbSmart_Stub implements LightBulbSmart {
  18
  19         private int objectId = 1;
  20         private IoTRMIComm rmiComm;
  21         // Synchronization variables
  22         private AtomicBoolean retValueReceived10 = new AtomicBoolean(false);
  23         private AtomicBoolean retValueReceived3 = new AtomicBoolean(false);
  24         private AtomicBoolean retValueReceived11 = new AtomicBoolean(false);
  25         private AtomicBoolean retValueReceived8 = new AtomicBoolean(false);
  26         private AtomicBoolean retValueReceived12 = new AtomicBoolean(false);
  27         private AtomicBoolean retValueReceived7 = new AtomicBoolean(false);
  28         private AtomicBoolean retValueReceived13 = new AtomicBoolean(false);
  29         private AtomicBoolean retValueReceived9 = new AtomicBoolean(false);
  30         private AtomicBoolean retValueReceived6 = new AtomicBoolean(false);
  31         private AtomicBoolean retValueReceived16 = new AtomicBoolean(false);
  32         private AtomicBoolean retValueReceived17 = new AtomicBoolean(false);
  33         private AtomicBoolean retValueReceived14 = new AtomicBoolean(false);
  34         private AtomicBoolean retValueReceived15 = new AtomicBoolean(false);
  35
  36
  37         public LightBulbSmart_Stub(int _localPortSend, int _localPortRecv, int _portSend, int _portRecv, String _skeletonAddress, int _rev) throws Exception {
  38                 if (_localPortSend != 0 && _localPortRecv != 0) {
  39                         rmiComm = new IoTRMICommClient(_localPortSend, _localPortRecv, _portSend, _portRecv, _skeletonAddress, _rev);
  40                 } else
  41                 {
  42                         rmiComm = new IoTRMICommClient(_portSend, _portRecv, _skeletonAddress, _rev);
  43                 }
  44                 rmiComm.registerStub(objectId, 10, retValueReceived10);
  45                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  46                 rmiComm.registerStub(objectId, 11, retValueReceived11);
  47                 rmiComm.registerStub(objectId, 8, retValueReceived8);
  48                 rmiComm.registerStub(objectId, 12, retValueReceived12);
  49                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  50                 rmiComm.registerStub(objectId, 13, retValueReceived13);
  51                 rmiComm.registerStub(objectId, 9, retValueReceived9);
  52                 rmiComm.registerStub(objectId, 6, retValueReceived6);
  53                 rmiComm.registerStub(objectId, 16, retValueReceived16);
  54                 rmiComm.registerStub(objectId, 17, retValueReceived17);
  55                 rmiComm.registerStub(objectId, 14, retValueReceived14);
  56                 rmiComm.registerStub(objectId, 15, retValueReceived15);
  57                 IoTRMIUtil.mapStub.put(objectId, this);
  58         }
  59
  60         public LightBulbSmart_Stub(IoTRMIComm _rmiComm, int _objectId) throws Exception {
  61                 rmiComm = _rmiComm;
  62                 objectId = _objectId;
  63                 rmiComm.registerStub(objectId, 10, retValueReceived10);
  64                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  65                 rmiComm.registerStub(objectId, 11, retValueReceived11);
  66                 rmiComm.registerStub(objectId, 8, retValueReceived8);
  67                 rmiComm.registerStub(objectId, 12, retValueReceived12);
  68                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  69                 rmiComm.registerStub(objectId, 13, retValueReceived13);
  70                 rmiComm.registerStub(objectId, 9, retValueReceived9);
  71                 rmiComm.registerStub(objectId, 6, retValueReceived6);
  72                 rmiComm.registerStub(objectId, 16, retValueReceived16);
  73                 rmiComm.registerStub(objectId, 17, retValueReceived17);
  74                 rmiComm.registerStub(objectId, 14, retValueReceived14);
  75                 rmiComm.registerStub(objectId, 15, retValueReceived15);
  76         }
  77
  78         public void turnOn() {
  79                 int methodId = 2;
  80                 Class<?> retType = void.class;
  81                 Class<?>[] paramCls = new Class<?>[] {  };
  82                 Object[] paramObj = new Object[] {  };
  83                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  84         }
  85
  86         public double getBrightnessRangeLowerBound() {
  87                 int methodId = 10;
  88                 Class<?> retType = double.class;
  89                 Class<?>[] paramCls = new Class<?>[] {  };
  90                 Object[] paramObj = new Object[] {  };
  91                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  92                 // Waiting for return value
  93                 while (!retValueReceived10.get());
  94                 Object retObj = rmiComm.getReturnValue(retType, null);
  95                 retValueReceived10.set(false);
  96                 rmiComm.setGetReturnBytes();
  97
  98                 return (double)retObj;
  99         }
 100
 101         public void turnOff() {
 102                 int methodId = 1;
 103                 Class<?> retType = void.class;
 104                 Class<?>[] paramCls = new Class<?>[] {  };
 105                 Object[] paramObj = new Object[] {  };
 106                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 107         }
 108
 109         public boolean getState() {
 110                 int methodId = 3;
 111                 Class<?> retType = boolean.class;
 112                 Class<?>[] paramCls = new Class<?>[] {  };
 113                 Object[] paramObj = new Object[] {  };
 114                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 115                 // Waiting for return value
 116                 while (!retValueReceived3.get());
 117                 Object retObj = rmiComm.getReturnValue(retType, null);
 118                 retValueReceived3.set(false);
 119                 rmiComm.setGetReturnBytes();
 120
 121                 return (boolean)retObj;
 122         }
 123
 124         public double getBrightnessRangeUpperBound() {
 125                 int methodId = 11;
 126                 Class<?> retType = double.class;
 127                 Class<?>[] paramCls = new Class<?>[] {  };
 128                 Object[] paramObj = new Object[] {  };
 129                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 130                 // Waiting for return value
 131                 while (!retValueReceived11.get());
 132                 Object retObj = rmiComm.getReturnValue(retType, null);
 133                 retValueReceived11.set(false);
 134                 rmiComm.setGetReturnBytes();
 135
 136                 return (double)retObj;
 137         }
 138
 139         public double getSaturation() {
 140                 int methodId = 8;
 141                 Class<?> retType = double.class;
 142                 Class<?>[] paramCls = new Class<?>[] {  };
 143                 Object[] paramObj = new Object[] {  };
 144                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 145                 // Waiting for return value
 146                 while (!retValueReceived8.get());
 147                 Object retObj = rmiComm.getReturnValue(retType, null);
 148                 retValueReceived8.set(false);
 149                 rmiComm.setGetReturnBytes();
 150
 151                 return (double)retObj;
 152         }
 153
 154         public double getHueRangeLowerBound() {
 155                 int methodId = 12;
 156                 Class<?> retType = double.class;
 157                 Class<?>[] paramCls = new Class<?>[] {  };
 158                 Object[] paramObj = new Object[] {  };
 159                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 160                 // Waiting for return value
 161                 while (!retValueReceived12.get());
 162                 Object retObj = rmiComm.getReturnValue(retType, null);
 163                 retValueReceived12.set(false);
 164                 rmiComm.setGetReturnBytes();
 165
 166                 return (double)retObj;
 167         }
 168
 169         public double getHue() {
 170                 int methodId = 7;
 171                 Class<?> retType = double.class;
 172                 Class<?>[] paramCls = new Class<?>[] {  };
 173                 Object[] paramObj = new Object[] {  };
 174                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 175                 // Waiting for return value
 176                 while (!retValueReceived7.get());
 177                 Object retObj = rmiComm.getReturnValue(retType, null);
 178                 retValueReceived7.set(false);
 179                 rmiComm.setGetReturnBytes();
 180
 181                 return (double)retObj;
 182         }
 183
 184         public double getHueRangeUpperBound() {
 185                 int methodId = 13;
 186                 Class<?> retType = double.class;
 187                 Class<?>[] paramCls = new Class<?>[] {  };
 188                 Object[] paramObj = new Object[] {  };
 189                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 190                 // Waiting for return value
 191                 while (!retValueReceived13.get());
 192                 Object retObj = rmiComm.getReturnValue(retType, null);
 193                 retValueReceived13.set(false);
 194                 rmiComm.setGetReturnBytes();
 195
 196                 return (double)retObj;
 197         }
 198
 199         public int getTemperature() {
 200                 int methodId = 9;
 201                 Class<?> retType = int.class;
 202                 Class<?>[] paramCls = new Class<?>[] {  };
 203                 Object[] paramObj = new Object[] {  };
 204                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 205                 // Waiting for return value
 206                 while (!retValueReceived9.get());
 207                 Object retObj = rmiComm.getReturnValue(retType, null);
 208                 retValueReceived9.set(false);
 209                 rmiComm.setGetReturnBytes();
 210
 211                 return (int)retObj;
 212         }
 213
 214         public double getBrightness() {
 215                 int methodId = 6;
 216                 Class<?> retType = double.class;
 217                 Class<?>[] paramCls = new Class<?>[] {  };
 218                 Object[] paramObj = new Object[] {  };
 219                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 220                 // Waiting for return value
 221                 while (!retValueReceived6.get());
 222                 Object retObj = rmiComm.getReturnValue(retType, null);
 223                 retValueReceived6.set(false);
 224                 rmiComm.setGetReturnBytes();
 225
 226                 return (double)retObj;
 227         }
 228
 229         public int getTemperatureRangeLowerBound() {
 230                 int methodId = 16;
 231                 Class<?> retType = int.class;
 232                 Class<?>[] paramCls = new Class<?>[] {  };
 233                 Object[] paramObj = new Object[] {  };
 234                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 235                 // Waiting for return value
 236                 while (!retValueReceived16.get());
 237                 Object retObj = rmiComm.getReturnValue(retType, null);
 238                 retValueReceived16.set(false);
 239                 rmiComm.setGetReturnBytes();
 240
 241                 return (int)retObj;
 242         }
 243
 244         public int getTemperatureRangeUpperBound() {
 245                 int methodId = 17;
 246                 Class<?> retType = int.class;
 247                 Class<?>[] paramCls = new Class<?>[] {  };
 248                 Object[] paramObj = new Object[] {  };
 249                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 250                 // Waiting for return value
 251                 while (!retValueReceived17.get());
 252                 Object retObj = rmiComm.getReturnValue(retType, null);
 253                 retValueReceived17.set(false);
 254                 rmiComm.setGetReturnBytes();
 255
 256                 return (int)retObj;
 257         }
 258
 259         public void setColor(double _hue, double _saturation, double _brightness) {
 260                 int methodId = 4;
 261                 Class<?> retType = void.class;
 262                 Class<?>[] paramCls = new Class<?>[] { double.class, double.class, double.class };
 263                 Object[] paramObj = new Object[] { _hue, _saturation, _brightness };
 264                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 265         }
 266
 267         public void init() {
 268                 int methodId = 0;
 269                 Class<?> retType = void.class;
 270                 Class<?>[] paramCls = new Class<?>[] {  };
 271                 Object[] paramObj = new Object[] {  };
 272                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 273         }
 274
 275         public double getSaturationRangeLowerBound() {
 276                 int methodId = 14;
 277                 Class<?> retType = double.class;
 278                 Class<?>[] paramCls = new Class<?>[] {  };
 279                 Object[] paramObj = new Object[] {  };
 280                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 281                 // Waiting for return value
 282                 while (!retValueReceived14.get());
 283                 Object retObj = rmiComm.getReturnValue(retType, null);
 284                 retValueReceived14.set(false);
 285                 rmiComm.setGetReturnBytes();
 286
 287                 return (double)retObj;
 288         }
 289
 290         public double getSaturationRangeUpperBound() {
 291                 int methodId = 15;
 292                 Class<?> retType = double.class;
 293                 Class<?>[] paramCls = new Class<?>[] {  };
 294                 Object[] paramObj = new Object[] {  };
 295                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 296                 // Waiting for return value
 297                 while (!retValueReceived15.get());
 298                 Object retObj = rmiComm.getReturnValue(retType, null);
 299                 retValueReceived15.set(false);
 300                 rmiComm.setGetReturnBytes();
 301
 302                 return (double)retObj;
 303         }
 304
 305         public void setTemperature(int _temperature) {
 306                 int methodId = 5;
 307                 Class<?> retType = void.class;
 308                 Class<?>[] paramCls = new Class<?>[] { int.class };
 309                 Object[] paramObj = new Object[] { _temperature };
 310                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 311         }
 312
 313 }