001package jmri.jmrit.whereused; 002 003import jmri.jmrit.blockboss.BlockBossLogicProvider; 004import jmri.jmrit.display.EditorManager; 005 006import java.util.Collections; 007import java.util.Enumeration; 008 009import jmri.*; 010import jmri.jmrit.blockboss.BlockBossLogic; 011import jmri.jmrit.ctc.CtcManager; 012import jmri.jmrit.display.switchboardEditor.SwitchboardEditor; 013import jmri.jmrit.entryexit.EntryExitPairs; 014import jmri.jmrit.logix.OBlockManager; 015import jmri.jmrit.logix.WarrantManager; 016import jmri.jmrit.logixng.LogixNG_Manager; 017import jmri.jmrit.logixng.ModuleManager; 018import jmri.jmrit.display.layoutEditor.LayoutBlockManager; 019/** 020 * Find references. Each collector method calls a corresponding getUsageReport(NamedBean) 021 * in the main implementation class for the object type. The matches are returned in an 022 * array list of NamedBeanUsageReport objects. 023 * 024 * Collectors: 025 * <ul> 026 * <li>checkAudio</li> 027 * <li>checkTurnouts</li> 028 * <li>checkLights</li> 029 * <li>checkRoutes</li> 030 * <li>checkBlocks</li> 031 * <li>checkLayoutBlocks</li> 032 * <li>checkSignalHeadLogic</li> 033 * <li>checkSignalMastLogic</li> 034 * <li>checkSignalGroups</li> 035 * <li>checkSignalHeads</li> 036 * <li>checkSignalMasts</li> 037 * <li>checkOBlocks</li> 038 * <li>checkWarrants</li> 039 * <li>checkEntryExit</li> 040 * <li>checkLogixConditionals</li> 041 * <li>checkLogixNGConditionals</li> 042 * <li>checkSections</li> 043 * <li>checkTransits</li> 044 * <li>checkPanels</li> 045 * <li>checkCTC</li> 046 * </ul> 047 * 048 * @author Dave Sand Copyright (C) 2020 049 */ 050 051public class WhereUsedCollectors { 052 053 /** 054 * Create the Audio usage string. 055 * Usage keys: 056 * <ul> 057 * <li>AudioBuffer</li> 058 * </ul> 059 * @param bean The requesting bean: Audio. 060 * @return usage string 061 */ 062 static String checkAudio(NamedBean bean) { 063 StringBuilder sb = new StringBuilder(); 064 InstanceManager.getDefault(AudioManager.class).getNamedBeanSet().forEach((audio) -> audio.getUsageReport(bean).forEach((report) -> { 065 if (report.usageKey.startsWith("Audio")) { // NOI18N 066 String name = audio.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 067 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 068 } 069 })); 070 return addHeader(sb, "ReferenceAudio"); // NOI18N 071 } 072 073 /** 074 * Create the Turnout usage string. 075 * Usage keys: 076 * <ul> 077 * <li>TurnoutFeedback1</li> 078 * <li>TurnoutFeedback2</li> 079 * </ul> 080 * @param bean The requesting bean: Sensor. 081 * @return usage string 082 */ 083 static String checkTurnouts(NamedBean bean) { 084 StringBuilder sb = new StringBuilder(); 085 InstanceManager.getDefault(TurnoutManager.class).getNamedBeanSet().forEach((turnout) -> { 086 int feedback = turnout.getFeedbackMode(); 087 if (feedback == Turnout.ONESENSOR || feedback == Turnout.TWOSENSOR) { 088 turnout.getUsageReport(bean).forEach((report) -> { 089 if (report.usageKey.startsWith("TurnoutFeedback")) { // NOI18N 090 String name = turnout.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 091 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 092 } 093 }); 094 } 095 }); 096 return addHeader(sb, "ReferenceFeedback"); // NOI18N 097 } 098 099 /** 100 * Create the Light usage string. 101 * Usage keys: 102 * <ul> 103 * <li>LightControlSensor1</li> 104 * <li>LightControlSensor2</li> 105 * <li>LightControlSensorTimed</li> 106 * <li>LightControlTurnout</li> 107 * </ul> 108 * @param bean The requesting bean: Sensor, Turnout. 109 * @return usage string 110 */ 111 static String checkLights(NamedBean bean) { 112 StringBuilder sb = new StringBuilder(); 113 InstanceManager.getDefault(LightManager.class).getNamedBeanSet().forEach((light) -> light.getUsageReport(bean).forEach((report) -> { 114 if (report.usageKey.startsWith("LightControl")) { // NOI18N 115 String name = light.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 116 sb.append(Bundle.getMessage("ReferenceLineData", name, report.usageData)); // NOI18N 117 } 118 })); 119 return addHeader(sb, "ReferenceLightControl"); // NOI18N 120 } 121 122 /** 123 * Create the Route usage string. 124 * Usage keys: 125 * <ul> 126 * <li>RouteTurnoutOutput</li> 127 * <li>RouteSensorOutput</li> 128 * <li>RouteSensorControl</li> 129 * <li>RouteSensorAligned</li> 130 * <li>RouteTurnoutControl</li> 131 * <li>RouteTurnoutLock</li> 132 * </ul> 133 * @param bean The requesting bean: Sensor, Turnout. 134 * @return usage string 135 */ 136 static String checkRoutes(NamedBean bean) { 137 StringBuilder sb = new StringBuilder(); 138 InstanceManager.getDefault(RouteManager.class).getNamedBeanSet().forEach((route) -> route.getUsageReport(bean).forEach((report) -> { 139 if (report.usageKey.startsWith("Route")) { // NOI18N 140 String name = route.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 141 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 142 } 143 })); 144 return addHeader(sb, "ReferenceRoutes"); // NOI18N 145 } 146 147 /** 148 * Create the Block usage string. 149 * Usage keys: 150 * <ul> 151 * <li>BlockSensor</li> 152 * <li>BlockReporter</li> 153 * <li>BlockPathNeighbor</li> 154 * <li>BlockPathTurnout</li> 155 * </ul> 156 * @param bean The requesting bean: Block (Path neighbor), Sensor, Reporter, Turnout (Path). 157 * @return usage string 158 */ 159 static String checkBlocks(NamedBean bean) { 160 StringBuilder sb = new StringBuilder(); 161 InstanceManager.getDefault(BlockManager.class).getNamedBeanSet().forEach((block) -> block.getUsageReport(bean).forEach((report) -> { 162 if (report.usageKey.startsWith("Block")) { // NOI18N 163 String name = block.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 164 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 165 } 166 })); 167 return addHeader(sb, "ReferenceBlock"); // NOI18N 168 } 169 170 /** 171 * Create the LayoutBlock usage string. 172 * Usage keys: 173 * <ul> 174 * <li>LayoutBlockBlock</li> 175 * <li>LayoutBlockMemory</li> 176 * <li>LayoutBlockSensor</li> 177 * <li>LayoutBlockNeighbor</li> 178 * </ul> 179 * @param bean The requesting bean: Block, Memory, Sensor. 180 * @return usage string 181 */ 182 static String checkLayoutBlocks(NamedBean bean) { 183 StringBuilder sb = new StringBuilder(); 184 InstanceManager.getDefault(LayoutBlockManager.class).getNamedBeanSet().forEach((layoutBlock) -> layoutBlock.getUsageReport(bean).forEach((report) -> { 185 if (report.usageKey.startsWith("LayoutBlock")) { // NOI18N 186 String name = layoutBlock.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 187 sb.append(Bundle.getMessage("ReferenceLineData", name, report.usageData)); // NOI18N 188 } 189 })); 190 return addHeader(sb, "ReferenceLayoutBlock"); // NOI18N 191 } 192 193 /** 194 * Create the Signal Head Logic usage string. 195 * Usage keys: 196 * <ul> 197 * <li>SSLSignal</li> 198 * <li>SSLSensor1-5</li> 199 * <li>SSLTurnout</li> 200 * <li>SSLSignal1</li> 201 * <li>SSLSignal1Alt</li> 202 * <li>SSLSignal2</li> 203 * <li>SSLSignal2Alt</li> 204 * <li>SSLSensorWatched1</li> 205 * <li>SSLSensorWatched1Alt</li> 206 * <li>SSLSensorWatched2</li> 207 * <li>SSLSensorWatched2Alt</li> 208 * <li>SSLSensorApproach</li> 209 * </ul> 210 * @param bean The requesting bean: Sensor, Signal Head, Turnout. 211 * @return usage string 212 */ 213 static String checkSignalHeadLogic(NamedBean bean) { 214 StringBuilder sb = new StringBuilder(); 215 Enumeration<BlockBossLogic> e = Collections.enumeration(InstanceManager.getDefault(BlockBossLogicProvider.class).provideAll()); 216 while (e.hasMoreElements()) { 217 BlockBossLogic ssl = e.nextElement(); 218 ssl.getUsageReport(bean).forEach((report) -> { 219 if (report.usageKey.startsWith("SSL")) { // NOI18N 220 String name = report.usageBean.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 221 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 222 } 223 }); 224 } 225 return addHeader(sb, "ReferenceHeadSSL"); // NOI18N 226 } 227 228 /** 229 * Create the Signal Mast Logic usage string. 230 * Usage keys: 231 * <ul> 232 * <li>SMLSourceMast</li> 233 * <li>SMLDestinationMast</li> 234 * <li>SMLBlockAuto</li> 235 * <li>SMLBlockUser</li> 236 * <li>SMLTurnoutAuto</li> 237 * <li>SMLTurnoutUser</li> 238 * <li>SMLSensor</li> 239 * <li>SMLMastAuto</li> 240 * <li>SMLMastUser</li> 241 * </ul> 242 * @param bean The requesting bean: Block, Turnout, Sensor, Signal Mast. 243 * @return usage string 244 */ 245 static String checkSignalMastLogic(NamedBean bean) { 246 StringBuilder sb = new StringBuilder(); 247 InstanceManager.getDefault(SignalMastLogicManager.class).getNamedBeanSet().forEach((sml) -> sml.getUsageReport(bean).forEach((report) -> { 248 String name = bean.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 249 if (report.usageKey.startsWith("SMLSource")) { // NOI18N 250 sb.append(Bundle.getMessage("ReferenceLineData", name, Bundle.getMessage("SourceMast"))); // NOI18N 251 return; 252 } 253 if (report.usageKey.startsWith("SMLDest")) { // NOI18N 254 sb.append(Bundle.getMessage("ReferenceLineData", name, Bundle.getMessage("DestMast"))); // NOI18N 255 return; 256 } 257 if (report.usageKey.startsWith("SML")) { // NOI18N 258 sb.append(Bundle.getMessage("ReferenceLinePair", sml.getSourceMast().getDisplayName(), report.usageBean.getDisplayName())); // NOI18N 259 } 260 })); 261 return addHeader(sb, "ReferenceMastSML"); // NOI18N 262 } 263 264 /** 265 * Create the Signal Group usage string. 266 * Usage keys: 267 * <ul> 268 * <li>SignalGroupMast</li> 269 * <li>SignalGroupHead</li> 270 * <li>SignalGroupHeadSensor</li> 271 * <li>SignalGroupHeadTurnout</li> 272 * </ul> 273 * @param bean The requesting bean: Sensor, Signal Head, Signal Mast, Turnout. 274 * @return usage string 275 */ 276 static String checkSignalGroups(NamedBean bean) { 277 StringBuilder sb = new StringBuilder(); 278 InstanceManager.getDefault(SignalGroupManager.class).getNamedBeanSet().forEach((group) -> group.getUsageReport(bean).forEach((report) -> { 279 if (report.usageKey.startsWith("SignalGroup")) { // NOI18N 280 String name = group.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 281 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 282 } 283 })); 284 return addHeader(sb, "ReferenceSignalGroup"); // NOI18N 285 } 286 287 /** 288 * Create the Signal Head usage string. 289 * Usage keys: 290 * <ul> 291 * <li>SignalHeadTurnout</li> 292 * </ul> 293 * @param bean The requesting bean: Turnout. 294 * @return usage string 295 */ 296 static String checkSignalHeads(NamedBean bean) { 297 StringBuilder sb = new StringBuilder(); 298 InstanceManager.getDefault(SignalHeadManager.class).getNamedBeanSet().forEach((head) -> head.getUsageReport(bean).forEach((report) -> { 299 if (report.usageKey.startsWith("SignalHead")) { // NOI18N 300 String name = head.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 301 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 302 } 303 })); 304 return addHeader(sb, "ReferenceSignalHead"); // NOI18N 305 } 306 307 /** 308 * Create the Signal Mast usage string. 309 * Usage keys: 310 * <ul> 311 * <li>SignalMastTurnout</li> 312 * <li>SignalMastSignalHead</li> 313 * </ul> 314 * @param bean The requesting bean: Signal Head, Turnout. 315 * @return usage string 316 */ 317 static String checkSignalMasts(NamedBean bean) { 318 StringBuilder sb = new StringBuilder(); 319 InstanceManager.getDefault(SignalMastManager.class).getNamedBeanSet().forEach((mast) -> mast.getUsageReport(bean).forEach((report) -> { 320 if (report.usageKey.startsWith("SignalMast")) { // NOI18N 321 String name = mast.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 322 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 323 } 324 })); 325 return addHeader(sb, "ReferenceSignalMast"); // NOI18N 326 } 327 328 /** 329 * Create the OBlock usage string. 330 * Usage keys: 331 * <ul> 332 * <li>OBlockSensor</li> 333 * <li>OBlockSensorError</li> 334 * <li>OBlockPortalNeighborOBlock</li> 335 * <li>OBlockPortalSignal</li> 336 * <li>OBlockPortalPathTurnout</li> 337 * <li>OBlockWarrant</li> 338 * </ul> 339 * @param bean The requesting bean: OBlock (Neightbor), Sensor, SignalHead, SignalMast, Turnout, Warrant. 340 * @return usage string 341 */ 342 static String checkOBlocks(NamedBean bean) { 343 StringBuilder sb = new StringBuilder(); 344 InstanceManager.getDefault(OBlockManager.class).getNamedBeanSet().forEach((oblock) -> oblock.getUsageReport(bean).forEach((report) -> { 345 if (report.usageKey.startsWith("OBlock")) { // NOI18N 346 String name = oblock.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 347 sb.append(Bundle.getMessage("ReferenceLineData", name, report.usageData)); // NOI18N 348 } 349 })); 350 return addHeader(sb, "ReferenceOBlock"); // NOI18N 351 } 352 353 /** 354 * Create the Warrant usage string. 355 * Usage keys: 356 * <ul> 357 * <li>WarrantBlocking</li> 358 * <li>WarrantBlock</li> 359 * <li>WarrantSignal</li> 360 * </ul> 361 * @param bean The requesting bean: OBlock SignalHead, SignalMast, Warrant. 362 * @return usage string 363 */ 364 static String checkWarrants(NamedBean bean) { 365 StringBuilder sb = new StringBuilder(); 366 InstanceManager.getDefault(WarrantManager.class).getNamedBeanSet().forEach((warrant) -> warrant.getUsageReport(bean).forEach((report) -> { 367 if (report.usageKey.startsWith("Warrant")) { // NOI18N 368 String name = warrant.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 369 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 370 } 371 })); 372 return addHeader(sb, "ReferenceWarrant"); // NOI18N 373 } 374 375 /** 376 * Create the Entry/Exit usage string. 377 * Usage keys: 378 * <ul> 379 * <li>EntryExitSourceSensor</li> 380 * <li>EntryExitSourceSignal</li> 381 * <li>EntryExitDestinationSensor</li> 382 * <li>EntryExitDestinationSignal</li> 383 * </ul> 384 * @param bean The requesting bean: Sensor SignalHead, SignalMast. 385 * @return usage string 386 */ 387 static String checkEntryExit(NamedBean bean) { 388 StringBuilder sb = new StringBuilder(); 389 InstanceManager.getDefault(EntryExitPairs.class).getNamedBeanSet().forEach((destPoint) -> destPoint.getUsageReport(bean).forEach((report) -> { 390 if (report.usageKey.startsWith("EntryExit")) { // NOI18N 391 String name = destPoint.getDisplayName(); 392 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 393 } 394 })); 395 return addHeader(sb, "ReferenceEntryExit"); // NOI18N 396 } 397 398 /** 399 * Create the Logix/Conditional usage string. 400 * Usage keys: 401 * <ul> 402 * <li>ConditionalAction</li> 403 * <li>ConditionalVariable</li> 404 * <li>ConditionalVariableData</li> 405 * </ul> 406 * @param bean The requesting bean: Many. 407 * @return usage string 408 */ 409 static String checkLogixConditionals(NamedBean bean) { 410 StringBuilder sb = new StringBuilder(); 411 InstanceManager.getDefault(LogixManager.class).getNamedBeanSet().forEach((logix) -> logix.getUsageReport(bean).forEach((report) -> { 412 if (report.usageKey.startsWith("ConditionalVariable") || report.usageKey.startsWith("ConditionalAction")) { // NOI18N 413 String name = logix.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 414 String cdlName = report.usageBean.getDisplayName(); 415 sb.append(Bundle.getMessage("ReferenceLineConditional", name, cdlName, Bundle.getMessage(report.usageKey), report.usageData)); // NOI18N 416 } 417 })); 418 return addHeader(sb, "ReferenceConditionals"); // NOI18N 419 } 420 421 /** 422 * Create the LogixNG/ConditionalNG usage string. 423 * Usage keys: 424 * <ul> 425 * <li>LogixNGAction</li> 426 * <li>LogixNGExpression</li> 427 * </ul> 428 * @param bean The requesting bean: Many. 429 * @return usage string 430 */ 431 static String checkLogixNGConditionals(NamedBean bean) { 432 StringBuilder sb = new StringBuilder(); 433 InstanceManager.getDefault(LogixNG_Manager.class).getNamedBeanSet().forEach((logixng) -> logixng.getUsageReport(bean).forEach((report) -> { 434 if (report.usageKey.startsWith("LogixNG")) { // NOI18N 435 String name = logixng.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 436 String cdlName = report.usageBean != null ? report.usageBean.getDisplayName() : ""; 437 sb.append(Bundle.getMessage("ReferenceLineLogixNG", name, cdlName, Bundle.getMessage(report.usageKey), report.usageData)); // NOI18N 438 } 439 })); 440 InstanceManager.getDefault(ModuleManager.class).getNamedBeanSet().forEach((module) -> module.getUsageReport(bean).forEach((report) -> { 441 if (report.usageKey.startsWith("LogixNG")) { // NOI18N 442 String name = module.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 443 sb.append(Bundle.getMessage("ReferenceLineModule", name, Bundle.getMessage(report.usageKey), report.usageData)); // NOI18N 444 } 445 })); 446 return addHeader(sb, "ReferenceLogixNG"); // NOI18N 447 } 448 449 /** 450 * Create the Section usage string. 451 * Usage keys: 452 * <ul> 453 * <li>SectionBlock</li> 454 * <li>SectionSensorForwardBlocking</li> 455 * <li>SectionSensorForwardStopping</li> 456 * <li>SectionSensorReverseBlocking</li> 457 * <li>SectionSensorReverseStopping</li> 458 * </ul> 459 * @param bean The requesting bean: Block, Sensor. 460 * @return usage string 461 */ 462 static String checkSections(NamedBean bean) { 463 StringBuilder sb = new StringBuilder(); 464 InstanceManager.getDefault(SectionManager.class).getNamedBeanSet().forEach((section) -> section.getUsageReport(bean).forEach((report) -> { 465 if (report.usageKey.startsWith("SectionSensor")) { // NOI18N 466 String name = section.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 467 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 468 } 469 })); 470 return addHeader(sb, "ReferenceSections"); // NOI18N 471 } 472 473 /** 474 * Create the Transit usage string. 475 * Usage keys: 476 * <ul> 477 * <li>TransitSection</li> 478 * <li>TransitSensorStopAllocation</li> 479 * <li>TransitActionSensorWhen</li> 480 * <li>TransitActionSensorWhat</li> 481 * <li>TransitActionSignalHeadWhat</li> 482 * <li>TransitActionSignalMastWhat</li> 483 * </ul> 484 * @param bean The requesting bean: Section, Sensor, Signal Head, Signal Mast. 485 * @return usage string 486 */ 487 static String checkTransits(NamedBean bean) { 488 StringBuilder sb = new StringBuilder(); 489 InstanceManager.getDefault(TransitManager.class).getNamedBeanSet().forEach((transit) -> transit.getUsageReport(bean).forEach((report) -> { 490 String name = transit.getDisplayName(NamedBean.DisplayOptions.USERNAME_SYSTEMNAME); 491 if (report.usageKey.startsWith("TransitSensor") || report.usageKey.startsWith("TransitSection")) { // NOI18N 492 sb.append(Bundle.getMessage("ReferenceLineName", name)); // NOI18N 493 } 494 if (report.usageKey.startsWith("TransitAction")) { // NOI18N 495 sb.append(Bundle.getMessage("ReferenceLineAction", name, report.usageBean.getDisplayName())); // NOI18N 496 } 497 })); 498 return addHeader(sb, "ReferenceTransits"); // NOI18N 499 } 500 501 /** 502 * Create the Panel usage string. The string includes the icon class name. 503 * Usage keys: 504 * <ul> 505 * <li>PositionalIcon</li> 506 * <li>LayoutEditorTurnout</li> 507 * <li>LayoutEditorTurnout2</li> 508 * <li>LayoutEditorTurnoutBlock</li> 509 * <li>LayoutEditorTurnoutSensor</li> 510 * <li>LayoutEditorTurnoutSignalHead</li> 511 * <li>LayoutEditorTurnoutSignalMast</li> 512 * <li>LayoutEditorPointSensor</li> 513 * <li>LayoutEditorPointSignalHead</li> 514 * <li>LayoutEditorPointSignalMast</li> 515 * <li>LayoutEditorSegmentBlock</li> 516 * <li>LayoutEditorXingBlock</li> 517 * <li>LayoutEditorXingOther (sensor, head, mast)</li> 518 * <li>Switchboard (sensor, turnout, light)</li> 519 * </ul> 520 * Note: The getUsageReport is invoked at either Editor or LayoutEditor depending on the 521 * panel type. The LayoutEditor version does a super call and then does special turnout 522 * checking since LE turnouts are not icons. 523 * @param bean The requesting bean: Many. 524 * @return usage string 525 */ 526 static String checkPanels(NamedBean bean) { 527 StringBuilder sb = new StringBuilder(); 528 InstanceManager.getDefault(EditorManager.class).getAll().forEach(panel -> 529 panel.getUsageReport(bean).forEach(report -> { 530 if (panel instanceof SwitchboardEditor) { 531 sb.append(Bundle.getMessage("ReferenceLineName", report.usageData)); // NOI18N 532 } else { 533 sb.append(Bundle.getMessage("ReferenceLinePanel", panel.getTitle(), report.usageData)); // NOI18N 534 } 535 })); 536 return addHeader(sb, "ReferencePanels"); // NOI18N 537 } 538 539 /** 540 * Create the CTC usage string. 541 * The CTC manager is found using the ConfigureManager instead of the InstanceManager. 542 * The CTC manager uses InstanceManagerAutoDefault which can result in unnecessary 543 * XML content when CTC is not being used. 544 * Usage keys: 545 * <ul> 546 * <li>CtcWhereUsedOther</li> 547 * <li>CtcWhereUsedCBHD</li> 548 * </ul> 549 * @param bean The requesting bean: Block, Sensor, Signal Head, Signal Mast, Turnout. 550 * @return usage string 551 */ 552 static String checkCTC(NamedBean bean) { 553 StringBuilder sb = new StringBuilder(); 554 555 // Get the CTC manager via the ConfigureManager to avoid auto default. 556 InstanceManager.getOptionalDefault(ConfigureManager.class).ifPresent(cm -> { 557 cm.getInstanceList(CtcManager.class).forEach(m -> { 558 mgr = (CtcManager) m; 559 }); 560 }); 561 562 if (mgr != null) { 563 mgr.getUsageReport(bean).forEach((report) -> { 564 sb.append(Bundle.getMessage("ReferenceLineName", report.usageData)); // NOI18N 565 }); 566 } 567 return addHeader(sb, "ReferenceCTC"); // NOI18N 568 } 569 static CtcManager mgr = null; 570 571 /** 572 * Add the specified section to the beginning of the string builder if there is data. 573 * @param sb The current string builder. 574 * @param bundleKey The key for the section header. 575 * @return the resulting string. 576 */ 577 static String addHeader(StringBuilder sb, String bundleKey) { 578 if (sb.length() > 0) { 579 sb.insert(0, Bundle.getMessage("ReferenceHeader", Bundle.getMessage(bundleKey))); // NOI18N 580 sb.append("\n"); 581 } 582 return sb.toString(); 583 } 584 585// private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(WhereUsedCollectors.class); 586}