benchmarks/Java/HomeSecurityController/SmartthingsActuatorSmart_Stub.java

   1 package HomeSecurityController;
   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 SmartthingsActuatorSmart_Stub implements SmartthingsActuatorSmart {
  18
  19         private int objectId = 1;
  20         private IoTRMIComm rmiComm;
  21         // Synchronization variables
  22         private AtomicBoolean retValueReceived5 = new AtomicBoolean(false);
  23         private AtomicBoolean retValueReceived7 = new AtomicBoolean(false);
  24         private AtomicBoolean retValueReceived4 = new AtomicBoolean(false);
  25         private AtomicBoolean retValueReceived3 = new AtomicBoolean(false);
  26         private AtomicBoolean retValueReceived1 = new AtomicBoolean(false);
  27
  28
  29         public SmartthingsActuatorSmart_Stub(int _localPortSend, int _localPortRecv, int _portSend, int _portRecv, String _skeletonAddress, int _rev) throws Exception {
  30                 if (_localPortSend != 0 && _localPortRecv != 0) {
  31                         rmiComm = new IoTRMICommClient(_localPortSend, _localPortRecv, _portSend, _portRecv, _skeletonAddress, _rev);
  32                 } else
  33                 {
  34                         rmiComm = new IoTRMICommClient(_portSend, _portRecv, _skeletonAddress, _rev);
  35                 }
  36                 rmiComm.registerStub(objectId, 5, retValueReceived5);
  37                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  38                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  39                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  40                 rmiComm.registerStub(objectId, 1, retValueReceived1);
  41                 IoTRMIUtil.mapStub.put(objectId, this);
  42         }
  43
  44         public SmartthingsActuatorSmart_Stub(IoTRMIComm _rmiComm, int _objectId) throws Exception {
  45                 rmiComm = _rmiComm;
  46                 objectId = _objectId;
  47                 rmiComm.registerStub(objectId, 5, retValueReceived5);
  48                 rmiComm.registerStub(objectId, 7, retValueReceived7);
  49                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  50                 rmiComm.registerStub(objectId, 3, retValueReceived3);
  51                 rmiComm.registerStub(objectId, 1, retValueReceived1);
  52         }
  53
  54         public long getTimestampOfLastReading() {
  55                 int methodId = 5;
  56                 Class<?> retType = long.class;
  57                 Class<?>[] paramCls = new Class<?>[] {  };
  58                 Object[] paramObj = new Object[] {  };
  59                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  60                 // Waiting for return value
  61                 while (!retValueReceived5.get());
  62                 Object retObj = rmiComm.getReturnValue(retType, null);
  63                 retValueReceived5.set(false);
  64                 rmiComm.setGetReturnBytes();
  65
  66                 return (long)retObj;
  67         }
  68
  69         public int getId() {
  70                 int methodId = 7;
  71                 Class<?> retType = int.class;
  72                 Class<?>[] paramCls = new Class<?>[] {  };
  73                 Object[] paramObj = new Object[] {  };
  74                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  75                 // Waiting for return value
  76                 while (!retValueReceived7.get());
  77                 Object retObj = rmiComm.getReturnValue(retType, null);
  78                 retValueReceived7.set(false);
  79                 rmiComm.setGetReturnBytes();
  80
  81                 return (int)retObj;
  82         }
  83
  84         public void registerCallback(SmartthingsActuatorCallback _callbackTo) {
  85                 int[] objIdSent0 = new int[1];
  86                 try {
  87                         if (!IoTRMIUtil.mapSkel.containsKey(_callbackTo)) {
  88                                 int newObjIdSent = rmiComm.getObjectIdCounter();
  89                                 objIdSent0[0] = newObjIdSent;
  90                                 rmiComm.decrementObjectIdCounter();
  91                                 SmartthingsActuatorCallback_Skeleton skel0 = new SmartthingsActuatorCallback_Skeleton(_callbackTo, rmiComm, newObjIdSent);
  92                                 IoTRMIUtil.mapSkel.put(_callbackTo, skel0);
  93                                 IoTRMIUtil.mapSkelId.put(_callbackTo, newObjIdSent);
  94                                 Thread thread = new Thread() {
  95                                         public void run() {
  96                                                 try {
  97                                                         skel0.___waitRequestInvokeMethod();
  98                                                         } catch (Exception ex) {
  99                                                         ex.printStackTrace();
 100                                                         throw new Error("Exception when trying to run ___waitRequestInvokeMethod() for SmartthingsActuatorCallback_Skeleton!");
 101                                                 }
 102                                         }
 103                                 };
 104                                 thread.start();
 105                                 while(!skel0.didAlreadyInitWaitInvoke());
 106                         }
 107                         else
 108                         {
 109                                 int newObjIdSent = IoTRMIUtil.mapSkelId.get(_callbackTo);
 110                                 objIdSent0[0] = newObjIdSent;
 111                         }
 112                 } catch (Exception ex) {
 113                         ex.printStackTrace();
 114                         throw new Error("Exception when generating skeleton objects!");
 115                 }
 116
 117                 int methodId = 8;
 118                 Class<?> retType = void.class;
 119                 Class<?>[] paramCls = new Class<?>[] { int[].class };
 120                 Object[] paramObj = new Object[] { objIdSent0 };
 121                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 122         }
 123
 124         public void requestStatus() {
 125                 int methodId = 2;
 126                 Class<?> retType = void.class;
 127                 Class<?>[] paramCls = new Class<?>[] {  };
 128                 Object[] paramObj = new Object[] {  };
 129                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 130         }
 131
 132         public void setId(int id) {
 133                 int methodId = 6;
 134                 Class<?> retType = void.class;
 135                 Class<?>[] paramCls = new Class<?>[] { int.class };
 136                 Object[] paramObj = new Object[] { id };
 137                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 138         }
 139
 140         public boolean isActiveStatus() {
 141                 int methodId = 4;
 142                 Class<?> retType = boolean.class;
 143                 Class<?>[] paramCls = new Class<?>[] {  };
 144                 Object[] paramObj = new Object[] {  };
 145                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 146                 // Waiting for return value
 147                 while (!retValueReceived4.get());
 148                 Object retObj = rmiComm.getReturnValue(retType, null);
 149                 retValueReceived4.set(false);
 150                 rmiComm.setGetReturnBytes();
 151
 152                 return (boolean)retObj;
 153         }
 154
 155         public int getStatus() {
 156                 int methodId = 3;
 157                 Class<?> retType = int.class;
 158                 Class<?>[] paramCls = new Class<?>[] {  };
 159                 Object[] paramObj = new Object[] {  };
 160                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 161                 // Waiting for return value
 162                 while (!retValueReceived3.get());
 163                 Object retObj = rmiComm.getReturnValue(retType, null);
 164                 retValueReceived3.set(false);
 165                 rmiComm.setGetReturnBytes();
 166
 167                 return (int)retObj;
 168         }
 169
 170         public void init() {
 171                 int methodId = 0;
 172                 Class<?> retType = void.class;
 173                 Class<?>[] paramCls = new Class<?>[] {  };
 174                 Object[] paramObj = new Object[] {  };
 175                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 176         }
 177
 178         public boolean actuate(int value) {
 179                 int methodId = 1;
 180                 Class<?> retType = boolean.class;
 181                 Class<?>[] paramCls = new Class<?>[] { int.class };
 182                 Object[] paramObj = new Object[] { value };
 183                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 184                 // Waiting for return value
 185                 while (!retValueReceived1.get());
 186                 Object retObj = rmiComm.getReturnValue(retType, null);
 187                 retValueReceived1.set(false);
 188                 rmiComm.setGetReturnBytes();
 189
 190                 return (boolean)retObj;
 191         }
 192
 193 }