001package jmri.jmrit.ctc.configurexml; 002 003import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; 004 005import java.beans.XMLDecoder; 006import java.io.BufferedInputStream; 007import java.io.BufferedReader; 008import java.io.BufferedWriter; 009import java.io.FileInputStream; 010import java.io.FileReader; 011import java.io.FileWriter; 012import java.io.IOException; 013import java.util.ArrayList; 014import jmri.*; 015import jmri.jmrit.ctc.*; 016import jmri.jmrit.ctc.editor.code.*; 017import jmri.jmrit.ctc.ctcserialdata.*; 018 019/** 020 * The external data was created using XMLEncoder. The import process changes the 021 * class names in the xml file and then loads the temporary classes using XMLDecoder. 022 * The content from the temporary classes is then transferred and converted to the 023 * real classes. 024 * 025 * @author Dave Sand Copyright (c) 2020 026 */ 027public class ImportExternalData { 028 029 static final CtcManager cm = InstanceManager.getDefault(CtcManager.class); 030 static ImportOtherData _mImportOtherData; 031 static ArrayList<ImportCodeButtonHandlerData> _mImportCodeButtonHandlerDataArrayList = new ArrayList<>(); 032 033 private static final String CTC_FILE_NAME = "CTCSystem.xml"; // NOI18N 034 private static final String PROG_PROPS = "ProgramProperties.xml"; // NOI18N 035 private static final String TEMPORARY_EXTENSION = ".xmlTMP"; // NOI18N 036 private static final String SAVED_PREFIX = "V1_Save_"; // NOI18N 037 038 public static void loadExternalData() { 039 // Make an initial backup of the CTCSystem.xml file. This only occurs on the very first run 040 // This backup can be used to run version 1 CTC. 041 String backName = SAVED_PREFIX + CTC_FILE_NAME; 042 if (!CTCFiles.fileExists(backName)) { 043 if (!CTCFiles.copyFile(CTC_FILE_NAME, backName, false)) { 044 log.warn("Unable to make version 1 copy: source = {}, backup = {}", CTC_FILE_NAME, backName); 045 return; 046 } 047 } 048 backName = SAVED_PREFIX + PROG_PROPS; 049 if (!CTCFiles.fileExists(backName)) { 050 if (!CTCFiles.copyFile(PROG_PROPS, backName, false)) { 051 log.warn("Unable to make version 1 copy: source = {}, backup = {}", PROG_PROPS, backName); 052 return; 053 } 054 } 055 056 cm.getProgramProperties().importExternalProgramProperties(); // Load ProgramProperties 057 if (loadCTCSystemContent()) { // Load the CTCSystem.xml file into special classes 058 doDataLoading(); // Process the content 059 } 060 061 // Delete tempoary data files 062 if (!CTCFiles.deleteFile(CTC_FILE_NAME)) { 063 log.error("Delete failed for old CTCSystem.xml"); 064 } 065 if (!CTCFiles.deleteFile(PROG_PROPS)) { 066 log.error("Delete failed for old ProgramProperties.xml"); 067 } 068 } 069 070 @SuppressWarnings("unchecked") // See below comments: 071 public static boolean loadCTCSystemContent() { 072 String fullName = CTCFiles.getFullName(CTC_FILE_NAME); 073 ImportCodeButtonHandlerData.preprocessingUpgradeSelf(fullName); // WHOLE FILE operations FIRST. 074 try { 075 convertClassNameReferences(CTC_FILE_NAME); // Change the class references 076 } catch (Exception ex) { 077 log.error("Exception occurred converting the class names in CTCSystem.xml: ex = {}", ex.getMessage()); 078 return false; 079 } 080 081 try { 082 try (XMLDecoder xmlDecoder = new XMLDecoder(new BufferedInputStream(new FileInputStream(fullName)))) { 083 _mImportOtherData = (ImportOtherData) xmlDecoder.readObject(); 084 // triggers unchecked warning 085 _mImportCodeButtonHandlerDataArrayList = (ArrayList<ImportCodeButtonHandlerData>) xmlDecoder.readObject(); // Type safety: Unchecked cast from Object to ArrayList<> 086 } 087 } catch (IOException e) { 088 log.debug("Unable to read {}", CTC_FILE_NAME, e); // debug because missing file is not error 089 } 090 if (_mImportOtherData == null) { 091 log.error("--------- Import failed"); 092 return false; 093 } 094 095 // Give each object a chance to upgrade itself BEFORE anything uses it: 096 _mImportOtherData.upgradeSelf(); 097 for (ImportCodeButtonHandlerData codeButtonHandlerData : _mImportCodeButtonHandlerDataArrayList) { 098 codeButtonHandlerData.upgradeSelf(); 099 } 100 101 return true; 102 } 103 104 @SuppressFBWarnings(value = "OS_OPEN_STREAM_EXCEPTION_PATH", justification = "Low risk due to rare usage") 105 static private void convertClassNameReferences(String fileName) throws Exception { 106 String temporaryFilename = fileName + TEMPORARY_EXTENSION; 107 int errors = 0; 108 if (!CTCFiles.deleteFile(temporaryFilename)) errors++; // Just delete it for safety before we start: 109 BufferedReader bufferedReader = new BufferedReader(new FileReader(CTCFiles.getFullName(fileName))); 110 BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(CTCFiles.getFullName(temporaryFilename))); 111 String aLine = null; 112 while ((aLine = bufferedReader.readLine()) != null) { // Not EOF: 113 aLine = aLine.replaceFirst("jmri.jmrit.ctc.ctcserialdata.", "jmri.jmrit.ctc.configurexml.Import"); 114 writeLine(bufferedWriter, aLine); 115 } 116 bufferedReader.close(); 117 bufferedWriter.close(); 118 if (!CTCFiles.deleteFile(fileName)) errors++; // Just delete it for safety before we start: 119 if (!CTCFiles.renameFile(temporaryFilename, fileName, false)) errors++; // Just delete it for safety before we start: 120 log.debug("convertClassNameReferences: errors = {}", errors); 121 } 122 123 static private void writeLine(BufferedWriter bufferedWriter, String aLine) throws IOException { 124 bufferedWriter.write(aLine); bufferedWriter.newLine(); 125 } 126 127 static void doDataLoading() { 128 loadOtherData(); 129 _mImportCodeButtonHandlerDataArrayList.forEach(imp -> { 130 loadCodeButtonHandlerData(imp); 131 }); 132 convertCallOnSensorNamesToNBHSensors(); 133 } 134 135 static void loadCodeButtonHandlerData(ImportCodeButtonHandlerData oldCBHD) { 136 log.debug("------------- Create CBHD ------------"); 137 int _mUniqueID = oldCBHD._mUniqueID; 138 int _mSwitchNumber = oldCBHD._mSwitchNumber; 139 int _mSignalEtcNumber = oldCBHD._mSignalEtcNumber; 140 int _mGUIColumnNumber = oldCBHD._mGUIColumnNumber; 141 142 // Create a new CodeButtonHandlerData via CodeButtonHandlerDataRoutines which sets default values and empty NBH... objects 143 CodeButtonHandlerData cbhd = CodeButtonHandlerDataRoutines.createNewCodeButtonHandlerData( 144 _mUniqueID, _mSwitchNumber, _mSignalEtcNumber, _mGUIColumnNumber, cm.getProgramProperties()); 145 cm.getCTCSerialData().addCodeButtonHandlerData(cbhd); 146 147 log.debug("------------- Code ------------"); 148 149 // Code section 150 cbhd._mCodeButtonInternalSensor = loadSensor(oldCBHD._mCodeButtonInternalSensor, true); 151 cbhd._mOSSectionOccupiedExternalSensor = loadSensor(oldCBHD._mOSSectionOccupiedExternalSensor, false); 152 cbhd._mOSSectionOccupiedExternalSensor2 = loadSensor(oldCBHD._mOSSectionOccupiedExternalSensor2, false); 153 cbhd._mOSSectionSwitchSlavedToUniqueID = oldCBHD._mOSSectionSwitchSlavedToUniqueID; 154 cbhd._mGUIGeneratedAtLeastOnceAlready = oldCBHD._mGUIGeneratedAtLeastOnceAlready; 155 cbhd._mCodeButtonDelayTime = oldCBHD._mCodeButtonDelayTime; 156 157 log.debug("------------- SIDI ------------"); 158 159 // SIDI section 160 cbhd._mSIDI_Enabled = oldCBHD._mSIDI_Enabled; 161 cbhd._mSIDI_LeftInternalSensor = loadSensor(oldCBHD._mSIDI_LeftInternalSensor, true); 162 cbhd._mSIDI_NormalInternalSensor = loadSensor(oldCBHD._mSIDI_NormalInternalSensor, true); 163 cbhd._mSIDI_RightInternalSensor = loadSensor(oldCBHD._mSIDI_RightInternalSensor, true); 164 cbhd._mSIDI_CodingTimeInMilliseconds = oldCBHD._mSIDI_CodingTimeInMilliseconds; 165 cbhd._mSIDI_TimeLockingTimeInMilliseconds = oldCBHD._mSIDI_TimeLockingTimeInMilliseconds; 166 cbhd._mSIDI_LeftRightTrafficSignals = getSignalList(oldCBHD._mSIDI_LeftRightTrafficSignalsCSVList); 167 cbhd._mSIDI_RightLeftTrafficSignals = getSignalList(oldCBHD._mSIDI_RightLeftTrafficSignalsCSVList); 168 169 // Set the traffic direction based on indicator sensors. 170 String trafficDirection = "BOTH"; 171 if (oldCBHD._mSIDI_LeftInternalSensor.isEmpty() && !oldCBHD._mSIDI_RightInternalSensor.isEmpty()) { 172 trafficDirection = "RIGHT"; 173 } else if (!oldCBHD._mSIDI_LeftInternalSensor.isEmpty() && oldCBHD._mSIDI_RightInternalSensor.isEmpty()) { 174 trafficDirection = "LEFT"; 175 } 176 cbhd._mSIDI_TrafficDirection = CodeButtonHandlerData.TRAFFIC_DIRECTION.valueOf(trafficDirection); 177 178 log.debug("------------- SIDL ------------"); 179 // SIDL section 180 cbhd._mSIDL_Enabled = oldCBHD._mSIDL_Enabled; 181 cbhd._mSIDL_LeftInternalSensor = loadSensor(oldCBHD._mSIDL_LeftInternalSensor, true); 182 cbhd._mSIDL_NormalInternalSensor = loadSensor(oldCBHD._mSIDL_NormalInternalSensor, true); 183 cbhd._mSIDL_RightInternalSensor = loadSensor(oldCBHD._mSIDL_RightInternalSensor, true); 184 185 log.debug("------------- SWDI ------------"); 186 // SWDI section 187 cbhd._mSWDI_Enabled = oldCBHD._mSWDI_Enabled; 188 cbhd._mSWDI_NormalInternalSensor = loadSensor(oldCBHD._mSWDI_NormalInternalSensor, true); 189 cbhd._mSWDI_ReversedInternalSensor = loadSensor(oldCBHD._mSWDI_ReversedInternalSensor, true); 190 cbhd._mSWDI_FeedbackDifferent = oldCBHD._mSWDI_FeedbackDifferent; 191 cbhd._mSWDI_ExternalTurnout = loadTurnout(oldCBHD._mSWDI_ExternalTurnout, oldCBHD._mSWDI_FeedbackDifferent); 192 cbhd._mSWDI_CodingTimeInMilliseconds = oldCBHD._mSWDI_CodingTimeInMilliseconds; 193 cbhd._mSWDI_GUITurnoutType = CodeButtonHandlerData.TURNOUT_TYPE.valueOf(oldCBHD._mSWDI_GUITurnoutType.toString()); 194 cbhd._mSWDI_GUITurnoutLeftHand = oldCBHD._mSWDI_GUITurnoutLeftHand; 195 cbhd._mSWDI_GUICrossoverLeftHand = oldCBHD._mSWDI_GUICrossoverLeftHand; 196 197 log.debug("------------- SWDL ------------"); 198 // SWDL section 199 cbhd._mSWDL_Enabled = oldCBHD._mSWDL_Enabled; 200 cbhd._mSWDL_InternalSensor = loadSensor(oldCBHD._mSWDL_InternalSensor, true); 201 202 log.debug("------------- CO ------------"); 203 // CO section 204 cbhd._mCO_Enabled = oldCBHD._mCO_Enabled; 205 cbhd._mCO_CallOnToggleInternalSensor = loadSensor(oldCBHD._mCO_CallOnToggleInternalSensor, true); 206 cbhd._mCO_GroupingsList = getCallOnList(oldCBHD._mCO_GroupingsListString); 207 208 log.debug("------------- TRL ------------"); 209 // TRL section 210 cbhd._mTRL_Enabled = oldCBHD._mTRL_Enabled; 211 cbhd._mTRL_LeftTrafficLockingRules = getTrafficLocking(oldCBHD._mTRL_LeftTrafficLockingRulesSSVList); 212 cbhd._mTRL_RightTrafficLockingRules = getTrafficLocking(oldCBHD._mTRL_RightTrafficLockingRulesSSVList); 213 214 log.debug("------------- TUL ------------"); 215 // TUL section 216 cbhd._mTUL_Enabled = oldCBHD._mTUL_Enabled; 217 cbhd._mTUL_DispatcherInternalSensorLockToggle = loadSensor(oldCBHD._mTUL_DispatcherInternalSensorLockToggle, true); 218 cbhd._mTUL_ExternalTurnoutFeedbackDifferent = oldCBHD._mTUL_ExternalTurnoutFeedbackDifferent; 219 cbhd._mTUL_ExternalTurnout = loadTurnout(oldCBHD._mTUL_ExternalTurnout, oldCBHD._mTUL_ExternalTurnoutFeedbackDifferent); 220 cbhd._mTUL_DispatcherInternalSensorUnlockedIndicator = loadSensor(oldCBHD._mTUL_DispatcherInternalSensorUnlockedIndicator, true); 221 cbhd._mTUL_NoDispatcherControlOfSwitch = oldCBHD._mTUL_NoDispatcherControlOfSwitch; 222 cbhd._mTUL_ndcos_WhenLockedSwitchStateIsClosed = oldCBHD._mTUL_ndcos_WhenLockedSwitchStateIsClosed; 223 224 // Use the lock toggle to set the GUI icons boolean 225 cbhd._mTUL_GUI_IconsEnabled = cbhd._mTUL_DispatcherInternalSensorLockToggle.valid() ? true : false; 226 227 cbhd._mTUL_LockImplementation = CodeButtonHandlerData.LOCK_IMPLEMENTATION.valueOf(oldCBHD._mTUL_LockImplementation.toString()); 228 229 cbhd._mTUL_AdditionalExternalTurnout1 = loadTurnout(oldCBHD._mTUL_AdditionalExternalTurnout1, oldCBHD._mTUL_AdditionalExternalTurnout1FeedbackDifferent); 230 cbhd._mTUL_AdditionalExternalTurnout2 = loadTurnout(oldCBHD._mTUL_AdditionalExternalTurnout2, oldCBHD._mTUL_AdditionalExternalTurnout2FeedbackDifferent); 231 cbhd._mTUL_AdditionalExternalTurnout3 = loadTurnout(oldCBHD._mTUL_AdditionalExternalTurnout3, oldCBHD._mTUL_AdditionalExternalTurnout3FeedbackDifferent); 232 233 cbhd._mTUL_AdditionalExternalTurnout1FeedbackDifferent = oldCBHD._mTUL_AdditionalExternalTurnout1FeedbackDifferent; 234 cbhd._mTUL_AdditionalExternalTurnout2FeedbackDifferent = oldCBHD._mTUL_AdditionalExternalTurnout2FeedbackDifferent; 235 cbhd._mTUL_AdditionalExternalTurnout3FeedbackDifferent = oldCBHD._mTUL_AdditionalExternalTurnout3FeedbackDifferent; 236 237 log.debug("------------- IL ------------"); 238 // IL section 239 cbhd._mIL_Enabled = oldCBHD._mIL_Enabled; 240 cbhd._mIL_Signals = getSignalList(oldCBHD._mIL_ListOfCSVSignalNames); 241 242// Debugging aid -- not active due to SpotBugs 243// log.info("CodeButtonHandlerData, {}/{}:", _mSwitchNumber, _mSignalEtcNumber); 244// List<Field> fields = Arrays.asList(CodeButtonHandlerData.class.getFields()); 245// fields.forEach(field -> { 246// try { 247// log.info(" CBHD: fld = {}, type = {}, val = {}", field.getName(), field.getType(), field.get(cbhd)); 248// } catch (Exception ex) { 249// log.info(" CBHD list exception: {}", ex.getMessage()); 250// } 251// }); 252 } 253 254 /** 255 * Load the OtherData class. 256 */ 257 static void loadOtherData() { 258 OtherData od = cm.getOtherData(); 259 260// Fleeting: 261 od._mFleetingToggleInternalSensor = loadSensor(_mImportOtherData._mFleetingToggleInternalSensor, true); 262 od._mDefaultFleetingEnabled = _mImportOtherData._mDefaultFleetingEnabled; 263 264// Global startup: 265 od._mTUL_EnabledAtStartup = _mImportOtherData._mTUL_EnabledAtStartup; 266 od._mSignalSystemType = OtherData.SIGNAL_SYSTEM_TYPE.valueOf(_mImportOtherData._mSignalSystemType.toString()); 267 od._mTUL_SecondsToLockTurnouts = _mImportOtherData._mTUL_SecondsToLockTurnouts; 268 269// Next unique # for each created Column: 270 od._mNextUniqueNumber = _mImportOtherData._mNextUniqueNumber; 271 272// CTC Debugging: 273 od._mCTCDebugSystemReloadInternalSensor = loadSensor(_mImportOtherData._mCTCDebugSystemReloadInternalSensor, true); 274 od._mCTCDebug_TrafficLockingRuleTriggeredDisplayInternalSensor = loadSensor(_mImportOtherData._mCTCDebug_TrafficLockingRuleTriggeredDisplayInternalSensor, true); 275 276// GUI design: 277 od._mGUIDesign_NumberOfEmptyColumnsAtEnd = _mImportOtherData._mGUIDesign_NumberOfEmptyColumnsAtEnd ; 278 od._mGUIDesign_CTCPanelType = OtherData.CTC_PANEL_TYPE.valueOf(_mImportOtherData._mGUIDesign_CTCPanelType.toString()); 279 od._mGUIDesign_BuilderPlate = _mImportOtherData._mGUIDesign_BuilderPlate ; 280 od._mGUIDesign_SignalsOnPanel = OtherData.SIGNALS_ON_PANEL.valueOf(_mImportOtherData._mGUIDesign_SignalsOnPanel.toString()); 281 od._mGUIDesign_FleetingToggleSwitch = _mImportOtherData._mGUIDesign_FleetingToggleSwitch ; 282 od._mGUIDesign_AnalogClockEtc = _mImportOtherData._mGUIDesign_AnalogClockEtc ; 283 od._mGUIDesign_ReloadCTCSystemButton = _mImportOtherData._mGUIDesign_ReloadCTCSystemButton ; 284 od._mGUIDesign_CTCDebugOnToggle = _mImportOtherData._mGUIDesign_CTCDebugOnToggle ; 285 od._mGUIDesign_CreateTrackPieces = _mImportOtherData._mGUIDesign_CreateTrackPieces ; 286 od._mGUIDesign_VerticalSize = OtherData.VERTICAL_SIZE.valueOf(_mImportOtherData._mGUIDesign_VerticalSize.toString()); 287 od._mGUIDesign_OSSectionUnknownInconsistentRedBlink = _mImportOtherData._mGUIDesign_OSSectionUnknownInconsistentRedBlink ; 288 od._mGUIDesign_TurnoutsOnPanel = _mImportOtherData._mGUIDesign_TurnoutsOnPanel ; 289 290// Debugging aid -- not active due to SpotBugs 291// log.info("OtherData:"); 292// List<Field> fields = Arrays.asList(ImportOtherData.class.getFields()); 293// fields.forEach(field -> { 294// try { 295// log.info(" OtherData: fld = {}, type = {}, val = {}", field.getName(), field.getType(), field.get(_mImportOtherData)); 296// } catch (Exception ex) { 297// log.info(" OtherData list exception: {}", ex.getMessage()); 298// } 299// }); 300 } 301 302 // **** Load simple objects **** 303 304// static String loadString(String value) { 305// String newString = null; 306// if (value != null) { 307// newString = value; 308// } 309// return newString; 310// } 311 312 static int loadInt(String value) { 313 int newInt = 0; 314 if (value != null) { 315 try { 316 newInt = Integer.parseInt(value); 317 } catch (NumberFormatException ex) { 318 log.warn("loadInt format exception: value = {}", value); 319 } 320 } 321 return newInt; 322 } 323 324// static boolean loadBoolean(String value) { 325// boolean newBoolean = false; 326// if (value != null) { 327// newBoolean = value.equals("true") ? true : false; 328// } 329// return newBoolean; 330// } 331 332 static NBHSensor loadSensor(String value, boolean isInternal) { 333 NBHSensor sensor = null; 334 if (value != null && !value.isEmpty()) { 335 String sensorName = value; 336 sensor = cm.getNBHSensor(sensorName); 337 if (sensor == null) { 338 if (isInternal) { 339 sensor = new NBHSensor("CtcManagerXml", "create internal = ", sensorName, sensorName); 340 } else { 341 sensor = new NBHSensor("CtcManagerXml", "create standard = ", sensorName, sensorName, false); 342 } 343 } 344 } else { 345 sensor = new NBHSensor("CtcManagerXml", "", "Empty NBHSensor", "", true); 346 } 347 return sensor; 348 } 349 350 static NBHSignal loadSignal(String signalName) { 351 NBHSignal signal = null; 352 if (signalName != null && !signalName.isEmpty()) { 353 signal = cm.getNBHSignal(signalName); 354 if (signal == null) { 355 signal = new NBHSignal(signalName); 356 } 357 } else { 358 signal = new NBHSignal(""); 359 } 360 return signal; 361 } 362 363 static NBHTurnout loadTurnout(String value, boolean feedback) { 364 NBHTurnout turnout = null; 365 if (value != null && !value.isEmpty()) { 366 String turnoutName = value; 367 368 turnout = cm.getNBHTurnout(turnoutName); 369 if (turnout == null) { 370 turnout = new NBHTurnout("CtcManagerXml", "", value, value, feedback); 371 } 372 } else { 373 turnout = new NBHTurnout("CtcManagerXml", "Empty NBHTurnout", ""); 374 } 375 return turnout; 376 } 377 378 static NamedBeanHandle<Block> loadBlock(String value) { 379 NamedBeanHandle<Block> blockHandle = null; 380 if (value != null && !value.isEmpty()) { 381 blockHandle = cm.getBlock(value); 382 if (blockHandle == null) { 383 Block block = InstanceManager.getDefault(BlockManager.class).getBlock(value); 384 if (block != null) { 385 blockHandle = InstanceManager.getDefault(NamedBeanHandleManager.class).getNamedBeanHandle(value, block); 386 cm.putBlock(value, blockHandle); 387 } 388 } 389 } 390 return blockHandle; 391 } 392 393 // **** Load ArrayList objects **** 394 395 static ArrayList<NBHSignal> getSignalList(String value) { 396 ArrayList<NBHSignal> signalList = new ArrayList<>(); 397 if (value != null) { 398 for (String signalName : ProjectsCommonSubs.getArrayListFromCSV(value)) { 399 NBHSignal signal = loadSignal(signalName); 400 signalList.add(signal); 401 } 402 } 403 return signalList; 404 } 405 406 static ArrayList<CallOnData> getCallOnList(String value) { 407 ArrayList<CallOnData> callOnList = new ArrayList<>(); 408 for (String csvString : ProjectsCommonSubs.getArrayListFromSSV(value)) { 409 CallOnData cod = new CallOnData(); 410 411 CallOnEntry entry = new CallOnEntry(csvString); 412 cod._mExternalSignal = loadSignal(entry._mExternalSignal); 413 cod._mSignalFacingDirection = entry._mSignalFacingDirection; 414 cod._mSignalAspectToDisplay = entry._mSignalAspectToDisplay; 415 cod._mCalledOnExternalSensor = loadSensor(entry._mCalledOnExternalSensor, false); 416 cod._mExternalBlock = loadBlock(entry._mExternalBlock); 417 418 cod._mSwitchIndicators = new ArrayList<>(); 419 cod._mSwitchIndicatorNames = getCallOnSensorNames(entry); 420 421 callOnList.add(cod); 422 } 423 return callOnList; 424 } 425 426 static ArrayList<String> getCallOnSensorNames(CallOnEntry entry) { 427 ArrayList<String> sensorList = new ArrayList<>(); 428 if (!entry._mSwitchIndicator1.isEmpty()) sensorList.add(entry._mSwitchIndicator1); 429 if (!entry._mSwitchIndicator2.isEmpty()) sensorList.add(entry._mSwitchIndicator2); 430 if (!entry._mSwitchIndicator3.isEmpty()) sensorList.add(entry._mSwitchIndicator3); 431 if (!entry._mSwitchIndicator4.isEmpty()) sensorList.add(entry._mSwitchIndicator4); 432 if (!entry._mSwitchIndicator5.isEmpty()) sensorList.add(entry._mSwitchIndicator5); 433 if (!entry._mSwitchIndicator6.isEmpty()) sensorList.add(entry._mSwitchIndicator6); 434 return sensorList; 435 } 436 437 static void convertCallOnSensorNamesToNBHSensors() { 438 for (CodeButtonHandlerData cbhd : cm.getCTCSerialData().getCodeButtonHandlerDataArrayList()) { 439 for (CallOnData cod : cbhd._mCO_GroupingsList) { 440 for (String sensorName : cod._mSwitchIndicatorNames) { 441 NBHSensor sensor = cm.getNBHSensor(sensorName); 442 if (sensor != null) { 443 cod._mSwitchIndicators.add(sensor); 444 } 445 } 446 } 447 } 448 } 449 450 static ArrayList<TrafficLockingData> getTrafficLocking(String value) { 451 ArrayList<TrafficLockingData> trlData = new ArrayList<>(); 452 for (String csvString : ProjectsCommonSubs.getArrayListFromSSV(value)) { 453 TrafficLockingData trl = new TrafficLockingData(); 454 455 TrafficLockingEntry entry = new TrafficLockingEntry(csvString); 456 trl._mUserRuleNumber = entry._mUserRuleNumber; 457 trl._mRuleEnabled = entry._mRuleEnabled; 458 trl._mDestinationSignalOrComment = entry._mDestinationSignalOrComment; 459 460 trl._mSwitchAlignments = getTRLSwitchList(entry); 461 462 trl._mOccupancyExternalSensors = getTRLSensorList(entry, true); 463 trl._mOptionalExternalSensors = getTRLSensorList(entry, false); 464 465 trlData.add(trl); 466 } 467 return trlData; 468 } 469 470 static ArrayList<TrafficLockingData.TRLSwitch> getTRLSwitchList(TrafficLockingEntry entry) { 471 ArrayList<TrafficLockingData.TRLSwitch> trlSwitches = new ArrayList<>(); 472 if (!entry._mUserText1.isEmpty()) trlSwitches.add(createTRLSwitch(entry._mUserText1, entry._mSwitchAlignment1, entry._mUniqueID1)); 473 if (!entry._mUserText2.isEmpty()) trlSwitches.add(createTRLSwitch(entry._mUserText2, entry._mSwitchAlignment2, entry._mUniqueID2)); 474 if (!entry._mUserText3.isEmpty()) trlSwitches.add(createTRLSwitch(entry._mUserText3, entry._mSwitchAlignment3, entry._mUniqueID3)); 475 if (!entry._mUserText4.isEmpty()) trlSwitches.add(createTRLSwitch(entry._mUserText4, entry._mSwitchAlignment4, entry._mUniqueID4)); 476 if (!entry._mUserText5.isEmpty()) trlSwitches.add(createTRLSwitch(entry._mUserText5, entry._mSwitchAlignment5, entry._mUniqueID5)); 477 return trlSwitches; 478 } 479 480 static TrafficLockingData.TRLSwitch createTRLSwitch(String text, String alignment, String id) { 481 return new TrafficLockingData.TRLSwitch(text, alignment, loadInt(id)); 482 } 483 484 static ArrayList<NBHSensor> getTRLSensorList(TrafficLockingEntry entry, boolean occupancy) { 485 ArrayList<NBHSensor> sensorList = new ArrayList<>(); 486 if (occupancy) { 487 if (!entry._mOccupancyExternalSensor1.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor1, false)); 488 if (!entry._mOccupancyExternalSensor2.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor2, false)); 489 if (!entry._mOccupancyExternalSensor3.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor3, false)); 490 if (!entry._mOccupancyExternalSensor4.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor4, false)); 491 if (!entry._mOccupancyExternalSensor5.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor5, false)); 492 if (!entry._mOccupancyExternalSensor6.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor6, false)); 493 if (!entry._mOccupancyExternalSensor7.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor7, false)); 494 if (!entry._mOccupancyExternalSensor8.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor8, false)); 495 if (!entry._mOccupancyExternalSensor9.isEmpty()) sensorList.add(loadSensor(entry._mOccupancyExternalSensor9, false)); 496 } else { 497 if (!entry._mOptionalExternalSensor1.isEmpty()) sensorList.add(loadSensor(entry._mOptionalExternalSensor1, false)); 498 if (!entry._mOptionalExternalSensor2.isEmpty()) sensorList.add(loadSensor(entry._mOptionalExternalSensor2, false)); 499 } 500 return sensorList; 501 } 502 503 private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(ImportExternalData.class); 504}