iotjava/iotruntime/master/ObjectInitHandler.java

   1 package iotruntime.master;
   2
   3 // Java standard libraries
   4 import java.io.ObjectInputStream;
   5 import java.io.ObjectOutputStream;
   6 import java.util.ArrayList;
   7 import java.util.HashMap;
   8 import java.util.Iterator;
   9 import java.util.List;
  10 import java.util.Map;
  11
  12 // IoTJava library
  13 import iotruntime.messages.IoTCommCode;
  14
  15 /** Class ObjectInitHandler is a class that maintains
  16  *  a data structure that preserves a collection information
  17  *  for object creation and re-initialization in IoTMaster/IoTSlave.
  18  *  The purpose of this class is to allow field instrumentation and object generation
  19  *  for the main controller to be separate from field re-initialization.
  20  *  This way, object creations can be parallelized.
  21  *  +------------+----------------------+----------------+
  22  *  | FIELD_NAME | ARRAYLIST OF List    | OBJECTINITINFO |
  23  *  +------------+----------------------+----------------+
  24  *  | XXXXXXXXXX | #1                   | XXXXX          |
  25  *  |            |                              | XXXXX          |
  26  *  |            |                      | XXXXX          |
  27  *  |            |                      | ...            |
  28  *  |            | #2                   | XXXXX          |
  29  *  |            |                      | XXXXX          |
  30  *  |            |                      | XXXXX          |
  31  *  +------------+----------------------+----------------+
  32  *  | XXXXXXXXXX | #1                   | XXXXX          |
  33  *  |            |                              | XXXXX          |
  34  *  |            |                      | XXXXX          |
  35  *  |            |                      | ...            |
  36  *  |            | #2                   | XXXXX          |
  37  *  |            |                      | XXXXX          |
  38  *  |            |                      | XXXXX          |
  39  *  |            | ...                  | ...            |
  40  *  +------------+----------------------+----------------+
  41  *
  42  * @author      Rahmadi Trimananda <rahmadi.trimananda @ uci.edu>
  43  * @version     1.0
  44  * @since       2016-05-12
  45  */
  46 public final class ObjectInitHandler {
  47
  48
  49         /**
  50          * ObjectInitHandler class properties
  51      * <p>
  52      * listFieldToObject is our data structure that is implemented
  53      * based on the above description; First we do a lookup on
  54          * listField to find fieldname's index and we use it to access
  55          * other list data structures
  56          */
  57         private List<String> listField;
  58         private List<IoTCommCode> listFieldToSetRelation;
  59         private List<List<ObjectInitInfo>> listFieldToObject;
  60         private Map<Integer, List<ObjectInitInfo>> mapFieldToSecondObject;
  61         private int iNumOfFields;
  62         private boolean bVerbose;
  63
  64
  65         /**
  66          * Empty constructor
  67          */
  68         public ObjectInitHandler(boolean _bVerbose) {
  69
  70                 listField = new ArrayList<String>();
  71                 listFieldToSetRelation = new ArrayList<IoTCommCode>();
  72                 listFieldToObject = new ArrayList<List<ObjectInitInfo>>();
  73                 mapFieldToSecondObject = new HashMap<Integer, List<ObjectInitInfo>>();
  74                 iNumOfFields = 0;
  75                 bVerbose = _bVerbose;
  76                 RuntimeOutput.print("ObjectInitHandler: Creating a new ObjectInitHandler object!", bVerbose);
  77         }
  78
  79     /**
  80          * Method clearObjectInitHandler()
  81          * <p>
  82          * Clear the data structure
  83          *
  84          * @return  void
  85          */
  86         public void clearObjectInitHandler() {
  87
  88                 listField.clear();
  89                 listFieldToSetRelation.clear();
  90                 listFieldToObject.clear();
  91                 mapFieldToSecondObject.clear();
  92                 iNumOfFields = 0;
  93                 RuntimeOutput.print("ObjectInitHandler: Clearing ObjectInitHandler object's data structure!", bVerbose);
  94         }
  95
  96         /**
  97          * Method addField()
  98          * <p>
  99          * Add a new field
 100          *
 101          * @param   strField    String field name
 102          * @param   iotcommMsg  Store IoTCommCode from master
 103          * @return  void
 104          */
 105         public void addField(String strField, IoTCommCode iotcommMsg) {
 106
 107
 108                 // Add a new object in the list of objects
 109                 listField.add(iNumOfFields, strField);
 110                 listFieldToSetRelation.add(iNumOfFields, iotcommMsg);
 111
 112                 List<ObjectInitInfo> list = new ArrayList<ObjectInitInfo>();
 113                 listFieldToObject.add(iNumOfFields, list);
 114                 if (iotcommMsg == IoTCommCode.CREATE_NEW_IOTRELATION) {
 115                         List<ObjectInitInfo> listSecond = new ArrayList<ObjectInitInfo>();
 116                         mapFieldToSecondObject.put(iNumOfFields, listSecond);
 117                 }
 118                 iNumOfFields++;
 119         }
 120
 121
 122         /**
 123          * Method addObjectIntoField()
 124          * <p>
 125          * Add a new field
 126          *
 127          * @param   strField                                    String field name
 128          * @param   strIoTSlaveObjectHostAdd    String IoTSlave object hostname
 129          * @param   strObjName                                  String object name
 130          * @param   strObjClassName                     String object class
 131          * @param   strObjClassInterfaceName    String object class interface
 132          * @param       iRMIRegPort                                     Integer RMI registry port
 133          * @param       iRMIStubPort                            Integer RMI stub port
 134          * @return  void
 135          */
 136         public void addObjectIntoField(String strField, String strIoTSlaveObjectHostAdd,
 137                 String strObjName, String strObjClassName, String strObjClassInterfaceName,
 138                 String strObjStubClsIntfaceName, int iRMIRegPort, int iRMIStubPort) {
 139
 140                 // Get index of strField
 141                 int iFieldIndex = listField.indexOf(strField);
 142
 143                 // Get list structure at index of field
 144                 List<ObjectInitInfo> list = listFieldToObject.get(iFieldIndex);
 145                 // Create a new ObjectInitInfo for a new object in the field
 146                 ObjectInitInfo objInitInfo = new ObjectInitInfo(strIoTSlaveObjectHostAdd, strObjName,
 147                         strObjClassName, strObjClassInterfaceName, strObjStubClsIntfaceName, iRMIRegPort, iRMIStubPort);
 148                 // Add the new ObjectInitInfo
 149                 list.add(objInitInfo);
 150         }
 151
 152
 153         /**
 154          * Method addSecondObjectIntoField()
 155          * <p>
 156          * Add a new field
 157          *
 158          * @param   strField                                    String field name
 159          * @param   strIoTSlaveObjectHostAdd    String IoTSlave object hostname
 160          * @param   strObjName                                  String object name
 161          * @param   strObjClassName                     String object class
 162          * @param   strObjClassInterfaceName    String object class interface
 163          * @param       iRMIRegPort                                     Integer RMI registry port
 164          * @param       iRMIStubPort                            Integer RMI stub port
 165          * @return  void
 166          */
 167         public void addSecondObjectIntoField(String strField, String strIoTSlaveObjectHostAdd,
 168                 String strObjName, String strObjClassName, String strObjClassInterfaceName,
 169                 String strObjStubClsIntfaceName, int iRMIRegPort, int iRMIStubPort) {
 170
 171                 // Get index of strField
 172                 int iFieldIndex = listField.indexOf(strField);
 173                 // Get list structure at index of field
 174                 List<ObjectInitInfo> list = mapFieldToSecondObject.get(iFieldIndex);
 175                 // Create a new ObjectInitInfo for a new object in the field
 176                 ObjectInitInfo objInitInfo = new ObjectInitInfo(strIoTSlaveObjectHostAdd, strObjName,
 177                         strObjClassName, strObjClassInterfaceName, strObjStubClsIntfaceName, iRMIRegPort, iRMIStubPort);
 178                 // Add the new ObjectInitInfo
 179                 list.add(objInitInfo);
 180         }
 181
 182
 183         /**
 184          * Method getNumOfFields()
 185          *
 186          * @return  int
 187          */
 188         public int getNumOfFields() {
 189
 190                 return iNumOfFields;
 191
 192         }
 193
 194         /**
 195          * Method getListOfFields()
 196          *
 197          * @return  List<String>        List of fields
 198          */
 199         public List<String> getListOfFields() {
 200
 201                 return listField;
 202         }
 203
 204         /**
 205          * Method getFieldMessage()
 206          *
 207          * @param   strField            String field name
 208          * @return  IoTCommCode
 209          */
 210         public IoTCommCode getFieldMessage(String strField) {
 211
 212                 return listFieldToSetRelation.get(listField.indexOf(strField));
 213         }
 214
 215
 216         /**
 217          * Method getListObjectInitInfo()
 218          *
 219          * @param   strField                            String field name
 220          * @return  List<ObjectInitInfo>
 221          */
 222         public List<ObjectInitInfo> getListObjectInitInfo(String strField) {
 223
 224                 return listFieldToObject.get(listField.indexOf(strField));
 225         }
 226
 227
 228         /**
 229          * Method getSecondObjectInitInfo()
 230          *
 231          * @param   strField                            String field name
 232          * @return  List<ObjectInitInfo>
 233          */
 234         public List<ObjectInitInfo> getSecondObjectInitInfo(String strField) {
 235
 236                 return mapFieldToSecondObject.get(listField.indexOf(strField));
 237         }
 238
 239
 240         /**
 241          * Method printLists()
 242          *
 243          * @return  int
 244          */
 245         public void printLists() {
 246
 247                 // Iterate on HostAddress
 248                 for(String s : listField) {
 249
 250                         RuntimeOutput.print("ObjectInitHandler: Field: " + s, bVerbose);
 251                         RuntimeOutput.print("ObjectInitHandler: Message type: " + listFieldToSetRelation.get(listField.indexOf(s)), bVerbose);
 252                         List<ObjectInitInfo> listObject = listFieldToObject.get(listField.indexOf(s));
 253                         List<ObjectInitInfo> listSecObject = mapFieldToSecondObject.get(listField.indexOf(s));
 254
 255                         Iterator it = null;
 256                         if (listFieldToSetRelation.get(listField.indexOf(s)) == IoTCommCode.CREATE_NEW_IOTRELATION) {
 257                                 it = listSecObject.iterator();
 258                         }
 259
 260                         for (ObjectInitInfo objInitInfo : listObject) {
 261                                 RuntimeOutput.print("ObjectInitHandler: Object info: ", bVerbose);
 262                                 RuntimeOutput.print("==> Slave object host address: " + objInitInfo.getIoTSlaveObjectHostAdd(), bVerbose);
 263                                 RuntimeOutput.print("==> Object name: " + objInitInfo.getObjectName(), bVerbose);
 264                                 RuntimeOutput.print("==> Object class name: " + objInitInfo.getObjectClassName(), bVerbose);
 265                                 RuntimeOutput.print("==> Object class interface: " + objInitInfo.getObjectClassInterfaceName(), bVerbose);
 266                                 RuntimeOutput.print("==> Object stub class interface: " + objInitInfo.getObjectStubClassInterfaceName(), bVerbose);
 267                                 RuntimeOutput.print("==> RMI registry port: " + objInitInfo.getRMIRegistryPort(), bVerbose);
 268                                 RuntimeOutput.print("==> RMI stub port: " + objInitInfo.getRMIStubPort(), bVerbose);
 269
 270                                 if (listFieldToSetRelation.get(listField.indexOf(s)) == IoTCommCode.CREATE_NEW_IOTRELATION) {
 271                                         ObjectInitInfo objSecObj = (ObjectInitInfo) it.next();
 272
 273                                         RuntimeOutput.print("ObjectInitHandler: Second object info: ", bVerbose);
 274                                         RuntimeOutput.print("==> Slave object host address: " + objSecObj.getIoTSlaveObjectHostAdd(), bVerbose);
 275                                         RuntimeOutput.print("==> Object name: " + objSecObj.getObjectName(), bVerbose);
 276                                         RuntimeOutput.print("==> Object class name: " + objSecObj.getObjectClassName(), bVerbose);
 277                                         RuntimeOutput.print("==> Object class interface: " + objSecObj.getObjectClassInterfaceName(), bVerbose);
 278                                         RuntimeOutput.print("==> Object stub class interface: " + objInitInfo.getObjectStubClassInterfaceName(), bVerbose);
 279                                         RuntimeOutput.print("==> RMI registry port: " + objSecObj.getRMIRegistryPort(), bVerbose);
 280                                         RuntimeOutput.print("==> RMI stub port: " + objSecObj.getRMIStubPort(), bVerbose);
 281                                 }
 282                         }
 283                 }
 284         }
 285 }