From fb54047b4d6022fbc631786731ed2d470c757e49 Mon Sep 17 00:00:00 2001 From: Quang Truong Date: Wed, 1 Apr 2026 13:12:07 +0200 Subject: [PATCH 1/2] Implementation Sskx - Table der Tafeln --- .../application/graph/BankServiceImpl.java | 13 +- .../table/TableMenuServiceImpl.java | 9 +- .../META-INF/MANIFEST.MF | 2 + .../OSGI-INF/l10n/bundle.properties | 6 + ...tractPlanPro2TableModelTransformator.xtend | 1 - .../feature/table/pt1/messages/Messages.java | 30 + .../ssks/AbstractSignalTableTransform.java | 416 +++++ .../table/pt1/ssks/SsksTransformator.xtend | 1348 +++++++---------- .../feature/table/pt1/sskx/SskxColumns.java | 94 ++ .../pt1/sskx/SskxDescriptionService.java | 45 + .../pt1/sskx/SskxTransformationService.java | 113 ++ .../table/pt1/sskx/SskxTransformator.java | 310 ++++ ...AbstractESTWSupplementTableDesciption.java | 4 +- .../table/internal/TableServiceImpl.java | 2 - .../table/internal/TableServiceUtils.java | 27 +- .../table/overview/TableErrorTableView.java | 11 +- .../data/export/excel/sskx_vorlage.xlsx | Bin 0 -> 24948 bytes .../extensions/FootnoteExtensions.java | 13 +- .../extensions/FstrZugRangierExtensions.xtend | 2 +- .../ppmodel/extensions/SignalExtensions.xtend | 42 +- .../extensions/StellBereichExtensions.java | 4 +- .../org.eclipse.set.swtbot/SWTBot.launch | 16 +- .../org/eclipse/set/swtbot/table/PtTable.java | 4 +- .../eclipse/set/utils/table/TableInfo.java | 50 + 24 files changed, 1702 insertions(+), 860 deletions(-) create mode 100644 java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/AbstractSignalTableTransform.java create mode 100644 java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxColumns.java create mode 100644 java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxDescriptionService.java create mode 100644 java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformationService.java create mode 100644 java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformator.java create mode 100644 java/bundles/org.eclipse.set.feature/rootdir/data/export/excel/sskx_vorlage.xlsx diff --git a/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/graph/BankServiceImpl.java b/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/graph/BankServiceImpl.java index c82c4169a5..3c54543d11 100644 --- a/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/graph/BankServiceImpl.java +++ b/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/graph/BankServiceImpl.java @@ -498,10 +498,12 @@ public List findBankValue(final TopPoint point) { final BigDecimal distanceLeft = leftPosition.subtract(pointDistance) .abs(); - - return List.of( - bankingDefault(ueRight.subtract(ueLeft), distanceLeft, length) - .add(ueLeft)); + final BigDecimal defaultValue = bankingDefault(ueRight.subtract(ueLeft), + distanceLeft, length); + if (defaultValue == null) { + return Collections.emptyList(); + } + return List.of(defaultValue.add(ueLeft)); } static BigDecimal findBankingValue(final TopPoint point, @@ -630,6 +632,9 @@ private static BigDecimal bankingOfRampeS(final BigDecimal h_between, */ private static BigDecimal bankingDefault(final BigDecimal h_between, final BigDecimal distanceFromLeft, final BigDecimal length) { + if (length.compareTo(BigDecimal.ZERO) == 0) { + return null; + } return h_between.multiply(distanceFromLeft) .divide(length, ToolboxConstants.ROUNDING_TO_PLACE, RoundingMode.HALF_EVEN); diff --git a/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/table/TableMenuServiceImpl.java b/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/table/TableMenuServiceImpl.java index 447b8fd977..e7466c7219 100644 --- a/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/table/TableMenuServiceImpl.java +++ b/java/bundles/org.eclipse.set.application/src/org/eclipse/set/application/table/TableMenuServiceImpl.java @@ -19,7 +19,6 @@ import org.eclipse.nebula.widgets.nattable.selection.SelectionLayer; import org.eclipse.set.application.Messages; import org.eclipse.set.basis.constants.Events; -import org.eclipse.set.basis.constants.ToolboxConstants; import org.eclipse.set.core.services.Services; import org.eclipse.set.core.services.part.ToolboxPartService; import org.eclipse.set.utils.events.JumpToSiteplanEvent; @@ -141,11 +140,9 @@ public void widgetSelected(final SelectionEvent e) { || tableShortcut.isEmpty()) { return; } - String tableIdPrefix = ToolboxConstants.ESTW_TABLE_PART_ID_PREFIX; - if (jumpEvent.getTableCategory() - .equals(Pt1TableCategory.ETCS.getId())) { - tableIdPrefix = ToolboxConstants.ETCS_TABLE_PART_ID_PREFIX; - } + final String category = jumpEvent.getTableCategory(); + final String tableIdPrefix = Pt1TableCategory + .getTablePartPrefix(category); toolboxPartService.showPart(tableIdPrefix + "." //$NON-NLS-1$ + tableShortcut.toLowerCase()); ToolboxEvents.send(broker, jumpEvent); diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/META-INF/MANIFEST.MF b/java/bundles/org.eclipse.set.feature.table.pt1/META-INF/MANIFEST.MF index 8a93c5fbb3..128e950f9a 100644 --- a/java/bundles/org.eclipse.set.feature.table.pt1/META-INF/MANIFEST.MF +++ b/java/bundles/org.eclipse.set.feature.table.pt1/META-INF/MANIFEST.MF @@ -132,6 +132,8 @@ Service-Component: OSGI-INF/org.eclipse.set.feature.table.pt1.messages.Messages. OSGI-INF/org.eclipse.set.feature.table.pt1.sskt.SsktTransformationService.xml, OSGI-INF/org.eclipse.set.feature.table.pt1.sskw.SskwDescriptionService.xml, OSGI-INF/org.eclipse.set.feature.table.pt1.sskw.SskwTransformationService.xml, + OSGI-INF/org.eclipse.set.feature.table.pt1.sskx.SskxDescriptionService.xml, + OSGI-INF/org.eclipse.set.feature.table.pt1.sskx.SskxTransformationService.xml, OSGI-INF/org.eclipse.set.feature.table.pt1.sskz.SskzDescriptionService.xml, OSGI-INF/org.eclipse.set.feature.table.pt1.sskz.SskzTransformationService.xml, OSGI-INF/org.eclipse.set.feature.table.pt1.ssla.SslaDescriptionService.xml, diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/OSGI-INF/l10n/bundle.properties b/java/bundles/org.eclipse.set.feature.table.pt1/OSGI-INF/l10n/bundle.properties index 99394c99a9..ff079747b3 100644 --- a/java/bundles/org.eclipse.set.feature.table.pt1/OSGI-INF/l10n/bundle.properties +++ b/java/bundles/org.eclipse.set.feature.table.pt1/OSGI-INF/l10n/bundle.properties @@ -191,3 +191,9 @@ ToolboxTableNameSxxxShort=Sxxx ToolboxTableNameSxxxLong=Tabelle der Bearbeitungsvermerke ToolboxTableNameSxxxPlanningNumber=?? +SskxTableView_Heading=Tabelle der Tafeln – Sskx +ToolboxTableNameSskxLong=Tabelle der Tafeln +ToolboxTableNameSskxPlanningNumber=??? +ToolboxTableNameSskxShort=Sskx +SskxDescriptionService_ViewTooltip=Tabelle der Tafeln +SskxDescriptionService_ViewName=Sskx – Tabelle der Tafeln diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/AbstractPlanPro2TableModelTransformator.xtend b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/AbstractPlanPro2TableModelTransformator.xtend index 597c946a1a..469342ccdb 100644 --- a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/AbstractPlanPro2TableModelTransformator.xtend +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/AbstractPlanPro2TableModelTransformator.xtend @@ -302,5 +302,4 @@ abstract class AbstractPlanPro2TableModelTransformator extends AbstractTableMode topologicalCells.put(row, newHashSet(col)) } } - } diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/messages/Messages.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/messages/Messages.java index 57fb988a89..094d3407e4 100644 --- a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/messages/Messages.java +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/messages/Messages.java @@ -823,4 +823,34 @@ private void bindBundleLocalization( */ public String SxxxDescriptionService_ViewTooltip; + /** + * Tabelle der Tafeln – Sskx + */ + public String SskxTableView_Heading; + + /** + * Tabelle der Tafeln + */ + public String ToolboxTableNameSskxLong; + + /** + * ??? + */ + public String ToolboxTableNameSskxPlanningNumber; + + /** + * Sskx + */ + public String ToolboxTableNameSskxShort; + + /** + * Tabelle der Tafeln + */ + public String SskxDescriptionService_ViewTooltip; + + /** + * Sskx – Tabelle der Tafeln + */ + public String SskxDescriptionService_ViewName; + } diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/AbstractSignalTableTransform.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/AbstractSignalTableTransform.java new file mode 100644 index 0000000000..af07f1f4c1 --- /dev/null +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/AbstractSignalTableTransform.java @@ -0,0 +1,416 @@ +/** + * Copyright (c) 2026 DB InfraGO AG and others + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v2.0 which is available at + * https://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + */ +package org.eclipse.set.feature.table.pt1.ssks; + +import static org.eclipse.set.model.planpro.Signale.ENUMBefestigungArt.*; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.eclipse.set.basis.graph.TopPoint; +import org.eclipse.set.core.services.enumtranslation.EnumTranslationService; +import org.eclipse.set.core.services.graph.BankService; +import org.eclipse.set.feature.table.pt1.AbstractPlanPro2TableModelTransformator; +import org.eclipse.set.feature.table.pt1.ssks.SignalSideDistance.SideDistance; +import org.eclipse.set.model.planpro.BasisTypen.ENUMLinksRechts; +import org.eclipse.set.model.planpro.BasisTypen.ID_Bearbeitungsvermerk_TypeClass; +import org.eclipse.set.model.planpro.Basisobjekte.Punkt_Objekt_TOP_Kante_AttributeGroup; +import org.eclipse.set.model.planpro.Geodaten.Strecke; +import org.eclipse.set.model.planpro.Gleis.Gleis_Lichtraum; +import org.eclipse.set.model.planpro.Signale.ENUMBefestigungArt; +import org.eclipse.set.model.planpro.Signale.Signal; +import org.eclipse.set.model.planpro.Signale.Signal_Befestigung; +import org.eclipse.set.model.planpro.Signale.Signal_Rahmen; +import org.eclipse.set.model.planpro.Verweise.ID_Regelzeichnung_TypeClass; +import org.eclipse.set.model.tablemodel.ColumnDescriptor; +import org.eclipse.set.model.tablemodel.Table; +import org.eclipse.set.model.tablemodel.TableRow; +import org.eclipse.set.ppmodel.extensions.BereichObjektExtensions; +import org.eclipse.set.ppmodel.extensions.EObjectExtensions; +import org.eclipse.set.ppmodel.extensions.PunktObjektExtensions; +import org.eclipse.set.ppmodel.extensions.PunktObjektTopKanteExtensions; +import org.eclipse.set.ppmodel.extensions.SignalExtensions; +import org.eclipse.set.ppmodel.extensions.SignalRahmenExtensions; +import org.eclipse.set.ppmodel.extensions.container.MultiContainer_AttributeGroup; +import org.eclipse.set.ppmodel.extensions.geometry.GEOKanteGeometryExtensions; +import org.eclipse.set.utils.math.BigDecimalExtensions; +import org.eclipse.set.utils.table.RowFactory; +import org.eclipse.set.utils.table.TMFactory; +import org.eclipse.xtext.xbase.lib.Pair; +import org.osgi.service.event.EventAdmin; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Streams; + +/** + * This + */ +public abstract class AbstractSignalTableTransform + extends AbstractPlanPro2TableModelTransformator { + static final Logger LOGGER = LoggerFactory + .getLogger(AbstractSignalTableTransform.class); + BankService bankingService; + String tableShortCut; + Map sideDistancesSignal; + + private static final List mastTypeOfSignalWithTwoMast = List + .of(ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_MAST_HOCH, + ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_MAST_NIEDRIG, + ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_SONSTIGE_HOCH, + ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_SONSTIGE_NIEDRIG, + ENUM_BEFESTIGUNG_ART_SONDERANORDNUNG_MAST_HOCH, + ENUM_BEFESTIGUNG_ART_SONDERANORDNUNG_MAST_NIEDRIG); + + protected AbstractSignalTableTransform(final Set cols, + final EnumTranslationService enumTranslationService, + final BankService bankingService, final EventAdmin eventAdmin, + final String tableShortCut) { + super(cols, enumTranslationService, eventAdmin); + this.bankingService = bankingService; + this.tableShortCut = tableShortCut; + } + + @Override + public Table transformTableContent( + final MultiContainer_AttributeGroup container, + final TMFactory factory) { + sideDistancesSignal = new HashMap<>(); + for (final Signal signal : getRelevantSignal(container)) { + Thread.currentThread(); + if (Thread.interrupted()) { + return null; + } + transformSignal(factory, container, signal); + } + return factory.getTable(); + } + + protected abstract Iterable getRelevantSignal( + MultiContainer_AttributeGroup contanier); + + protected void transformSignal(final TMFactory factory, + final MultiContainer_AttributeGroup container, + final Signal signal) { + try { + final RowFactory newRowGroup = factory.newRowGroup(signal); + final List> befestigungsgruppen = SignalExtensions + .getBefestigungsgruppen(signal, + mastTypeOfSignalWithTwoMast); + for (int i = 0; i < 2 && i < befestigungsgruppen.size(); i++) { + final boolean isHauptbefestigung = i == 0; + final Set gruppe = new HashSet<>( + befestigungsgruppen.get(i)); + if (isHauptbefestigung || !gruppe.isEmpty()) { + final List signalRahmen = SignalExtensions + .signalRahmenForBefestigung(signal, gruppe); + final TableRow row = newRowGroup.newTableRow(); + fillGenerallyColumns(row, container, signal, + isHauptbefestigung, signalRahmen); + fillSpecifyColumns(row, container, signal, + isHauptbefestigung, signalRahmen); + } + } + } catch (final Exception e) { + LOGGER.error("{0}: {1} - failed to transform table contents", //$NON-NLS-1$ + e.getClass().getSimpleName(), e.getMessage()); + handledThrowException(factory, signal, e); + } + } + + /** + * Fill the specify column of table + * + * @param row + * the {@link TableRow} + * @param container + * the {@link MultiContainer_AttributeGroup} + * @param signal + * the {@link Signal} + * @param isHauptbefestigung + * is this signal an main mast + * @param signalRahmen + * the list of {@link Signal_Rahmen} + */ + protected abstract void fillSpecifyColumns(TableRow row, + MultiContainer_AttributeGroup container, Signal signal, + boolean isHauptbefestigung, List signalRahmen); + + /** + * Fill the generally columns, which are same at all Signal table + * + * @param row + * @param container + * @param signal + * @param isHauptBefestigung + * @param signalRahmen + */ + @SuppressWarnings("boxing") + protected void fillGenerallyColumns(final TableRow row, + final MultiContainer_AttributeGroup container, final Signal signal, + final boolean isHauptBefestigung, + final List signalRahmen) { + // Bezeichnung.Signal + fillConditional(row, getBezeichnungColumn(), signal, + s -> isHauptBefestigung, SignalExtensions::getTableBezeichnung, + s -> ""); //$NON-NLS-1$ + + final List>> streckeAndKm = PunktObjektExtensions + .getStreckeAndKm(signal); + if (signal.getPunktObjektStrecke().size() > 1 + && signal.getPunktObjektStrecke() + .stream() + .noneMatch(pos -> pos.getKmMassgebend() != null + && pos.getKmMassgebend().getWert() != null)) { + addTopologicalCell(row, getStreckeColumn()); + addTopologicalCell(row, getKmColumn()); + } + // Standortmerkmale.Standort.Strecke + fillIterableWithConditional(row, getStreckeColumn(), signal, + s -> isHauptBefestigung, + s -> streckeAndKm.stream().map(Pair::getKey).toList(), + MIXED_STRING_COMPARATOR, ITERABLE_FILLING_SEPARATOR); + + // Standortmerkmale.Standort.km + fillIterableSingleCellWhenAllowed(row, getKmColumn(), signal, + () -> GEOKanteGeometryExtensions.isFindGeometryComplete() + || streckeAndKm.stream() + .flatMap(p -> p.getValue().stream()) + .anyMatch(s -> s != null && !s.isEmpty()), + s -> { + final List kmValues = streckeAndKm.stream() + .flatMap(p -> p.getValue().stream()) + .toList(); + if (kmValues.stream() + .anyMatch(km -> km != null && !km.isEmpty())) { + return kmValues; + } + + final Punkt_Objekt_TOP_Kante_AttributeGroup potk = PunktObjektExtensions + .getSinglePoint(s); + final List routeThroughBereichObjekt = PunktObjektTopKanteExtensions + .getStreckenThroughBereichObjekt(potk); + return PunktObjektExtensions.getStreckeKm(signal, + routeThroughBereichObjekt); + }, null, ITERABLE_FILLING_SEPARATOR, tableShortCut); + + // Standortmerkmale.Lichtraumprofil + fillIterableWithConditional(row, getLichtraumProfilColumn(), signal, + s -> signal.getSignalReal() != null, s -> { + final List lichtraeume = Streams + .stream(container.getGleisLichtraum()) + .filter(lichtRaum -> BereichObjektExtensions + .contains(lichtRaum, s)) + .toList(); + final Set translateValues = lichtraeume.stream() + .map(Gleis_Lichtraum::getLichtraumprofil) + .filter(Objects::nonNull) + .map(this::translate) + .collect(Collectors.toSet()); + final List sortedList = new ArrayList<>( + translateValues); + sortedList.sort(Comparable::compareTo); + return sortedList; + }, null, ITERABLE_FILLING_SEPARATOR); + + // Standortmerkmale.Ueberhoehung + if (signal.getSignalReal() != null) { + fillIterableSingleCellWhenAllowed(row, getUeberhoehungColumn(), + signal, () -> bankingService.isFindBankingComplete(), s -> { + final TopPoint topPoint = new TopPoint(s); + final List bankValues = bankingService + .findBankValue(topPoint); + return bankValues.stream() + .filter(Objects::nonNull) + .map(value -> BigDecimalExtensions + .toTableInteger(value.multiply( + new BigDecimal(1000)))) + .toList(); + }, null, ITERABLE_FILLING_SEPARATOR, tableShortCut); + } + + // Standortmerkmale.Abstand_Mastmitte.links + // Standortmerkmale.Abstand_Mastmitte.rechts + fillAbstandMastMitte(row, signal); + + // konstruktive_Merkmale.Anordnung.Befestigung + fillIterable(row, getBefestigungColumn(), signalRahmen, + rahmen -> rahmen.stream() + .map(r -> fillBefestigung( + SignalRahmenExtensions.getSignalBefestigung(r))) + .collect(Collectors.toSet()), + null); + + // konstruktive_Merkmale.Anordnung.Regelzeichnung + fillIterable(row, getRegelzeichnungColumn(), signalRahmen, + rahmen -> rahmen.stream().flatMap(r -> { + final Signal_Befestigung signalBefestigung = SignalRahmenExtensions + .getSignalBefestigung(r); + if (signalBefestigung == null) { + return Stream.empty(); + } + return signalBefestigung.getIDRegelzeichnung() + .stream() + .map(ID_Regelzeichnung_TypeClass::getValue) + .filter(Objects::nonNull) + .map(z -> fillRegelzeichnung(z)); + }).toList(), null); + + // konstruktive_Merkmale.Fundament.Art_Regelzeichnung + fillIterable(row, getArtRegelzeichnungColumn(), signalRahmen, + rahmen -> transformRegelzeichnungArt(row, rahmen), + MIXED_STRING_COMPARATOR); + + // konstruktive_Merkmale.Fundament.Hoehe + fillIterable(row, getFundamentHoeheColumn(), signalRahmen, + rahmen -> rahmen.stream() + .map(r -> EObjectExtensions.getNullableObject(r, + e -> SignalRahmenExtensions.getFundament(e) + .getSignalBefestigungAllg() + .getHoeheFundamentoberkante() + .getWert()) + .orElse(null)) + .filter(Objects::nonNull) + .toList(), + null, + value -> BigDecimalExtensions.toTableInteger(value, 1000)); + } + + protected Iterable transformRegelzeichnungArt(final TableRow row, + final List rahmen) { + final List fundamenten = rahmen.stream() + .map(SignalRahmenExtensions::getFundament) + .filter(Objects::nonNull) + .toList(); + final List fundamentArt = fundamenten.stream() + .map(fund -> EObjectExtensions + .getNullableObject(fund, + f -> f.getSignalBefestigungAllg() + .getFundamentArt()) + .orElse(null)) + .filter(Objects::nonNull) + .map(this::translate) + .filter(Objects::nonNull) + .toList(); + final List regelzeichnungen = fundamenten.stream() + .flatMap(fund -> fund.getIDRegelzeichnung().stream()) + .map(id -> { + if (id == null) { + return null; + } + return fillRegelzeichnung(id.getValue()); + }) + .filter(Objects::nonNull) + .toList(); + if (!regelzeichnungen.isEmpty()) { + addTopologicalCell(row, getArtRegelzeichnungColumn()); + } + final Set result = new HashSet<>(regelzeichnungen); + result.addAll(fundamentArt); + return result; + } + + protected void fillAbstandMastMitte(final TableRow row, + final Signal signal) { + getAbstandMastMitteColumn().forEach( + (linksrechts, column) -> fillIterableMultiCellWhenAllow(row, + column, signal, + GEOKanteGeometryExtensions::isFindGeometryComplete, + s -> { + final SignalSideDistance signalSideDistances = sideDistancesSignal + .computeIfAbsent(s, + SignalSideDistance::new); + final Set distances = switch (linksrechts) { + case ENUM_LINKS_RECHTS_LINKS -> signalSideDistances + .getSideDistancesLeft(); + case ENUM_LINKS_RECHTS_RECHTS -> signalSideDistances + .getSideDistancesRight(); + }; + + if (distances.stream() + .anyMatch(v -> v + .getDistanceToNeighborTrack() > 0)) { + addTopologicalCell(row, column); + } + return distances.stream() + .map(SideDistance::toString) + .toList(); + }, null, ITERABLE_FILLING_SEPARATOR)); + } + + protected abstract ColumnDescriptor getFundamentHoeheColumn(); + + protected abstract ColumnDescriptor getArtRegelzeichnungColumn(); + + protected abstract ColumnDescriptor getRegelzeichnungColumn(); + + protected abstract ColumnDescriptor getBefestigungColumn(); + + protected abstract Map getAbstandMastMitteColumn(); + + protected abstract ColumnDescriptor getUeberhoehungColumn(); + + protected abstract ColumnDescriptor getLichtraumProfilColumn(); + + protected abstract ColumnDescriptor getStreckeColumn(); + + protected abstract ColumnDescriptor getKmColumn(); + + protected abstract ColumnDescriptor getBezeichnungColumn(); + + protected abstract void handledThrowException(TMFactory row, Signal signal, + Exception e); + + @SuppressWarnings("nls") + private String fillBefestigung(final Signal_Befestigung befestigung) { + final ENUMBefestigungArt art = EObjectExtensions.getNullableObject( + befestigung, + b -> b.getSignalBefestigungAllg().getBefestigungArt().getWert()) + .orElse(null); + return switch (art) { + case ENUM_BEFESTIGUNG_ART_SONSTIGE -> { + final List bearbeitungsvermerke = EObjectExtensions + .getNullableObject(befestigung, + b -> b.getSignalBefestigungAllg() + .getBefestigungArt() + .getIDBearbeitungsvermerk()) + .orElse(null); + if (bearbeitungsvermerke == null + || bearbeitungsvermerke.isEmpty()) { + throw new IllegalArgumentException(String.format( + "'Befestigung Art of Befestigung %s has no Bearbeitungsvermerke.", + befestigung.getIdentitaet().getWert())); + } + yield bearbeitungsvermerke.stream() + .map(b -> b.getValue() + .getBearbeitungsvermerkAllg() + .getKurztext() + .getWert()) + .collect(Collectors.joining(",")); + } + default -> translate( + EObjectExtensions + .getNullableObject(befestigung, + b -> b.getSignalBefestigungAllg() + .getBefestigungArt()) + .orElse(null)); + }; + } + +} diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/SsksTransformator.xtend b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/SsksTransformator.xtend index fb671383b4..53be092a2d 100644 --- a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/SsksTransformator.xtend +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/ssks/SsksTransformator.xtend @@ -12,13 +12,13 @@ import java.math.BigDecimal import java.util.Collections import java.util.LinkedList import java.util.List +import java.util.Map import java.util.Set import org.eclipse.set.basis.MixedStringComparator -import org.eclipse.set.basis.graph.TopPoint import org.eclipse.set.core.services.enumtranslation.EnumTranslationService import org.eclipse.set.core.services.graph.BankService -import org.eclipse.set.feature.table.pt1.AbstractPlanPro2TableModelTransformator import org.eclipse.set.model.planpro.Ansteuerung_Element.Unterbringung +import org.eclipse.set.model.planpro.BasisTypen.ENUMLinksRechts import org.eclipse.set.model.planpro.Basisobjekte.Punkt_Objekt import org.eclipse.set.model.planpro.Geodaten.Technischer_Punkt import org.eclipse.set.model.planpro.Signalbegriffe_Ril_301.Hl10 @@ -78,7 +78,6 @@ import org.eclipse.set.model.planpro.Signalbegriffe_Struktur.Signalbegriff_ID_Ty import org.eclipse.set.model.planpro.Signale.ENUMAutoEinstellung import org.eclipse.set.model.planpro.Signale.ENUMGeltungsbereich import org.eclipse.set.model.planpro.Signale.Signal -import org.eclipse.set.model.planpro.Signale.Signal_Befestigung import org.eclipse.set.model.planpro.Signale.Signal_Rahmen import org.eclipse.set.model.planpro.Signale.Signal_Signalbegriff import org.eclipse.set.model.tablemodel.ColumnDescriptor @@ -88,13 +87,10 @@ import org.eclipse.set.ppmodel.extensions.utils.Case import org.eclipse.set.utils.table.TMFactory import org.locationtech.jts.geom.Coordinate import org.osgi.service.event.EventAdmin -import org.slf4j.Logger -import org.slf4j.LoggerFactory import static org.eclipse.set.feature.table.pt1.ssks.SsksColumns.* import static org.eclipse.set.model.planpro.Ansteuerung_Element.ENUMAussenelementansteuerungArt.* import static org.eclipse.set.model.planpro.Signale.ENUMAnschaltdauer.* -import static org.eclipse.set.model.planpro.Signale.ENUMBefestigungArt.* import static org.eclipse.set.model.planpro.Signale.ENUMBeleuchtet.* import static org.eclipse.set.model.planpro.Signale.ENUMFiktivesSignalFunktion.* import static org.eclipse.set.model.planpro.Signale.ENUMGeltungsbereich.* @@ -102,10 +98,8 @@ import static org.eclipse.set.model.planpro.Signale.ENUMRahmenArt.* import static org.eclipse.set.model.planpro.Signale.ENUMSignalArt.* import static org.eclipse.set.model.planpro.Signale.ENUMSignalFunktion.* import static org.eclipse.set.model.planpro.Signale.ENUMTunnelsignal.* -import static org.eclipse.set.ppmodel.extensions.geometry.GEOKanteGeometryExtensions.* import static extension org.eclipse.set.ppmodel.extensions.BasisAttributExtensions.* -import static extension org.eclipse.set.ppmodel.extensions.BereichObjektExtensions.* import static extension org.eclipse.set.ppmodel.extensions.GeoPunktExtensions.* import static extension org.eclipse.set.ppmodel.extensions.PunktObjektExtensions.* import static extension org.eclipse.set.ppmodel.extensions.PunktObjektTopKanteExtensions.* @@ -116,7 +110,6 @@ import static extension org.eclipse.set.ppmodel.extensions.SignalbegriffExtensio import static extension org.eclipse.set.ppmodel.extensions.StellelementExtensions.* import static extension org.eclipse.set.ppmodel.extensions.UnterbringungExtensions.* import static extension org.eclipse.set.ppmodel.extensions.UrObjectExtensions.* -import static extension org.eclipse.set.ppmodel.extensions.utils.IterableExtensions.* import static extension org.eclipse.set.utils.math.BigDecimalExtensions.* /** @@ -124,19 +117,10 @@ import static extension org.eclipse.set.utils.math.BigDecimalExtensions.* * * @author Dittmer */ -class SsksTransformator extends AbstractPlanPro2TableModelTransformator { +class SsksTransformator extends AbstractSignalTableTransform { - static val Logger LOGGER = LoggerFactory.getLogger( - typeof(SsksTransformator)) static val SIGNALBEGRIFF_COMPARATOR = new MixedStringComparator( "(?[A-Za-z]*)(?[0-9]*)(?[A-Za-z]*)") - static val mastTypeOfSignalWithTwoMast = #[ - ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_MAST_HOCH, - ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_MAST_NIEDRIG, - ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_SONSTIGE_HOCH, - ENUM_BEFESTIGUNG_ART_REGELANORDNUNG_SONSTIGE_NIEDRIG, - ENUM_BEFESTIGUNG_ART_SONDERANORDNUNG_MAST_HOCH, - ENUM_BEFESTIGUNG_ART_SONDERANORDNUNG_MAST_NIEDRIG] static val inRelevantFiktivFunktion = #[ ENUM_FIKTIVES_SIGNAL_FUNKTION_ZUG_START_ZIEL_BK_MIT_ZS_1, ENUM_FIKTIVES_SIGNAL_FUNKTION_ZUG_START_ZIEL_BK_MIT_ZS_7, @@ -145,815 +129,499 @@ class SsksTransformator extends AbstractPlanPro2TableModelTransformator { ENUM_FIKTIVES_SIGNAL_FUNKTION_ZUG_START_ZIEL_NE_14_MIT_ZS_8, ENUM_FIKTIVES_SIGNAL_FUNKTION_RANGIER_START_ZIEL_NE_14 ] - val BankService bankingService - val String tableShortCut // Container the thread, which will be refresh table after all thread is done new(Set cols, EnumTranslationService enumTranslationService, BankService bankingService, EventAdmin eventAdmin, String tableShortCut) { - super(cols, enumTranslationService, eventAdmin) - this.bankingService = bankingService - this.tableShortCut = tableShortCut + super(cols, enumTranslationService, bankingService, eventAdmin, + tableShortCut) } + + override protected fillSpecifyColumns(TableRow row, + MultiContainer_AttributeGroup container, Signal signal, + boolean isHauptbefestigung, List signalRahmen) { + + // B: Ssks.Signal_Art.Reales_Signal + fillSwitch( + row, + cols.getColumn(Reales_Signal), + signal, + new Case( + [ + isHauptbefestigung && (isETCSMarker || + (signalReal?.signalRealAktiv !== null && + signalReal?.signalFunktion.wert === + ENUM_SIGNAL_FUNKTION_ALLEINSTEHENDES_ZUSATZSIGNAL)) + ], + ["W"] + ), + new Case( + [isHauptbefestigung], + [ + signalReal?.signalRealAktivSchirm?.signalArt?.translate + ] + ) + ) - override transformTableContent(MultiContainer_AttributeGroup container, - TMFactory factory) { - // iterate signal-wise - val sideDistancesSignal = newHashMap - for (Signal signal : container?.signal?.filter[ssksSignal]) { - if (Thread.currentThread.interrupted) { - return null - } - try { - val rowGroup = factory.newRowGroup(signal) - - // iterate over Befestigungen - val befestigungsgruppen = signal.befestigungsgruppen - for (var int i = 0; i < 2 && - i < befestigungsgruppen.size; i++) { - val isHauptbefestigung = (i == 0) - val gruppe = befestigungsgruppen.get(i)?.toSet - - // Certain columns have the same values in the rows for the "Haupt-" and "Nebenbefestigung". - // In order to avoid the redundant display, we only display these values in the line of the "Hauptbefestigung" - if (isHauptbefestigung || !gruppe.nullOrEmpty) { - val signalRahmen = signal. - signalRahmenForBefestigung(gruppe) - val TableRow row = rowGroup.newTableRow - - // A: Ssks.Bezeichnung_Signal - fillConditional( - row, - cols.getColumn(Bezeichnung_Signal), - signal, - [isHauptbefestigung], - [bezeichnung.bezeichnungTabelle.wert], - [""] - ) - - // B: Ssks.Signal_Art.Reales_Signal - fillSwitch( - row, - cols.getColumn(Reales_Signal), - signal, - new Case( - [ - isHauptbefestigung && (isETCSMarker || - (signalReal?.signalRealAktiv !== null && - signalReal?.signalFunktion.wert === - ENUM_SIGNAL_FUNKTION_ALLEINSTEHENDES_ZUSATZSIGNAL)) - ], - ["W"] - ), - new Case( - [isHauptbefestigung], - [ - signalReal?.signalRealAktivSchirm?. - signalArt?.translate - ] - ) - ) - - // C: Ssks.Signal_Art.Funktion_Ohne_Signal - fillConditional( - row, - cols.getColumn(Funktion_Ohne_Signal), - signal, - [isHauptbefestigung], - [ - signalReal?.funktionOhneSignal?.translate - ] - ) - - // D: Ssks.Signal_Art.Fiktives_Signal - fillIterable( - row, - cols.getColumn(Fiktives_Signal), - signal, - [ - signalFiktiv?.fiktivesSignalFunktion?.map [ fiktivSignalFunktion | - fiktivSignalFunktion?.translate - ] ?: Collections.emptyList - ], - null - ) - - val streckAndKm = getStreckeAndKm(signal) - if (signal.punktObjektStrecke.size > 1 && - !signal.punktObjektStrecke.exists [ - kmMassgebend?.wert !== null - ]) { - row.addTopologicalCell(cols.getColumn(Km)) - row.addTopologicalCell(cols.getColumn(Strecke)) - } - - // E: Ssks.Standortmerkmale.Standort.Strecke - fillIterableWithConditional( - row, - cols.getColumn(Strecke), - signal, - [isHauptbefestigung], - [ - streckAndKm.map[key] - ], - MIXED_STRING_COMPARATOR, - ITERABLE_FILLING_SEPARATOR - ) - - // F: Ssks.Standortmerkmale.Standort.km - fillIterableSingleCellWhenAllowed( - row, - cols.getColumn(Km), - signal, - [ - isFindGeometryComplete || streckAndKm.flatMap [ - value - ].exists[!nullOrEmpty] - ], - [ - if (streckAndKm.flatMap[value].exists [ - !nullOrEmpty - ]) { - return streckAndKm.flatMap[value].toList - } - val routeThroughBereichObjekt = singlePoint. - streckenThroughBereichObjekt - return getStreckeKm(routeThroughBereichObjekt). - toList - ], - null, - ITERABLE_FILLING_SEPARATOR, - tableShortCut - ) - - // G: Ssks.Standortmerkmale.Sonstige_Zulaessige_Anordnung - fill( - row, - cols.getColumn(Sonstige_Zulaessige_Anordnung), - signal, - [ - signalReal?.signalRealAktiv?. - sonstigeZulaessigeAnordnung?.translate - ] - ) - - // H: Ssks.Standortmerkmale.Lichtraumprofil - fillIterableWithConditional( - row, - cols.getColumn(Lichtraumprofil), - signal, - [signalReal !== null], - [ - val s = it - val lichtraeume = it.container.gleisLichtraum. - filter[contains(s)] - lichtraeume.map [ - lichtraumprofil?.translate - ].toSet.toList.sort - ], - null, - ITERABLE_FILLING_SEPARATOR - ) - - // I: Ssks.Standortmerkmale.Ueberhoehung - if (signal.signalReal !== null) { - fillIterableSingleCellWhenAllowed( - row, - cols.getColumn(Ueberhoehung), - signal, - [bankingService.isFindBankingComplete], - [ - bankingService.findBankValue( - new TopPoint(it)).map [ - multiply(new BigDecimal(1000)). - toTableInteger ?: "" - ] - ], - null, - ITERABLE_FILLING_SEPARATOR, - tableShortCut - ) - } - - // J: Ssks.Standortmerkmale.Abstand_Mastmitte.links - // K: Ssks.Standortmerkmale.Abstand_Mastmitte.rechts - #[Mastmitte_Links, Mastmitte_Rechts].forEach [ position | - val col = switch (position) { - case Mastmitte_Links: - cols.getColumn(Mastmitte_Links) - case Mastmitte_Rechts: - cols.getColumn(Mastmitte_Rechts) - } - - fillIterableMultiCellWhenAllow( - row, - col, - signal, - [isFindGeometryComplete], - [ - val signalSideDistances = sideDistancesSignal. - computeIfAbsent(it, [ s | - new SignalSideDistance(s) - ]) - val distances = switch (position) { - case Mastmitte_Links: - signalSideDistances. - sideDistancesLeft - case Mastmitte_Rechts: - signalSideDistances. - sideDistancesRight - } - if (distances.exists [ - distanceToNeighborTrack > 0 - ]) { - row.addTopologicalCell(col) - } - - return distances.map[toString].toList - ], - null, - ITERABLE_FILLING_SEPARATOR - ) + // C: Ssks.Signal_Art.Funktion_Ohne_Signal + fillConditional( + row, + cols.getColumn(Funktion_Ohne_Signal), + signal, + [isHauptbefestigung], + [ + signalReal?.funktionOhneSignal?.translate + ] + ) - ] + // D: Ssks.Signal_Art.Fiktives_Signal + fillIterable( + row, + cols.getColumn(Fiktives_Signal), + signal, + [ + signalFiktiv?.fiktivesSignalFunktion?.map [ fiktivSignalFunktion | + fiktivSignalFunktion?.translate + ] ?: Collections.emptyList + ], + null + ) - // L: Ssks.Standortmerkmale.Sichtbarkeit.Soll - fillConditional( - row, - cols.getColumn(Sichtbarkeit_Soll), - signal, - [isHauptbefestigung], - [ - signalReal?.signalsichtSoll?.wert?.toString - ] - ) - - // M: Ssks.Standortmerkmale.Sichtbarkeit.Mindest - fillConditional( - row, - cols.getColumn(Sichtbarkeit_Mindest), - signal, - [isHauptbefestigung], - [ - signalReal?.signalsichtMindest?.wert?.toString - ] - ) - - // N: Ssks.Standortmerkmale.Sichtbarkeit.Ist - fillConditional( - row, - cols.getColumn(Sichtbarkeit_Ist), - signal, - [isHauptbefestigung], - [ - signalReal?.signalsichtErreichbar?.wert?. - toString - ] - ) - - // O: Ssks.Standortmerkmale.Ausrichtung.Entfernung - fillConditional( - row, - cols.getColumn(Entfernung), - signal, - [isHauptbefestigung], - [ - signalReal?.signalRealAktivSchirm?. - richtpunktentfernung?.wert?.toString - ] - ) - - // P: Ssks.Standortmerkmale.Ausrichtung.Richtpunkt - fillConditional( - row, - cols.getColumn(Richtpunkt), - signal, - [isHauptbefestigung], - [ - signalReal?.signalRealAktivSchirm?. - richtpunkt?.wert - ] - ) - - // Q: Ssks.konstruktive_Merkmale.Anordnung.Befestigung - fillIterable( - row, - cols.getColumn(Befestigung), - signalRahmen, - [map[signalBefestigung.fillBefestigung].toSet], - null, - [toString] - ) - - // R: Ssks.konstruktive_Merkmale.Anordnung.Regelzeichnung - fillIterable( - row, - cols.getColumn(Anordnung_Regelzeichnung), - signalRahmen, - [fillRegelzeichnung.toSet], - null, - [toString] - ) - - // S: Ssks.konstruktive_Merkmale.Obere_Lichtpunkthoehe - fillIterable( - row, - cols.getColumn(Obere_Lichtpunkthoehe), - signalRahmen, - [ - map [ - signalBefestigung?.signalBefestigungAllg?. - obereLichtpunkthoehe?.wert - ].toSet.map [ b | - if (b !== null) - (Math.round(b.doubleValue * 1000)). - toString - else - "" - ] - ], - null, - [it] - ) - - // T: Ssks.konstruktive_Merkmale.Streuscheibe.Art - fillConditional( - row, - cols.getColumn(Streuscheibe_Art), - signal, - [isHauptbefestigung], - [ - signalReal?.signalRealAktivSchirm?. - streuscheibeArt?.translate ?: "" - ] - ) - - // U: Ssks.konstruktive_Merkmale.Streuscheibe.Stellung - fillConditional( - row, - cols.getColumn(Streuscheibe_Stellung), - signal, - [isHauptbefestigung], - [ - signalReal?.signalRealAktivSchirm?. - streuscheibeBetriebsstellung?. - translate ?: "" - ] - ) - - // V: Ssks.konstruktive_Merkmale.Fundament.Regelzeichnung - fillIterable( - row, - cols.getColumn(Fundament_Art_Regelzeichnung), - signalRahmen, - [ - val fundament = map[ - fundament?.signalBefestigungAllg?. - fundamentArt - ].filterNull.map[translate].filterNull - val regelzeichnung = map[getFundament]. - filterNull.flatMap[IDRegelzeichnung].map [ - value?.fillRegelzeichnung - ].filterNull - if (!regelzeichnung.isNullOrEmpty) { - row.addTopologicalCell( - cols.getColumn( - Fundament_Art_Regelzeichnung)) - } - return (regelzeichnung + fundament).toSet - ], - null, - [toString] - ) - - // W: Ssks.konstruktive_Merkmale.Fundament.Hoehe - fillIterable( - row, - cols.getColumn(Fundament_Hoehe), - signalRahmen, - [ - map[ - fundament?.signalBefestigungAllg?. - hoeheFundamentoberkante?.wert - ].filterNull.toSet - ], - null, - [toTableInteger(1000)] - ) - - // X: Ssks.Anschluss.Schaltkasten.Bezeichnung - fillConditional( - row, - cols.getColumn(Schaltkasten_Bezeichnung), - signal, - [ - stellelement?.energie?.AEAAllg?. - aussenelementansteuerungArt?.wert == - ENUM_AUSSENELEMENTANSTEUERUNG_ART_OBJEKTCONTROLLER - ], - [ - stellelement?.energie?.bezeichnung?. - bezeichnungAEA?.wert - ] - ) - - // Y: Ssks.Anschluss.Schaltkasten.Entfernung - fillConditional( - row, - cols.getColumn(Schaltkasten_Entfernung), - signal, - [controlBox !== null], - [ - distance(controlBox).toTableIntegerAgateUp - ] - ) - - // Z: Ssks.Anschluss.Schaltkasten_separat.Bezeichnung - fillConditional( - row, - cols.getColumn(Schaltkasten_Separat_Bezeichnung), - signal, - [hasSchaltkastenSeparatBezeichnung], - [ - stellelement?.information?.bezeichnung?. - bezeichnungAEA?.wert - ] - ) - - // AA: Ssks.Anschluss.Dauerhaft_Nacht - if (signal.isSsksSignalNichtAndere) { - fillConditional( - row, - cols.getColumn(Dauerhaft_Nacht), - signal, - [isHauptbefestigung], - [ - (signalReal?.signalRealAktiv?. - tunnelsignal?.wert == - ENUM_TUNNELSIGNAL_MIT_DAUERNACHTSCHALTUNG). - translate - ] - ) - } - - // AB: Ssks.Signalisierung.Signalbegriffe_Schirm.Hp_Hl - fillIterable( - row, - cols.getColumn(Schirm_Hp_Hl), - signalRahmen, - [fillSignalisierungHpHl], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AC: Ssks.Signalisierung.Signalbegriffe_Schirm.Ks_Vr - fillIterable( - row, - cols.getColumn(Schirm_Ks_Vr), - signalRahmen, - [fillSignalisierungKsVr], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AD: Ssks.Signalisierung.Signalbegriffe_Schirm.Zl_Kl - fillIterable( - row, - cols.getColumn(Schirm_Zl_Kl), - signalRahmen, - [fillSignalisierungZlKl], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AE: Ssks.Signalisierung.Signalbegriffe_Schirm.Ra_Sh - fillSwitch( - row, - cols.getColumn(Schirm_Ra_Sh), - signal, - new Case( - [ - hasSignalbegriffID(Sh1) && - signalReal?.geltungsbereich.exists [ - wert === ENUMGeltungsbereich. - ENUM_GELTUNGSBEREICH_DV - ] - ], - ["Ra 12"] - ), - new Case( - [ - hasSignalbegriffID(Sh1) && - signalReal?.geltungsbereich.exists [ - wert == ENUMGeltungsbereich. - ENUM_GELTUNGSBEREICH_DS - ] - ], - ["Sh 1"] - ), - new Case([hasSignalbegriffID(Sh1)], ["x"]) - ) - - // AF: Ssks.Signalisierung.Signalbegriffe_Schirm.Zs - fillIterable( - row, - cols.getColumn(Schirm_Zs), - signalRahmen, - [fillSignalisierungSchirmZs], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AG: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_2 - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zs_2), - signalRahmen, - [fillSignalisierungSymbol(typeof(Zs2))], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AH: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_2v - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zs_2v), - signalRahmen, - [fillSignalisierungSymbol(typeof(Zs2v))], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AI: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_3 - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zs_3), - signalRahmen, - [fillSignalisierungSymbolGeschaltet(typeof(Zs3))], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AJ: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_3v - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zs_3v), - signalRahmen, - [ - fillSignalisierungSymbolGeschaltet(typeof(Zs3v)) - ], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AK: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zs), - signalRahmen, - [fillSignalisierungZusatzanzeigerZs], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AL: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zp - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Zp), - signalRahmen, - [fillSignalisierungZp], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AM: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Kombination - fillIterable( - row, - cols.getColumn(Zusatzanzeiger_Kombination), - signalRahmen, - [fillSignalisierungKombination], - null, - [it], - ", " - ) - - // AN: Ssks.Signalisierung.Nachgeordnetes_Signal - fillIterable( - row, - cols.getColumn(Nachgeordnetes_Signal), - signalRahmen, - [ - filter[r|r.IDSignalNachordnung !== null].map [ r | - r.signalNachordnung.bezeichnung. - bezeichnungTabelle.wert - ] + container.signalRahmen.filter [ r | - r?.IDSignalNachordnung?.value?. - identitaet?.wert == - signal.identitaet.wert - ].map [ r | - r.signal.bezeichnung.bezeichnungTabelle.wert - ] - ], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AO: Ssks.Signalisierung.Mastschild - fillIterable( - row, - cols.getColumn(Mastschild), - signalRahmen, - [fillSignalisierungMastschild], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AP: Ssks.Signalisierung.Weitere.Regelzeichnung_Nr - fillIterable( - row, - cols.getColumn(Weitere_Regelzeichnung_Nr), - signal, - [fillSignalisierungWeitere(signalRahmen)], - MIXED_STRING_COMPARATOR, - [it] - ) - - // AQ: Ssks.Sonstiges.Automatische_Fahrtstellung - fill( - row, - cols.getColumn(Automatische_Fahrtstellung), - signal, - [fillSonstigesAutomatischeFahrtstellung] - ) - - // AR: Ssks.Sonstiges.Dunkelschaltung - fill( - row, - cols.getColumn(Dunkelschaltung), - signal, - [fillSonstigesDunkelschaltung] - ) - - // AS: Ssks.Sonstiges.Durchfahrt_erlaubt - fill( - row, - cols.getColumn(Durchfahrt_Erlaubt), - signal, - [fillSonstigesDurchfahrtErlaubt] - ) - - // AT: Ssks.Sonstiges.Besetzte_Ausfahrt - fillConditional( - row, - cols.getColumn(Besetzte_Ausfahrt), - signal, - [signalFstr?.besetzteAusfahrt?.wert !== null], - [signalFstr.besetzteAusfahrt.wert.translate] - ) - - // AU: Ssks.Sonstiges.Loeschung_Zs_1__Zs_7 - fill( - row, - cols.getColumn(Loeschung_Zs_1__Zs_7), - signalRahmen, - [fillSonstigesLoeschungZs1Zs7] - ) - - // AV: Ssks.Sonstiges.Ueberwachung.Zs_2 - fillIterable( - row, - cols.getColumn(Ueberwachung_Zs_2), - signal, - [ - val zs2 = getSignalbegriffe(Zs2).filterNull - // Is there any Zs2 without zs2Ueberwacht = true? - if (zs2.empty || zs2.findFirst [ - signalSignalbegriffAllg?. - zs2Ueberwacht === null || - signalSignalbegriffAllg. - zs2Ueberwacht.wert == false - ] !== null) - return #[""] - - return zs2.map [ - signalbegriffID?.symbol ?: "?" - ] - ], - null - ) - - // AW: Ssks.Sonstiges.Ueberwachung.Zs_2v - fillIterable( - row, - cols.getColumn(Ueberwachung_Zs_2v), - signal, - [ - val zs2v = getSignalbegriffe(Zs2v).filterNull - // Is there any Zs2v without zs2Ueberwacht = true? - if (zs2v.empty || zs2v.findFirst [ - signalSignalbegriffAllg?. - zs2Ueberwacht === null || - signalSignalbegriffAllg. - zs2Ueberwacht.wert == false - ] !== null) - return #[""] - - return zs2v.map [ - signalbegriffID?.symbol ?: "?" - ] - ], - null - ) - - // AX: Ssks.Bemerkung - fill( - row, - cols.getColumn(Bemerkung), - signal, - [fillBemerkung(signalRahmen, row)] - ) - } - } - - } catch (Exception e) { - LOGGER.error('''«e. - -class .simpleName»: «e.message» - failed to transform table contents''', e) - val TableRow row = factory.newTableRow(signal); - fill( - row, - cols.getColumn(Reales_Signal), - signal, - [throw new RuntimeException(e)] - ) - } + // G: Ssks.Standortmerkmale.Sonstige_Zulaessige_Anordnung + fill( + row, + cols.getColumn(Sonstige_Zulaessige_Anordnung), + signal, + [ + signalReal?.signalRealAktiv?.sonstigeZulaessigeAnordnung?. + translate + ] + ) - } + // L: Ssks.Standortmerkmale.Sichtbarkeit.Soll + fillConditional( + row, + cols.getColumn(Sichtbarkeit_Soll), + signal, + [isHauptbefestigung], + [ + signalReal?.signalsichtSoll?.wert?.toString + ] + ) - return factory.table - } + // M: Ssks.Standortmerkmale.Sichtbarkeit.Mindest + fillConditional( + row, + cols.getColumn(Sichtbarkeit_Mindest), + signal, + [isHauptbefestigung], + [ + signalReal?.signalsichtMindest?.wert?.toString + ] + ) - private static def List> getBefestigungsgruppen( - Signal signal) { - val result = new LinkedList> - val rahmen = signal.signalRahmen - val befestigungen = rahmen.map[it -> signalBefestigung].distinctBy [ - value - ].toList + // N: Ssks.Standortmerkmale.Sichtbarkeit.Ist + fillConditional( + row, + cols.getColumn(Sichtbarkeit_Ist), + signal, + [isHauptbefestigung], + [ + signalReal?.signalsichtErreichbar?.wert?.toString + ] + ) - switch mast : befestigungen.filter [ - mastTypeOfSignalWithTwoMast.contains( - value?.signalBefestigungAllg?.befestigungArt?.wert) - ] { - // condition "zwei Befestigungen" - case mast.size == 2: { - val mainMast = befestigungen.filter [ - key.rahmenArt?.wert == ENUM_RAHMEN_ART_SCHIRM - ].filter [ - mastTypeOfSignalWithTwoMast.contains( - value.signalBefestigungAllg?.befestigungArt?.wert) - ].map[value].toSet - val subMast = mast.map[value].filter[!mainMast.contains(it)] - result.add(0, mainMast.toList) - result.add(1, subMast.toList) - } - case mast.size > 2: - throw new IllegalArgumentException('''«signal.bezeichnung?.bezeichnungAussenanlage?.toString» has more than two Befestigung Signal''') - default: - result.add(befestigungen.map[value].toList) - } - return result - } + // O: Ssks.Standortmerkmale.Ausrichtung.Entfernung + fillConditional( + row, + cols.getColumn(Entfernung), + signal, + [isHauptbefestigung], + [ + signalReal?.signalRealAktivSchirm?.richtpunktentfernung?.wert?. + toString + ] + ) - private def String fillBefestigung(Signal_Befestigung befestigung) { - val art = befestigung.signalBefestigungAllg.befestigungArt.wert + // P: Ssks.Standortmerkmale.Ausrichtung.Richtpunkt + fillConditional( + row, + cols.getColumn(Richtpunkt), + signal, + [isHauptbefestigung], + [ + signalReal?.signalRealAktivSchirm?.richtpunkt?.wert + ] + ) - switch (art) { - case ENUM_BEFESTIGUNG_ART_SONSTIGE: - return befestigung.fillBearbeitungsvermerke - default: - return befestigung?.signalBefestigungAllg?.befestigungArt?. - translate - } - } + // S: Ssks.konstruktive_Merkmale.Obere_Lichtpunkthoehe + fillIterable( + row, + cols.getColumn(Obere_Lichtpunkthoehe), + signalRahmen, + [ + map [ + signalBefestigung?.signalBefestigungAllg?. + obereLichtpunkthoehe?.wert + ].toSet.map [ b | + if (b !== null) + (Math.round(b.doubleValue * 1000)).toString + else + "" + ] + ], + null, + [it] + ) - private def String fillBearbeitungsvermerke( - Signal_Befestigung befestigung) { - val bearbeitungsvermerke = befestigung?.signalBefestigungAllg?. - befestigungArt?.IDBearbeitungsvermerk + // T: Ssks.konstruktive_Merkmale.Streuscheibe.Art + fillConditional( + row, + cols.getColumn(Streuscheibe_Art), + signal, + [isHauptbefestigung], + [ + signalReal?.signalRealAktivSchirm?.streuscheibeArt?.translate ?: + "" + ] + ) - if (bearbeitungsvermerke.empty) { - throw new IllegalArgumentException( - '''Befestigung Art of Befestigung «befestigung.identitaet.wert» has no Bearbeitungsvermerke.''' + // U: Ssks.konstruktive_Merkmale.Streuscheibe.Stellung + fillConditional( + row, + cols.getColumn(Streuscheibe_Stellung), + signal, + [isHauptbefestigung], + [ + signalReal?.signalRealAktivSchirm?. + streuscheibeBetriebsstellung?.translate ?: "" + ] + ) + + // X: Ssks.Anschluss.Schaltkasten.Bezeichnung + fillConditional( + row, + cols.getColumn(Schaltkasten_Bezeichnung), + signal, + [ + stellelement?.energie?.AEAAllg?. + aussenelementansteuerungArt?.wert == + ENUM_AUSSENELEMENTANSTEUERUNG_ART_OBJEKTCONTROLLER + ], + [ + stellelement?.energie?.bezeichnung?.bezeichnungAEA?.wert + ] + ) + + // Y: Ssks.Anschluss.Schaltkasten.Entfernung + fillConditional( + row, + cols.getColumn(Schaltkasten_Entfernung), + signal, + [controlBox !== null], + [ + distance(controlBox).toTableIntegerAgateUp + ] + ) + + // Z: Ssks.Anschluss.Schaltkasten_separat.Bezeichnung + fillConditional( + row, + cols.getColumn(Schaltkasten_Separat_Bezeichnung), + signal, + [hasSchaltkastenSeparatBezeichnung], + [ + stellelement?.information?.bezeichnung?.bezeichnungAEA?.wert + ] + ) + + // AA: Ssks.Anschluss.Dauerhaft_Nacht + if (signal.isSsksSignalNichtAndere) { + fillConditional( + row, + cols.getColumn(Dauerhaft_Nacht), + signal, + [isHauptbefestigung], + [ + (signalReal?.signalRealAktiv?.tunnelsignal?.wert == + ENUM_TUNNELSIGNAL_MIT_DAUERNACHTSCHALTUNG).translate + ] ) } - return '''«FOR b : bearbeitungsvermerke SEPARATOR ", "»« - b.value.bearbeitungsvermerkAllg.kurztext.wert»«ENDFOR»''' + // AB: Ssks.Signalisierung.Signalbegriffe_Schirm.Hp_Hl + fillIterable( + row, + cols.getColumn(Schirm_Hp_Hl), + signalRahmen, + [fillSignalisierungHpHl], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AC: Ssks.Signalisierung.Signalbegriffe_Schirm.Ks_Vr + fillIterable( + row, + cols.getColumn(Schirm_Ks_Vr), + signalRahmen, + [fillSignalisierungKsVr], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AD: Ssks.Signalisierung.Signalbegriffe_Schirm.Zl_Kl + fillIterable( + row, + cols.getColumn(Schirm_Zl_Kl), + signalRahmen, + [fillSignalisierungZlKl], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AE: Ssks.Signalisierung.Signalbegriffe_Schirm.Ra_Sh + fillSwitch( + row, + cols.getColumn(Schirm_Ra_Sh), + signal, + new Case( + [ + hasSignalbegriffID(Sh1) && + signalReal?.geltungsbereich.exists [ + wert === ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DV + ] + ], + ["Ra 12"] + ), + new Case( + [ + hasSignalbegriffID(Sh1) && + signalReal?.geltungsbereich.exists [ + wert == ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DS + ] + ], + ["Sh 1"] + ), + new Case([hasSignalbegriffID(Sh1)], ["x"]) + ) + + // AF: Ssks.Signalisierung.Signalbegriffe_Schirm.Zs + fillIterable( + row, + cols.getColumn(Schirm_Zs), + signalRahmen, + [fillSignalisierungSchirmZs], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AG: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_2 + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zs_2), + signalRahmen, + [fillSignalisierungSymbol(typeof(Zs2))], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AH: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_2v + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zs_2v), + signalRahmen, + [fillSignalisierungSymbol(typeof(Zs2v))], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AI: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_3 + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zs_3), + signalRahmen, + [fillSignalisierungSymbolGeschaltet(typeof(Zs3))], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AJ: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs_3v + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zs_3v), + signalRahmen, + [ + fillSignalisierungSymbolGeschaltet(typeof(Zs3v)) + ], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AK: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zs + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zs), + signalRahmen, + [fillSignalisierungZusatzanzeigerZs], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AL: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Zp + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Zp), + signalRahmen, + [fillSignalisierungZp], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AM: Ssks.Signalisierung.Signalbegriffe_Zusatzanzeiger.Kombination + fillIterable( + row, + cols.getColumn(Zusatzanzeiger_Kombination), + signalRahmen, + [fillSignalisierungKombination], + null, + [it], + ", " + ) + + // AN: Ssks.Signalisierung.Nachgeordnetes_Signal + fillIterable( + row, + cols.getColumn(Nachgeordnetes_Signal), + signalRahmen, + [ + filter[r|r.IDSignalNachordnung !== null].map [ r | + r.signalNachordnung.bezeichnung.bezeichnungTabelle.wert + ] + signal.container.signalRahmen.filter [ r | + r?.IDSignalNachordnung?.value?.identitaet?.wert == + signal.identitaet.wert + ].map [ r | + r.signal.bezeichnung.bezeichnungTabelle.wert + ] + ], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AO: Ssks.Signalisierung.Mastschild + fillIterable( + row, + cols.getColumn(Mastschild), + signalRahmen, + [fillSignalisierungMastschild], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AP: Ssks.Signalisierung.Weitere.Regelzeichnung_Nr + fillIterable( + row, + cols.getColumn(Weitere_Regelzeichnung_Nr), + signal, + [fillSignalisierungWeitere(signalRahmen)], + MIXED_STRING_COMPARATOR, + [it] + ) + + // AQ: Ssks.Sonstiges.Automatische_Fahrtstellung + fill( + row, + cols.getColumn(Automatische_Fahrtstellung), + signal, + [fillSonstigesAutomatischeFahrtstellung] + ) + + // AR: Ssks.Sonstiges.Dunkelschaltung + fill( + row, + cols.getColumn(Dunkelschaltung), + signal, + [fillSonstigesDunkelschaltung] + ) + + // AS: Ssks.Sonstiges.Durchfahrt_erlaubt + fill( + row, + cols.getColumn(Durchfahrt_Erlaubt), + signal, + [fillSonstigesDurchfahrtErlaubt] + ) + + // AT: Ssks.Sonstiges.Besetzte_Ausfahrt + fillConditional( + row, + cols.getColumn(Besetzte_Ausfahrt), + signal, + [signalFstr?.besetzteAusfahrt?.wert !== null], + [signalFstr.besetzteAusfahrt.wert.translate] + ) + + // AU: Ssks.Sonstiges.Loeschung_Zs_1__Zs_7 + fill( + row, + cols.getColumn(Loeschung_Zs_1__Zs_7), + signalRahmen, + [fillSonstigesLoeschungZs1Zs7] + ) + + // AV: Ssks.Sonstiges.Ueberwachung.Zs_2 + fillIterable( + row, + cols.getColumn(Ueberwachung_Zs_2), + signal, + [ + val zs2 = getSignalbegriffe(Zs2).filterNull + // Is there any Zs2 without zs2Ueberwacht = true? + if (zs2.empty || zs2.findFirst [ + signalSignalbegriffAllg?.zs2Ueberwacht === null || + signalSignalbegriffAllg.zs2Ueberwacht.wert == false + ] !== null) + return #[""] + + return zs2.map [ + signalbegriffID?.symbol ?: "?" + ] + ], + null + ) + + // AW: Ssks.Sonstiges.Ueberwachung.Zs_2v + fillIterable( + row, + cols.getColumn(Ueberwachung_Zs_2v), + signal, + [ + val zs2v = getSignalbegriffe(Zs2v).filterNull + // Is there any Zs2v without zs2Ueberwacht = true? + if (zs2v.empty || zs2v.findFirst [ + signalSignalbegriffAllg?.zs2Ueberwacht === null || + signalSignalbegriffAllg.zs2Ueberwacht.wert == false + ] !== null) + return #[""] + + return zs2v.map [ + signalbegriffID?.symbol ?: "?" + ] + ], + null + ) + + // AX: Ssks.Bemerkung + fill( + row, + cols.getColumn(Bemerkung), + signal, + [fillBemerkung(signalRahmen, row)] + ) } + private static def boolean isSsksSignal(Signal signal) { if (signal?.signalFiktiv !== null && !signal?.signalFiktiv?.fiktivesSignalFunktion.exists [ @@ -993,15 +661,6 @@ class .simpleName»: «e.message» - failed to transform table contents''', e) ENUM_SIGNAL_FUNKTION_ALLEINSTEHENDES_ZUSATZSIGNAL) } - private static def List fillRegelzeichnung( - List signalRahmen) { - return signalRahmen.map [ - signalBefestigung.IDRegelzeichnung.map [ z | - z?.value.fillRegelzeichnung - ] - ].flatten.toList - } - private static def boolean hasSchaltkastenSeparatBezeichnung( Signal signal) { val stellelement = signal.stellelement @@ -1507,4 +1166,65 @@ class .simpleName»: «e.message» - failed to transform table contents''', e) } return BigDecimal.valueOf(c1.distance(c2)) } + + + override protected getRelevantSignal( + MultiContainer_AttributeGroup contanier) { + return contanier.signal.filter[isSsksSignal] + } + + override protected getAbstandMastMitteColumn() { + return Map.of(ENUMLinksRechts.ENUM_LINKS_RECHTS_LINKS, + cols.getColumn(Mastmitte_Links), + ENUMLinksRechts.ENUM_LINKS_RECHTS_RECHTS, + cols.getColumn(Mastmitte_Rechts)) + } + + override protected getArtRegelzeichnungColumn() { + return cols.getColumn(Fundament_Art_Regelzeichnung) + } + + override protected getBefestigungColumn() { + return cols.getColumn(Befestigung) + } + + override protected getBezeichnungColumn() { + return cols.getColumn(Bezeichnung_Signal) + } + + override protected getFundamentHoeheColumn() { + return cols.getColumn(Fundament_Hoehe) + } + + override protected getKmColumn() { + return cols.getColumn(Km) + } + + override protected getLichtraumProfilColumn() { + return cols.getColumn(Lichtraumprofil) + } + + override protected getRegelzeichnungColumn() { + return cols.getColumn(Anordnung_Regelzeichnung) + } + + override protected getStreckeColumn() { + return cols.getColumn(Strecke) + } + + override protected getUeberhoehungColumn() { + return cols.getColumn(Ueberhoehung) + } + + override protected handledThrowException(TMFactory factory, Signal signal, + Exception e) { + val TableRow row = factory.newTableRow(signal); + fill( + row, + cols.getColumn(Reales_Signal), + signal, + [throw new RuntimeException(e)] + ) + } + } diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxColumns.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxColumns.java new file mode 100644 index 0000000000..1248b4b997 --- /dev/null +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxColumns.java @@ -0,0 +1,94 @@ +/** + * Copyright (c) 2026 DB InfraGO AG and others + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v2.0 which is available at + * https://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + */ +package org.eclipse.set.feature.table.pt1.sskx; + +/** + * Symbolic addressing for Sskx columns. + * + * @author Truong + */ +@SuppressWarnings("nls") +public class SskxColumns { + /** + * Sskx.Bezeichnung_Signal + */ + public static final String Bezeichnung_Signal = "A"; + + /** + * Sskx.Standortmerkmale.Standort.Strecke + */ + public static final String Strecke = "B"; + + /** + * Sskx.Standortmerkmale.Standort.km + */ + public static final String km = "C"; + + /** + * Sskx.Standortmerkmale.Standort.Gleis + */ + public static final String Gleis = "D"; + + /** + * Sskx.Standortmerkmale.Lichtraumprofil + */ + public static final String Lichtraumprofil = "E"; + + /** + * Sskx.Standortmerkmale.Ueberhoehung + */ + public static final String Ueberhoehung = "F"; + + /** + * Sskx.Standortmerkmale.Abstand_Mastmitte.links + */ + public static final String Abstand_Mastmitte_links = "G"; + + /** + * Sskx.Standortmerkmale.Abstand_Mastmitte.rechts + */ + public static final String Abstand_Mastmitte_rechts = "H"; + + /** + * Sskx.konstruktive_Merkmale.Anordnung.Befestigung + */ + public static final String Befestigung = "I"; + + /** + * Sskx.konstruktive_Merkmale.Anordnung.Regelzeichnung + */ + public static final String Regelzeichnung = "J"; + + /** + * Sskx.konstruktive_Merkmale.Fundament.Art_Regelzeichnung + */ + public static final String Art_Regelzeichnung = "K"; + + /** + * Sskx.konstruktive_Merkmale.Fundament.Hoehe + */ + public static final String Hoehe = "L"; + + /** + * Sskx.Signalisierung.Signalbegriffe.Bezeichnung + */ + public static final String Signalbegriffe_Bezeichnung = "M"; + + /** + * Sskx.Signalisierung.Signalbegriffe.Regelzeichnung + */ + public static final String Signalbegriffe_Regelzeichnung = "N"; + + /** + * Sskx.Bemerkung + */ + public static final String Bemerkung = "O"; +} diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxDescriptionService.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxDescriptionService.java new file mode 100644 index 0000000000..03cfe4b4bf --- /dev/null +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxDescriptionService.java @@ -0,0 +1,45 @@ +/** + * Copyright (c) 2024 DB InfraGO AG and others + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v2.0 which is available at + * https://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + */ +package org.eclipse.set.feature.table.pt1.sskx; + +import org.eclipse.set.core.services.part.PartDescriptionService; +import org.eclipse.set.feature.table.AbstractESTWSupplementTableDesciption; +import org.eclipse.set.feature.table.pt1.messages.Messages; +import org.osgi.service.component.annotations.Component; +import org.osgi.service.component.annotations.Reference; + +/** + * Part description for Sskz table view. + * + * @author Truong + */ +@Component(service = PartDescriptionService.class) +public class SskxDescriptionService + extends AbstractESTWSupplementTableDesciption { + @Reference + Messages messages; + + @Override + protected String getToolboxViewName() { + return messages.SskxDescriptionService_ViewName; + } + + @Override + protected String getToolboxViewTooltip() { + return messages.SskxDescriptionService_ViewTooltip; + } + + @Override + protected String getTableShortcut() { + return messages.ToolboxTableNameSskxShort; + } + +} diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformationService.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformationService.java new file mode 100644 index 0000000000..e27c34ed91 --- /dev/null +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformationService.java @@ -0,0 +1,113 @@ +/** + * Copyright (c) 2024 DB InfraGO AG and others + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v2.0 which is available at + * https://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + */ +package org.eclipse.set.feature.table.pt1.sskx; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import org.eclipse.e4.core.services.events.IEventBroker; +import org.eclipse.set.basis.constants.Events; +import org.eclipse.set.core.services.enumtranslation.EnumTranslationService; +import org.eclipse.set.core.services.graph.BankService; +import org.eclipse.set.feature.table.PlanPro2TableTransformationService; +import org.eclipse.set.feature.table.pt1.AbstractPlanPro2TableTransformationService; +import org.eclipse.set.feature.table.pt1.messages.Messages; +import org.eclipse.set.ppmodel.extensions.container.MultiContainer_AttributeGroup; +import org.eclipse.set.ppmodel.extensions.utils.TableNameInfo; +import org.eclipse.set.utils.table.TableModelTransformator; +import org.osgi.service.component.annotations.Component; +import org.osgi.service.component.annotations.Reference; +import org.osgi.service.event.Event; +import org.osgi.service.event.EventAdmin; +import org.osgi.service.event.EventConstants; +import org.osgi.service.event.EventHandler; + +/** + * Service for creating the Sskz table model. org.eclipse.set.feature.table + * + * @author Truong + */ +@Component(service = { + PlanPro2TableTransformationService.class }, immediate = true, property = { + "table.category=supplement-estw", "table.shortcut=sskx", + EventConstants.EVENT_TOPIC + "=" + Events.CLOSE_PART, + EventConstants.EVENT_TOPIC + "=" + Events.CLOSE_SESSION }) +public class SskxTransformationService extends + AbstractPlanPro2TableTransformationService implements EventHandler { + + @Reference + private Messages messages; + + @Reference + private EnumTranslationService enumTranslationService; + + @Reference + private BankService bankService; + @Reference + private EventAdmin eventAdmin; + + /** + * constructor. + */ + public SskxTransformationService() { + super(); + } + + @Override + protected String getTableHeading() { + return messages.SskxTableView_Heading; + } + + @Override + public TableNameInfo getTableNameInfo() { + return new TableNameInfo(messages.ToolboxTableNameSskxLong, + messages.ToolboxTableNameSskxPlanningNumber, + messages.ToolboxTableNameSskxShort); + } + + @Override + public TableModelTransformator createTransformator() { + return new SskxTransformator(cols, enumTranslationService, bankService, + eventAdmin, messages.ToolboxTableNameSskxShort); + } + + @Override + public void handleEvent(final Event event) { + final String property = (String) event.getProperty(IEventBroker.DATA); + if (messages.ToolboxTableNameSskxShort.toLowerCase().equals(property) + || event.getTopic().equals(Events.CLOSE_SESSION)) { + Thread.getAllStackTraces().keySet().forEach(thread -> { + if (thread.getName() + .toLowerCase() + .startsWith(messages.ToolboxTableNameSskxShort + .toLowerCase())) { + thread.interrupt(); + } + }); + } + } + + @Override + protected String getShortcut() { + return messages.ToolboxTableNameSskxShort.toLowerCase(); + } + + @Override + protected List getTopologicalColumnPosition() { + return List.of(SskxColumns.Gleis, SskxColumns.Lichtraumprofil); + } + + @Override + protected Map, String> getFootnotesColumnReferences() { + return Collections.emptyMap(); + } +} diff --git a/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformator.java b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformator.java new file mode 100644 index 0000000000..d36ff69967 --- /dev/null +++ b/java/bundles/org.eclipse.set.feature.table.pt1/src/org/eclipse/set/feature/table/pt1/sskx/SskxTransformator.java @@ -0,0 +1,310 @@ +/** + * Copyright (c) 2026 DB InfraGO AG and others + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v2.0 which is available at + * https://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + * + */ +package org.eclipse.set.feature.table.pt1.sskx; + +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Stream; + +import org.eclipse.set.core.services.enumtranslation.EnumTranslationService; +import org.eclipse.set.core.services.graph.BankService; +import org.eclipse.set.feature.table.pt1.ssks.AbstractSignalTableTransform; +import org.eclipse.set.model.planpro.BasisTypen.ENUMLinksRechts; +import org.eclipse.set.model.planpro.Basisobjekte.Basis_Objekt; +import org.eclipse.set.model.planpro.Geodaten.Technischer_Punkt; +import org.eclipse.set.model.planpro.Gleis.Gleis_Bezeichnung; +import org.eclipse.set.model.planpro.Signalbegriffe_Ril_301.Ne14; +import org.eclipse.set.model.planpro.Signalbegriffe_Ril_301.OzBk; +import org.eclipse.set.model.planpro.Signalbegriffe_Struktur.Signalbegriff_ID_TypeClass; +import org.eclipse.set.model.planpro.Signale.ENUMBeleuchtet; +import org.eclipse.set.model.planpro.Signale.ENUMGeltungsbereich; +import org.eclipse.set.model.planpro.Signale.Signal; +import org.eclipse.set.model.planpro.Signale.Signal_Rahmen; +import org.eclipse.set.model.planpro.Signale.Signal_Signalbegriff; +import org.eclipse.set.model.tablemodel.ColumnDescriptor; +import org.eclipse.set.model.tablemodel.TableRow; +import org.eclipse.set.model.tablemodel.extensions.FootnoteExtensions; +import org.eclipse.set.ppmodel.extensions.BasisAttributExtensions; +import org.eclipse.set.ppmodel.extensions.BereichObjektExtensions; +import org.eclipse.set.ppmodel.extensions.EObjectExtensions; +import org.eclipse.set.ppmodel.extensions.SignalExtensions; +import org.eclipse.set.ppmodel.extensions.SignalRahmenExtensions; +import org.eclipse.set.ppmodel.extensions.container.MultiContainer_AttributeGroup; +import org.eclipse.set.utils.table.TMFactory; +import org.osgi.service.event.EventAdmin; + +import com.google.common.collect.Streams; + +/** + * Table transformation for Tabelle der Tafeln (Sskx). + * + * @author Truong + */ +public class SskxTransformator extends AbstractSignalTableTransform { + + private static final String SIGNAL_BEGRIFFE_BEZEICHNUNG_SEPERATOR = ", "; //$NON-NLS-1$ + + /** + * Constructor + * + * @param cols + * the table columns + * @param bankService + * the {@link BankService} + * @param enumTranslationService + * {@link EnumTranslationService} + * @param eventAdmin + * the {@link EventAdmin} + * @param tableShortcut + * the table shortcut + */ + SskxTransformator(final Set cols, + final EnumTranslationService enumTranslationService, + final BankService bankingService, final EventAdmin eventAdmin, + final String tableShortCut) { + super(cols, enumTranslationService, bankingService, eventAdmin, + tableShortCut); + } + + private static Predicate generalCondition() { + return signal -> { + if (signal.getSignalReal() == null) { + return false; + } + + if (signal.getSignalReal().getSignalRealAktiv() != null + || signal.getSignalReal() + .getSignalRealAktivSchirm() != null) { + return false; + } + + final Set signalbegriffe = SignalExtensions + .getSignalbegriffe(signal); + return signalbegriffe.stream() + .map(Signal_Signalbegriff::getSignalbegriffID) + .noneMatch(begriff -> begriff instanceof Ne14 + || begriff instanceof OzBk); + }; + } + + private static List getRelevantGleisBezeichnuung( + final Signal signal) { + final MultiContainer_AttributeGroup container = BasisAttributExtensions + .getContainer(signal); + return Streams.stream(container.getGleisBezeichnung()) + .filter(g -> BereichObjektExtensions.contains(g, signal)) + .toList(); + } + + @Override + protected Iterable getRelevantSignal( + final MultiContainer_AttributeGroup container) { + return Streams.stream(container.getSignal()) + .filter(generalCondition()) + .toList(); + } + + @Override + protected void fillSpecifyColumns(final TableRow row, + final MultiContainer_AttributeGroup container, final Signal signal, + final boolean isHauptbefestigung, + final List signalRahmen) { + + // D: Sskx.Standortmerkmale.Standort.Gleis + fillIterable(row, getColumn(cols, SskxColumns.Gleis), signal, + s -> getRelevantGleisBezeichnuung(signal).stream() + .map(gleis -> EObjectExtensions + .getNullableObject(gleis, + g -> g.getBezeichnung() + .getBezGleisBezeichnung() + .getWert()) + .orElse(null)) + .filter(Objects::nonNull) + .toList(), + MIXED_STRING_COMPARATOR); + + // M: Sskx.Signalisierung.Signalbegriffe.Bezeichnung + fillIterable(row, + getColumn(cols, SskxColumns.Signalbegriffe_Bezeichnung), signal, + this::transformSignalbegriffeBezeichnung, + MIXED_STRING_COMPARATOR, s -> s, + SIGNAL_BEGRIFFE_BEZEICHNUNG_SEPERATOR); + + // Sskx.Bermerkung + fillFootnotes(row, signal); + fillIterable(row, getColumn(cols, SskxColumns.Bemerkung), signalRahmen, + rahmen -> rahmen.stream().map(r -> { + final boolean isAngestrahlt = Streams + .stream(SignalRahmenExtensions.getSignalbegriffe(r)) + .anyMatch(begriffe -> EObjectExtensions + .getNullableObject(begriffe, + b -> b.getSignalSignalbegriffAllg() + .getBeleuchtet() + .getWert()) + .orElse(null) == ENUMBeleuchtet.ENUM_BELEUCHTET_ANGESTRAHLT); + if (isAngestrahlt) { + return "angestrahlt"; //$NON-NLS-1$ + } + final Basis_Objekt befestigungBauwerk = EObjectExtensions + .getNullableObject(r, + e -> e.getIDSignalBefestigung() + .getValue() + .getIDBefestigungBauwerk() + .getValue()) + .orElse(null); + if (befestigungBauwerk != null + && befestigungBauwerk instanceof final Technischer_Punkt tp) { + return "Befestigung an " //$NON-NLS-1$ + + tp.getTPBeschreibung().getWert(); + } + + if (r.getRahmenHoehe() != null + && r.getRahmenHoehe().getWert() != null) { + return "Rahmenhöhen beachten"; //$NON-NLS-1$ + } + return null; + }).filter(Objects::nonNull).toList(), MIXED_STRING_COMPARATOR, + s -> s, SIGNAL_BEGRIFFE_BEZEICHNUNG_SEPERATOR); + } + + @Override + protected ColumnDescriptor getFundamentHoeheColumn() { + return getColumn(cols, SskxColumns.Hoehe); + } + + @Override + protected ColumnDescriptor getArtRegelzeichnungColumn() { + return getColumn(cols, SskxColumns.Art_Regelzeichnung); + } + + @Override + protected ColumnDescriptor getRegelzeichnungColumn() { + return getColumn(cols, SskxColumns.Regelzeichnung); + } + + @Override + protected ColumnDescriptor getBefestigungColumn() { + return getColumn(cols, SskxColumns.Befestigung); + } + + @Override + protected Map getAbstandMastMitteColumn() { + return Map.of(ENUMLinksRechts.ENUM_LINKS_RECHTS_LINKS, + getColumn(cols, SskxColumns.Abstand_Mastmitte_links), + ENUMLinksRechts.ENUM_LINKS_RECHTS_RECHTS, + getColumn(cols, SskxColumns.Abstand_Mastmitte_rechts)); + } + + @Override + protected ColumnDescriptor getUeberhoehungColumn() { + return getColumn(cols, SskxColumns.Ueberhoehung); + } + + @Override + protected ColumnDescriptor getLichtraumProfilColumn() { + return getColumn(cols, SskxColumns.Lichtraumprofil); + } + + @Override + protected ColumnDescriptor getStreckeColumn() { + return getColumn(cols, SskxColumns.Strecke); + } + + @Override + protected ColumnDescriptor getKmColumn() { + return getColumn(cols, SskxColumns.km); + } + + @Override + protected ColumnDescriptor getBezeichnungColumn() { + return getColumn(cols, SskxColumns.Bezeichnung_Signal); + } + + @Override + protected void handledThrowException(final TMFactory factory, + final Signal signal, final Exception e) { + // do nothing + } + + private List transformSignalbegriffeBezeichnung( + final Signal signal) { + final List geltungsbereich = signal.getSignalReal() + .getGeltungsbereich() + .stream() + .map(bereich -> bereich.getWert()) + .filter(Objects::nonNull) + .toList(); + if (geltungsbereich.isEmpty()) { + return getSignalbegriffeBezeichnung(signal, + signalbegriffBezeichnungSelections(null)); + } + return geltungsbereich.stream().flatMap(geltung -> switch (geltung) { + case ENUM_GELTUNGSBEREICH_DS -> getSignalbegriffeBezeichnung(signal, + signalbegriffBezeichnungSelections( + ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DS)) + .stream(); + case ENUM_GELTUNGSBEREICH_DV -> getSignalbegriffeBezeichnung(signal, + signalbegriffBezeichnungSelections( + ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DV)) + .stream(); + default -> Stream.empty(); + }).toList(); + } + + private static List> signalbegriffBezeichnungSelections( + final ENUMGeltungsbereich geltung) { + final LinkedList> selectBezeichnungFuncs = new LinkedList<>(); + // When Geltungsbereich_DS or without Geltungsbereich + if (geltung == ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DS + || geltung == null) { + selectBezeichnungFuncs + .add(Signalbegriff_ID_TypeClass::getKurzbezeichnungDS); + } + + // When Geltungsbereich_DV or without Geltungsbereich + if (geltung == ENUMGeltungsbereich.ENUM_GELTUNGSBEREICH_DV + || geltung == null) { + selectBezeichnungFuncs + .add(Signalbegriff_ID_TypeClass::getKurzbezeichnungDS); + } + + selectBezeichnungFuncs + .add(Signalbegriff_ID_TypeClass::getLangbezeichnung); + selectBezeichnungFuncs.add(FootnoteExtensions::getSignalBregiffIDName); + return selectBezeichnungFuncs; + } + + private static List getSignalbegriffeBezeichnung( + final Signal signal, + final List> selectBezeichnungFunc) { + return SignalExtensions.getSignalbegriffe(signal) + .stream() + .map(Signal_Signalbegriff::getSignalbegriffID) + .map(signalBegriffe -> { + for (final Function function : selectBezeichnungFunc) { + final String bezeichnung = function + .apply(signalBegriffe); + if (bezeichnung != null && !bezeichnung.isEmpty()) { + return bezeichnung; + } + } + return null; + }) + .filter(Objects::nonNull) + .toList(); + + } +} diff --git a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/AbstractESTWSupplementTableDesciption.java b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/AbstractESTWSupplementTableDesciption.java index bc200d8e80..877e3ebfd6 100644 --- a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/AbstractESTWSupplementTableDesciption.java +++ b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/AbstractESTWSupplementTableDesciption.java @@ -10,8 +10,8 @@ */ package org.eclipse.set.feature.table; +import org.eclipse.set.basis.constants.ToolboxConstants; import org.eclipse.set.basis.viewgroups.ToolboxViewGroup; -import org.eclipse.set.utils.table.TableInfo.Pt1TableCategory; import org.eclipse.set.utils.viewgroups.SetViewGroups; /** @@ -27,6 +27,6 @@ public ToolboxViewGroup getToolboxViewGroup() { @Override protected String getTableIdPrefix() { - return Pt1TableCategory.ESTW_SUPPLEMENT.getId(); + return ToolboxConstants.ESTW_SUPPLEMENT_PART_ID_PREFIX; } } diff --git a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceImpl.java b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceImpl.java index 2b293b0a77..2c40c20071 100644 --- a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceImpl.java +++ b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceImpl.java @@ -181,7 +181,6 @@ private Table createDiffStateTable(final TableInfo tableInfo, final IModelSession modelSession) { final PlanPro2TableTransformationService modelService = getModelService( tableInfo); - final Table startTable = modelService .transform(PlanProSchnittstelleExtensions.getContainer( modelSession.getPlanProSchnittstelle(), @@ -403,7 +402,6 @@ public Table transformToTable(final TableInfo tableInfo, getModelService(tableInfo).buildHeading(emptyTable); return emptyTable; } - final Table resultTable = TableServiceUtils.filterRequestValue( EcoreUtil.copy(table), tableInfo, tableType, modelSession, controlAreaIds); diff --git a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java index 3e3d4d24d2..c75941f85a 100644 --- a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java +++ b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java @@ -37,6 +37,7 @@ import org.eclipse.set.model.planpro.Basisobjekte.Ur_Objekt; import org.eclipse.set.model.planpro.Block.Block_Anlage; import org.eclipse.set.model.planpro.Block.Block_Element; +import org.eclipse.set.model.planpro.Signale.Signal; import org.eclipse.set.model.tablemodel.CellContent; import org.eclipse.set.model.tablemodel.CompareFootnoteContainer; import org.eclipse.set.model.tablemodel.CompareStateCellContent; @@ -51,6 +52,7 @@ import org.eclipse.set.ppmodel.extensions.BasisAttributExtensions; import org.eclipse.set.ppmodel.extensions.EObjectExtensions; import org.eclipse.set.ppmodel.extensions.MultiContainer_AttributeGroupExtensions; +import org.eclipse.set.ppmodel.extensions.SignalExtensions; import org.eclipse.set.ppmodel.extensions.StellBereichExtensions; import org.eclipse.set.ppmodel.extensions.UrObjectExtensions; import org.eclipse.set.ppmodel.extensions.container.MultiContainer_AttributeGroup; @@ -268,7 +270,6 @@ protected static Table filterRequestValue(final Table table, .isPlanningObject(group.getLeadingObject())); return result; } - result.getTablecontent().getRowgroups().removeIf(group -> { final Pair initalFinalObj = getInitalFinalObj( group.getLeadingObject(), modelsession); @@ -282,13 +283,28 @@ protected static Table filterRequestValue(final Table table, .toList(); return !UrObjectExtensions.isPlanningObject(leadingObj) || !areas.isEmpty() && areas.stream() - .noneMatch(area -> StellBereichExtensions - .isInControlArea(area, leadingObj)); + .noneMatch(area -> isLeadingObjecBelongToArea( + leadingObj, area, tableInfo)); }); return result; } + private static boolean isLeadingObjecBelongToArea( + final Ur_Objekt leadingObj, final Stell_Bereich area, + final TableInfo tableInfo) { + // Specify handle for Signal tabelle + if (leadingObj instanceof final Signal signal) { + if (tableInfo.shortcut().equalsIgnoreCase("Ssks")) { //$NON-NLS-1$ + return SignalExtensions.isSsksSignalBelongToArea(signal, area); + } else if (tableInfo.shortcut().equalsIgnoreCase("Sskx")) { //$NON-NLS-1$ + return SignalExtensions.isSskxSignalBelongToArea(signal, area); + } + } + + return StellBereichExtensions.isInControlArea(area, leadingObj); + } + private static Table filterTableByState(final Table table, final TableType tableType) { if (tableType == TableType.DIFF || tableType == TableType.SINGLE) { @@ -306,9 +322,8 @@ private static Table filterTableByState(final Table table, if (compareStateRows.isEmpty()) { return table; } - compareStateRows.forEach(row -> { - transformCompareCellContent(row, tableType); - }); + compareStateRows + .forEach(row -> transformCompareCellContent(row, tableType)); TableExtensions.getTableRows(table) .stream() diff --git a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/overview/TableErrorTableView.java b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/overview/TableErrorTableView.java index 22797c0440..6a850ba312 100644 --- a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/overview/TableErrorTableView.java +++ b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/overview/TableErrorTableView.java @@ -14,7 +14,6 @@ import org.eclipse.emf.common.util.ECollections; import org.eclipse.nebula.widgets.nattable.NatTable; import org.eclipse.nebula.widgets.nattable.layer.cell.ILayerCell; -import org.eclipse.set.basis.constants.ToolboxConstants; import org.eclipse.set.basis.files.ToolboxFile; import org.eclipse.set.core.services.Services; import org.eclipse.set.core.services.enumtranslation.EnumTranslationService; @@ -148,13 +147,9 @@ public String getTableShortcut() { @Override public String getTableCategory() { - if (part.getToolboxPart() - .getElementId() - .startsWith( - ToolboxConstants.ESTW_TABLE_PART_ID_PREFIX)) { - return Pt1TableCategory.ESTW.getId(); - } - return Pt1TableCategory.ETCS.getId(); + final String elementId = part.getToolboxPart().getElementId(); + return Pt1TableCategory.getCategoryFromPartId(elementId) + .getId(); } }; } diff --git a/java/bundles/org.eclipse.set.feature/rootdir/data/export/excel/sskx_vorlage.xlsx b/java/bundles/org.eclipse.set.feature/rootdir/data/export/excel/sskx_vorlage.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..2a96d2119e5db8ead853584f6b39f6f51e6f7194 GIT binary patch literal 24948 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 getPrefix( } final Signalbegriff_ID_TypeClass signalBegriffId = signalBegriff .getSignalbegriffID(); - final String prefix = getSignalBregiffIDName(signalBegriffId) - .replace("_", " ");//$NON-NLS-1$ //$NON-NLS-2$ + final String prefix = getSignalBregiffIDName(signalBegriffId); if (withSymbol && signalBegriffId.getSymbol() != null) { return new Pair<>(prefix, signalBegriffId.getSymbol()); } return new Pair<>(prefix, null); } - private static String getSignalBregiffIDName( + /** + * @param signalBegriffId + * the {@link Signalbegriff_ID_TypeClass} + * @return the name of this signalbegriff + */ + public static String getSignalBregiffIDName( final Signalbegriff_ID_TypeClass signalBegriffId) { try { return signalBegriffId.eClass() .getEAnnotation(ExtendedMetaData.ANNOTATION_URI) .getDetails() - .get("name"); //$NON-NLS-1$ + .get("name") //$NON-NLS-1$ + .replace("_", " "); //$NON-NLS-1$ //$NON-NLS-2$ } catch (final Exception e) { return signalBegriffId.eClass().getName(); } diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend index 59e093738c..23b46c09af 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend @@ -462,7 +462,7 @@ class FstrZugRangierExtensions extends BasisObjektExtensions { } // TODO: 2. Condition for target signal isn't clearly return startSignal !== null && - startSignal.isBelongToControlArea(controlArea) + startSignal.isSsksSignalBelongToArea(controlArea) } def static Signal getStartSignal(Fstr_Zug_Rangier fstrZug) { diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/SignalExtensions.xtend b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/SignalExtensions.xtend index 72e17dc64f..0fa8b6d78c 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/SignalExtensions.xtend +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/SignalExtensions.xtend @@ -10,6 +10,7 @@ package org.eclipse.set.ppmodel.extensions import java.math.BigDecimal import java.util.Collections +import java.util.LinkedList import java.util.List import java.util.Set import org.eclipse.core.runtime.Assert @@ -29,6 +30,8 @@ import org.eclipse.set.model.planpro.Ortung.FMA_Komponente import org.eclipse.set.model.planpro.Ortung.Schaltmittel_Zuordnung import org.eclipse.set.model.planpro.Signalbegriffe_Ril_301.Zs3v import org.eclipse.set.model.planpro.Signalbegriffe_Struktur.Signalbegriff_ID_TypeClass +import org.eclipse.set.model.planpro.Signale.ENUMBefestigungArt +import org.eclipse.set.model.planpro.Signale.ENUMRahmenArt import org.eclipse.set.model.planpro.Signale.Signal import org.eclipse.set.model.planpro.Signale.Signal_Befestigung import org.eclipse.set.model.planpro.Signale.Signal_Rahmen @@ -56,6 +59,7 @@ import static extension org.eclipse.set.ppmodel.extensions.SignalbegriffExtensio import static extension org.eclipse.set.ppmodel.extensions.StellelementExtensions.* import static extension org.eclipse.set.ppmodel.extensions.utils.CollectionExtensions.* import static extension org.eclipse.set.ppmodel.extensions.utils.Debug.* +import static extension org.eclipse.set.ppmodel.extensions.utils.IterableExtensions.* /** * This class extends {@link Signal}. @@ -430,7 +434,7 @@ class SignalExtensions extends PunktObjektExtensions { // Tolerant distance in meter static final double tolerantDistance = 1 - def static boolean isBelongToControlArea(Signal signal, + def static boolean isSsksSignalBelongToArea(Signal signal, Stell_Bereich controlArea) { val stellElement = signal.stellelement if (stellElement?.IDEnergie?.value.isBelongToControlArea(controlArea) || @@ -473,6 +477,10 @@ class SignalExtensions extends PunktObjektExtensions { } return false } + + def static boolean isSskxSignalBelongToArea(Signal signal, Stell_Bereich area) { + return area.contains(signal, tolerantDistance) + } def static List getFmaKomponenten(Signal signal) { val fstrFahrwegs = signal.container.fstrFahrweg.filter [ @@ -489,4 +497,36 @@ class SignalExtensions extends PunktObjektExtensions { def static String getTableBezeichnung(Signal signal) { return signal?.bezeichnung?.bezeichnungTabelle?.wert } + + def static List> getBefestigungsgruppen( + Signal signal, List mastTypeOfSignalWithTwoMast) { + val result = new LinkedList> + val rahmen = signal.signalRahmen + val befestigungen = rahmen.map[it -> signalBefestigung].distinctBy [ + value + ].toList + + switch mast : befestigungen.filter [ + mastTypeOfSignalWithTwoMast.contains( + value?.signalBefestigungAllg?.befestigungArt?.wert) + ] { + // condition "zwei Befestigungen" + case mast.size == 2: { + val mainMast = befestigungen.filter [ + key.rahmenArt?.wert == ENUMRahmenArt.ENUM_RAHMEN_ART_SCHIRM + ].filter [ + mastTypeOfSignalWithTwoMast.contains( + value.signalBefestigungAllg?.befestigungArt?.wert) + ].map[value].toSet + val subMast = mast.map[value].filter[!mainMast.contains(it)] + result.add(0, mainMast.toList) + result.add(1, subMast.toList) + } + case mast.size > 2: + throw new IllegalArgumentException('''«signal.bezeichnung?.bezeichnungAussenanlage?.toString» has more than two Befestigung Signal''') + default: + result.add(befestigungen.map[value].toList) + } + return result + } } diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java index d6df9e48e5..0ce2cb5185 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java @@ -51,7 +51,6 @@ import org.eclipse.set.model.planpro.Ortung.Zugeinwirkung; import org.eclipse.set.model.planpro.PZB.PZB_Element; import org.eclipse.set.model.planpro.Schluesselabhaengigkeiten.Schloss; -import org.eclipse.set.model.planpro.Signale.Signal; import org.eclipse.set.model.planpro.Weichen_und_Gleissperren.W_Kr_Gsp_Element; import org.eclipse.set.model.planpro.Weichen_und_Gleissperren.W_Kr_Gsp_Komponente; import org.eclipse.set.model.planpro.Zugnummernmeldeanlage.ZN_ZBS; @@ -219,6 +218,7 @@ public static boolean isInControlArea(final List areas, * the element * @return true, if the element belong to the area */ + @SuppressWarnings("nls") public static boolean isInControlArea(final Stell_Bereich area, final Ur_Objekt object) { if (object == null) { @@ -239,8 +239,6 @@ public static boolean isInControlArea(final Stell_Bereich area, .isBelongToControlArea(zugeinwirkung, area); case final PZB_Element pzb -> PZBElementExtensions .isBelongToControlArea(pzb, area); - case final Signal signal -> SignalExtensions - .isBelongToControlArea(signal, area); case final Technik_Standort standort -> TechnikStandortExtensions .isBelongToControlArea(standort, area); case final Bedien_Standort standort -> BedienStandortExtensions diff --git a/java/bundles/org.eclipse.set.swtbot/SWTBot.launch b/java/bundles/org.eclipse.set.swtbot/SWTBot.launch index ea4a8e20b8..83df9d82c0 100644 --- a/java/bundles/org.eclipse.set.swtbot/SWTBot.launch +++ b/java/bundles/org.eclipse.set.swtbot/SWTBot.launch @@ -26,22 +26,22 @@ - + - + - + - + @@ -438,9 +438,6 @@ - - - @@ -519,6 +516,7 @@ + @@ -566,12 +564,16 @@ + + + + diff --git a/java/bundles/org.eclipse.set.swtbot/src/org/eclipse/set/swtbot/table/PtTable.java b/java/bundles/org.eclipse.set.swtbot/src/org/eclipse/set/swtbot/table/PtTable.java index 579a47bea5..b1c9e45295 100644 --- a/java/bundles/org.eclipse.set.swtbot/src/org/eclipse/set/swtbot/table/PtTable.java +++ b/java/bundles/org.eclipse.set.swtbot/src/org/eclipse/set/swtbot/table/PtTable.java @@ -75,6 +75,8 @@ public record PtTable(String shortcut, String tableName, String category, "Sszw – ETCS Melde- und Kommandoanschaltung Weichen", "etcs", List.of(0)), new PtTable("sskz", "Sskz – Zuordnungstabelle FEAK/FEAS", - "supplement-estw", List.of(0))); + "supplement-estw", List.of(0)), + new PtTable("sskx", "Sskx – Tabelle der Tafeln", "supplement-estw", + List.of(0))); } diff --git a/java/bundles/org.eclipse.set.utils.table/src/org/eclipse/set/utils/table/TableInfo.java b/java/bundles/org.eclipse.set.utils.table/src/org/eclipse/set/utils/table/TableInfo.java index b1d080f214..b530fba3c9 100644 --- a/java/bundles/org.eclipse.set.utils.table/src/org/eclipse/set/utils/table/TableInfo.java +++ b/java/bundles/org.eclipse.set.utils.table/src/org/eclipse/set/utils/table/TableInfo.java @@ -13,6 +13,7 @@ import java.util.HashMap; import java.util.Map; +import org.eclipse.set.basis.constants.ToolboxConstants; import org.eclipse.set.utils.viewgroups.SetViewGroups; /** @@ -88,6 +89,55 @@ public static Pt1TableCategory getCategoryEnum( final String categoryId) { return categories.get(categoryId); } + + /** + * Get table part prefix from category + * + * @param categoryId + * the {@link Pt1TableCategory#getId()} + * @return the table part prefix + */ + public static String getTablePartPrefix(final String categoryId) { + return getTablePartPrefix(getCategoryEnum(categoryId)); + } + + /** + * Get table part prefix from category + * + * @param category + * the {@link Pt1TableCategory} + * @return the table part prefix + */ + public static String getTablePartPrefix( + final Pt1TableCategory category) { + return switch (category) { + case ESTW -> ToolboxConstants.ESTW_TABLE_PART_ID_PREFIX; + case ETCS -> ToolboxConstants.ETCS_TABLE_PART_ID_PREFIX; + case ESTW_SUPPLEMENT -> ToolboxConstants.ESTW_SUPPLEMENT_PART_ID_PREFIX; + case SUPPLEMENT -> ToolboxConstants.SUPPLEMENT_TABLE_PART_ID_PREFIX; + }; + } + + /** + * Determine the table category from part id + * + * @param partId + * the part id + * @return the {@link Pt1TableCategory} + */ + public static Pt1TableCategory getCategoryFromPartId( + final String partId) { + if (partId.startsWith(ToolboxConstants.ESTW_TABLE_PART_ID_PREFIX)) { + return Pt1TableCategory.ESTW; + } else if (partId + .startsWith(ToolboxConstants.ETCS_TABLE_PART_ID_PREFIX)) { + return Pt1TableCategory.ETCS; + } else if (partId.startsWith( + ToolboxConstants.ESTW_SUPPLEMENT_PART_ID_PREFIX)) { + return Pt1TableCategory.ESTW_SUPPLEMENT; + } + throw new IllegalArgumentException(); + } } /** From 385b68f23cca50a1f39623213d3fed6ff8016dd9 Mon Sep 17 00:00:00 2001 From: Quang Truong Date: Wed, 1 Apr 2026 15:33:18 +0200 Subject: [PATCH 2/2] fix table transform by change control area --- .../table/internal/TableServiceUtils.java | 67 +++++++++++-------- .../ppmodel/extensions/DwegExtensions.xtend | 8 +-- .../extensions/FstrAneinanderExtensions.xtend | 5 +- .../extensions/FstrZugRangierExtensions.xtend | 3 +- .../extensions/StellBereichExtensions.java | 3 + 5 files changed, 49 insertions(+), 37 deletions(-) diff --git a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java index c75941f85a..a593c4f193 100644 --- a/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java +++ b/java/bundles/org.eclipse.set.feature.table/src/org/eclipse/set/feature/table/internal/TableServiceUtils.java @@ -135,7 +135,7 @@ protected static List getCachedTableError( default -> throw new IllegalArgumentException(); }; return filterElementBelongToControlArea(errorsByCurrentTableState, - getObj, controlAreaIds, modelSession, null); + tableInfo, getObj, controlAreaIds, modelSession, null); } /** @@ -262,8 +262,8 @@ protected static Table filterRequestValue(final Table table, return result; } if (tableType == TableType.DIFF) { - filterRowGroupBelongToControlAreaByDiffState(result, modelsession, - controlAreaIds); + filterRowGroupBelongToControlAreaByDiffState(result, tableInfo, + modelsession, controlAreaIds); result.getTablecontent() .getRowgroups() .removeIf(group -> !UrObjectExtensions @@ -290,21 +290,6 @@ protected static Table filterRequestValue(final Table table, return result; } - private static boolean isLeadingObjecBelongToArea( - final Ur_Objekt leadingObj, final Stell_Bereich area, - final TableInfo tableInfo) { - // Specify handle for Signal tabelle - if (leadingObj instanceof final Signal signal) { - if (tableInfo.shortcut().equalsIgnoreCase("Ssks")) { //$NON-NLS-1$ - return SignalExtensions.isSsksSignalBelongToArea(signal, area); - } else if (tableInfo.shortcut().equalsIgnoreCase("Sskx")) { //$NON-NLS-1$ - return SignalExtensions.isSskxSignalBelongToArea(signal, area); - } - } - - return StellBereichExtensions.isInControlArea(area, leadingObj); - } - private static Table filterTableByState(final Table table, final TableType tableType) { if (tableType == TableType.DIFF || tableType == TableType.SINGLE) { @@ -378,13 +363,14 @@ private static void transformCompareFootnote(final TableRow compareRow, } private static void filterRowGroupBelongToControlAreaByDiffState( - final Table result, final IModelSession modelsession, + final Table result, final TableInfo tableInfo, + final IModelSession modelsession, final Set controlAreaIds) { if (controlAreaIds.isEmpty()) { return; } final List relevantRowGroup = filterElementBelongToControlArea( - result.getTablecontent().getRowgroups(), + result.getTablecontent().getRowgroups(), tableInfo, rowGroup -> UrObjektEachContainer.createInstance( rowGroup.getLeadingObject(), modelsession), controlAreaIds, modelsession, @@ -399,7 +385,7 @@ private static void filterRowGroupBelongToControlAreaByDiffState( } private static List filterElementBelongToControlArea( - final List listElement, + final List listElement, final TableInfo tableInfo, final Function getUrObj, final Set controlAreas, final IModelSession modelSession, final BiConsumer handleByInitialOrFinalElementNotBelongToArea) { @@ -411,7 +397,7 @@ private static List filterElementBelongToControlArea( .toList(); return listElement.stream().filter(ele -> { final Ur_Objekt obj = getUrObj.apply(ele).singleObj(); - return isElementBelongToAreas(obj, areas); + return isElementBelongToAreas(obj, tableInfo, areas); }).toList(); } final List inititalControlAreas = controlAreas.stream() @@ -427,9 +413,10 @@ private static List filterElementBelongToControlArea( return listElement.stream().filter(ele -> { final UrObjektEachContainer objEachContainer = getUrObj.apply(ele); final boolean isInitialObjBelongToAreas = isElementBelongToAreas( - objEachContainer.initalObj(), inititalControlAreas); + objEachContainer.initalObj(), tableInfo, + inititalControlAreas); final boolean isFinalObjBelongToAreas = isElementBelongToAreas( - objEachContainer.finalObj(), finalControlAreas); + objEachContainer.finalObj(), tableInfo, finalControlAreas); if (isInitialObjBelongToAreas != isFinalObjBelongToAreas && handleByInitialOrFinalElementNotBelongToArea != null) { handleByInitialOrFinalElementNotBelongToArea.accept(ele, @@ -460,14 +447,15 @@ private static Pair getInitalFinalObj( } private static boolean isElementBelongToAreas(final Ur_Objekt element, - final List areas) { + final TableInfo tableInfo, final List areas) { // Special case for block element: When this block element does not // belong // to area, but is relevant block element of another block element, // which belongs to control area, then return true // See: ppmtab - General condition and // SslbTransformator#findRelevantBlockElements for more information - if (element instanceof final Block_Element blockElement) { + if (tableInfo.shortcut().equalsIgnoreCase("Sslb") //$NON-NLS-1$ + && element instanceof final Block_Element blockElement) { if (isInControlArea(areas, blockElement)) { return true; } @@ -489,9 +477,32 @@ private static boolean isElementBelongToAreas(final Ur_Objekt element, : targetAnlage.get() .getIDBlockElementA() .getValue(); - return isInControlArea(areas, anotherBlockElement); + return isLeadObjecctBelongToArea(anotherBlockElement, areas, + tableInfo); } - return isInControlArea(areas, element); + return isLeadObjecctBelongToArea(element, areas, tableInfo); + } + + private static boolean isLeadObjecctBelongToArea(final Ur_Objekt leadingObj, + final List areas, final TableInfo tableInfo) { + return areas.stream() + .anyMatch(area -> isLeadingObjecBelongToArea(leadingObj, area, + tableInfo)); + } + + private static boolean isLeadingObjecBelongToArea( + final Ur_Objekt leadingObj, final Stell_Bereich area, + final TableInfo tableInfo) { + // Specify handle for Signal tabelle + if (leadingObj instanceof final Signal signal) { + if (tableInfo.shortcut().equalsIgnoreCase("Ssks")) { //$NON-NLS-1$ + return SignalExtensions.isSsksSignalBelongToArea(signal, area); + } else if (tableInfo.shortcut().equalsIgnoreCase("Sskx")) { //$NON-NLS-1$ + return SignalExtensions.isSskxSignalBelongToArea(signal, area); + } + } + + return StellBereichExtensions.isInControlArea(area, leadingObj); } private static BiConsumer handleTableRowNotBelongToArea() { diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/DwegExtensions.xtend b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/DwegExtensions.xtend index 6f9d07584a..3fcad6f93d 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/DwegExtensions.xtend +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/DwegExtensions.xtend @@ -22,7 +22,7 @@ import org.eclipse.set.model.planpro.Ortung.FMA_Anlage import static extension org.eclipse.set.ppmodel.extensions.FahrwegExtensions.* import static extension org.eclipse.set.ppmodel.extensions.PunktObjektExtensions.* -import static extension org.eclipse.set.ppmodel.extensions.StellBereichExtensions.* +import static extension org.eclipse.set.ppmodel.extensions.SignalExtensions.* /** * Extensions for {@link Fstr_DWeg}. @@ -101,11 +101,11 @@ class DwegExtensions extends BasisObjektExtensions { pathToFma.getDistance(new TopPoint(it)).isPresent ] } - + def static boolean isBelongToControlArea(Fstr_DWeg fstrDWeg, Stell_Bereich controlArea) { - return controlArea. - isInControlArea(fstrDWeg.IDFstrFahrweg?.value?.IDStart?.value) + return fstrDWeg.IDFstrFahrweg?.value?.IDStart?.value. + isSsksSignalBelongToArea(controlArea) } } diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrAneinanderExtensions.xtend b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrAneinanderExtensions.xtend index d7f368e913..6a49c068fd 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrAneinanderExtensions.xtend +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrAneinanderExtensions.xtend @@ -19,7 +19,7 @@ import org.eclipse.set.model.planpro.Signale.Signal import static extension org.eclipse.set.ppmodel.extensions.FahrwegExtensions.* import static extension org.eclipse.set.ppmodel.extensions.FstrZugRangierExtensions.* -import static extension org.eclipse.set.ppmodel.extensions.StellBereichExtensions.* +import static extension org.eclipse.set.ppmodel.extensions.SignalExtensions.* /** * This class extends {@link Fstr_Aneinander}. @@ -138,7 +138,6 @@ class FstrAneinanderExtensions extends BasisObjektExtensions { def static boolean isBelongToControlArea(Fstr_Aneinander fstrAneinander, Stell_Bereich controlArea) { - return - controlArea.isInControlArea(fstrAneinander.startSignal) + return fstrAneinander.startSignal.isSsksSignalBelongToArea(controlArea) } } diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend index 23b46c09af..f45b9a92b8 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/FstrZugRangierExtensions.xtend @@ -52,7 +52,6 @@ import static extension org.eclipse.set.ppmodel.extensions.PunktObjektTopKanteEx import static extension org.eclipse.set.ppmodel.extensions.SignalExtensions.* import static extension org.eclipse.set.ppmodel.extensions.SignalRahmenExtensions.* import static extension org.eclipse.set.ppmodel.extensions.SignalbegriffExtensions.* -import static extension org.eclipse.set.ppmodel.extensions.StellBereichExtensions.* import static extension org.eclipse.set.ppmodel.extensions.WKrGspKomponenteExtensions.* import static extension org.eclipse.set.ppmodel.extensions.utils.IterableExtensions.* import static extension org.eclipse.set.utils.math.BigIntegerExtensions.* @@ -446,7 +445,7 @@ class FstrZugRangierExtensions extends BasisObjektExtensions { return false } val startSignal = fstrZugRangier?.IDFstrFahrweg?.value?.IDStart?.value - return controlArea.isInControlArea(startSignal) + return startSignal.isSsksSignalBelongToArea(controlArea) } private def static boolean isZugStrBelongToControlArea( diff --git a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java index 0ce2cb5185..b37470fd2b 100644 --- a/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java +++ b/java/bundles/org.eclipse.set.ppmodel.extensions/src/org/eclipse/set/ppmodel/extensions/StellBereichExtensions.java @@ -31,6 +31,7 @@ import org.eclipse.set.model.planpro.Bahnuebergang.BUE_Anlage; import org.eclipse.set.model.planpro.Bahnuebergang.BUE_Kante; import org.eclipse.set.model.planpro.Basisobjekte.Bereich_Objekt; +import org.eclipse.set.model.planpro.Basisobjekte.Punkt_Objekt; import org.eclipse.set.model.planpro.Basisobjekte.Ur_Objekt; import org.eclipse.set.model.planpro.Bedienung.Bedien_Bezirk; import org.eclipse.set.model.planpro.Bedienung.Bedien_Einrichtung_Oertlich; @@ -285,6 +286,8 @@ public static boolean isInControlArea(final Stell_Bereich area, .intersects(area, bueAnlage); case final Schloss schloss -> SchlossExtensions .isBelongToControlArea(area, schloss); + case final Punkt_Objekt po -> BereichObjektExtensions.contains(area, + po, 1); default -> throw new IllegalArgumentException( "Unsupported object " + object.toString()); };