benchmarks/Java/IrrigationController/MoistureSensorSmart_Stub.java

   1 package IrrigationController;
   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 MoistureSensorSmart_Stub implements MoistureSensorSmart {
  18
  19         private int objectId = 5;
  20         private IoTRMIComm rmiComm;
  21         // Synchronization variables
  22         private AtomicBoolean retValueReceived2 = new AtomicBoolean(false);
  23         private AtomicBoolean retValueReceived4 = new AtomicBoolean(false);
  24         private AtomicBoolean retValueReceived1 = new AtomicBoolean(false);
  25
  26
  27         public MoistureSensorSmart_Stub(int _localPortSend, int _localPortRecv, int _portSend, int _portRecv, String _skeletonAddress, int _rev) throws Exception {
  28                 if (_localPortSend != 0 && _localPortRecv != 0) {
  29                         rmiComm = new IoTRMICommClient(_localPortSend, _localPortRecv, _portSend, _portRecv, _skeletonAddress, _rev);
  30                 } else
  31                 {
  32                         rmiComm = new IoTRMICommClient(_portSend, _portRecv, _skeletonAddress, _rev);
  33                 }
  34                 rmiComm.registerStub(objectId, 2, retValueReceived2);
  35                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  36                 rmiComm.registerStub(objectId, 1, retValueReceived1);
  37                 IoTRMIUtil.mapStub.put(objectId, this);
  38         }
  39
  40         public MoistureSensorSmart_Stub(IoTRMIComm _rmiComm, int _objectId) throws Exception {
  41                 rmiComm = _rmiComm;
  42                 objectId = _objectId;
  43                 rmiComm.registerStub(objectId, 2, retValueReceived2);
  44                 rmiComm.registerStub(objectId, 4, retValueReceived4);
  45                 rmiComm.registerStub(objectId, 1, retValueReceived1);
  46         }
  47
  48         public long getTimestampOfLastReading() {
  49                 int methodId = 2;
  50                 Class<?> retType = long.class;
  51                 Class<?>[] paramCls = new Class<?>[] {  };
  52                 Object[] paramObj = new Object[] {  };
  53                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  54                 // Waiting for return value
  55                 while (!retValueReceived2.get());
  56                 Object retObj = rmiComm.getReturnValue(retType, null);
  57                 retValueReceived2.set(false);
  58                 rmiComm.setGetReturnBytes();
  59
  60                 return (long)retObj;
  61         }
  62
  63         public int getId() {
  64                 int methodId = 4;
  65                 Class<?> retType = int.class;
  66                 Class<?>[] paramCls = new Class<?>[] {  };
  67                 Object[] paramObj = new Object[] {  };
  68                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
  69                 // Waiting for return value
  70                 while (!retValueReceived4.get());
  71                 Object retObj = rmiComm.getReturnValue(retType, null);
  72                 retValueReceived4.set(false);
  73                 rmiComm.setGetReturnBytes();
  74
  75                 return (int)retObj;
  76         }
  77
  78         public void registerCallback(MoistureSensorCallback _callbackTo) {
  79                 int[] objIdSent0 = new int[1];
  80                 try {
  81                         if (!IoTRMIUtil.mapSkel.containsKey(_callbackTo)) {
  82                                 int newObjIdSent = rmiComm.getObjectIdCounter();
  83                                 objIdSent0[0] = newObjIdSent;
  84                                 rmiComm.decrementObjectIdCounter();
  85                                 MoistureSensorCallback_Skeleton skel0 = new MoistureSensorCallback_Skeleton(_callbackTo, rmiComm, newObjIdSent);
  86                                 IoTRMIUtil.mapSkel.put(_callbackTo, skel0);
  87                                 IoTRMIUtil.mapSkelId.put(_callbackTo, newObjIdSent);
  88                                 Thread thread = new Thread() {
  89                                         public void run() {
  90                                                 try {
  91                                                         skel0.___waitRequestInvokeMethod();
  92                                                         } catch (Exception ex) {
  93                                                         ex.printStackTrace();
  94                                                         throw new Error("Exception when trying to run ___waitRequestInvokeMethod() for MoistureSensorCallback_Skeleton!");
  95                                                 }
  96                                         }
  97                                 };
  98                                 thread.start();
  99                                 while(!skel0.didAlreadyInitWaitInvoke());
 100                         }
 101                         else
 102                         {
 103                                 int newObjIdSent = IoTRMIUtil.mapSkelId.get(_callbackTo);
 104                                 objIdSent0[0] = newObjIdSent;
 105                         }
 106                 } catch (Exception ex) {
 107                         ex.printStackTrace();
 108                         throw new Error("Exception when generating skeleton objects!");
 109                 }
 110
 111                 int methodId = 5;
 112                 Class<?> retType = void.class;
 113                 Class<?>[] paramCls = new Class<?>[] { int[].class };
 114                 Object[] paramObj = new Object[] { objIdSent0 };
 115                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 116         }
 117
 118         public float getMoisture() {
 119                 int methodId = 1;
 120                 Class<?> retType = float.class;
 121                 Class<?>[] paramCls = new Class<?>[] {  };
 122                 Object[] paramObj = new Object[] {  };
 123                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 124                 // Waiting for return value
 125                 while (!retValueReceived1.get());
 126                 Object retObj = rmiComm.getReturnValue(retType, null);
 127                 retValueReceived1.set(false);
 128                 rmiComm.setGetReturnBytes();
 129
 130                 return (float)retObj;
 131         }
 132
 133         public void setId(int id) {
 134                 int methodId = 3;
 135                 Class<?> retType = void.class;
 136                 Class<?>[] paramCls = new Class<?>[] { int.class };
 137                 Object[] paramObj = new Object[] { id };
 138                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 139         }
 140
 141         public void init() {
 142                 int methodId = 0;
 143                 Class<?> retType = void.class;
 144                 Class<?>[] paramCls = new Class<?>[] {  };
 145                 Object[] paramObj = new Object[] {  };
 146                 rmiComm.remoteCall(objectId, methodId, paramCls, paramObj);
 147         }
 148
 149 }