Package jmri.jmrit.display.layoutEditor

Class LayoutTraverser

java.lang.Object
jmri.jmrit.display.layoutEditor.LayoutTrack
jmri.jmrit.display.layoutEditor.LayoutTraverser
public class LayoutTraverser extends LayoutTrack
A LayoutTraverser is a representation used by LayoutEditor to display a traverser.

A LayoutTraverser has a variable number of connection points, called SlotTracks. Each of these points should be connected to a TrackSegment.

Each slot gets its Block information from its connected track segment.

Each slot has a unique connection index. The connection index is set when the SlotTrack is created, and cannot be changed. This connection index is used to maintain the identity of the radiating segment to its connected Track Segment as slots are added and deleted by the user.

The length and width of the traverser is variable by the user.

  • Field Details

  • Constructor Details

  • Method Details

    • toString

      @Nonnull public String toString()
      Get a string that represents this object. This should only be used for debugging.
      Overrides:
      toString in class Object
      Returns:
      the string

    • getSlotOffset

      public double getSlotOffset()

    • setSlotOffset

      public void setSlotOffset(double offset)

    • getDeckLength

      public double getDeckLength()

    • getDeckWidth

      public double getDeckWidth()

    • setDeckWidth

      public void setDeckWidth(double w)

    • getOrientation

      public int getOrientation()

    • setOrientation

      public void setOrientation(int o)

    • isDispatcherManaged

      public boolean isDispatcherManaged()

    • setDispatcherManaged

      public void setDispatcherManaged(boolean managed)

    • getSignalIconPlacement

      public int getSignalIconPlacement()

    • setSignalIconPlacement

      public void setSignalIconPlacement(int placement)

    • getBufferMast

      public SignalMast getBufferMast()

    • getBufferSignalMastName

      public String getBufferSignalMastName()

    • setBufferSignalMast

      public void setBufferSignalMast(String name)

    • getExitSignalMast

      public SignalMast getExitSignalMast()

    • getExitSignalMastName

      public String getExitSignalMastName()

    • setExitSignalMast

      public void setExitSignalMast(String name)

    • getBlockName

      @Nonnull public String getBlockName()
      Returns:
      the layout block name

    • getLayoutBlock

      @CheckForNull public LayoutBlock getLayoutBlock()
      Returns:
      the layout block

    • setLayoutBlock

      public void setLayoutBlock(@CheckForNull LayoutBlock newLayoutBlock)
      Set up a LayoutBlock for this LayoutTraverser.
      Parameters:
      newLayoutBlock - the LayoutBlock to set

    • setLayoutBlockByName

      public void setLayoutBlockByName(@CheckForNull String name)
      Set up a LayoutBlock for this LayoutTraverser.
      Parameters:
      name - the name of the new LayoutBlock

    • addSlotPair

      public void addSlotPair()

    • addSlotTrack

      public void addSlotTrack(double offset, int index, String name)

    • getSlotConnectIndexed

      @CheckForNull public TrackSegment getSlotConnectIndexed(int index)
      Get the connection for the slot with this index.
      Parameters:
      index - the index
      Returns:
      the connection for the slot with this value of getConnectionIndex

    • getSlotConnectOrdered

      @CheckForNull public TrackSegment getSlotConnectOrdered(int i)
      Get the connection for the slot at the index in the slotList.
      Parameters:
      i - the index in the slotList
      Returns:
      the connection for the slot at that index in the slotList or null

    • setSlotConnect

      public void setSlotConnect(@CheckForNull TrackSegment ts, int index)
      Set the connection for the slot at the index in the slotList.
      Parameters:
      ts - the connection
      index - the index in the slotList

    • getSlotList

      @Nonnull public List<LayoutTraverser.SlotTrack> getSlotList()

    • getNumberSlots

      public int getNumberSlots()
      Get the number of slots on traverser.
      Returns:
      the number of slots

    • getSlotIndex

      public int getSlotIndex(int i)
      Get the index for the slot at this position in the slotList.
      Parameters:
      i - the position in the slotList
      Returns:
      the index

    • getSlotOffsetValue

      public double getSlotOffsetValue(int i)
      Get the offset for the slot at this position in the slotList.
      Parameters:
      i - the position in the slotList
      Returns:
      the offset

    • setSlotTurnout

      public void setSlotTurnout(int index, @CheckForNull String turnoutName, int state)
      Set the turnout and state for the slot with this index.
      Parameters:
      index - the index
      turnoutName - the turnout name
      state - the state

    • getSlotTurnoutName

      @CheckForNull public String getSlotTurnoutName(int i)
      Get the name of the turnout for the slot at this index.
      Parameters:
      i - the index
      Returns:
      name of the turnout for the slot at this index

    • getSlotTurnout

      @CheckForNull public Turnout getSlotTurnout(int i)
      Get the turnout for the slot at this index.
      Parameters:
      i - the index
      Returns:
      the turnout for the slot at this index

    • getSlotTurnoutState

      public int getSlotTurnoutState(int i)
      Get the state of the turnout for the slot at this index.
      Parameters:
      i - the index
      Returns:
      state of the turnout for the slot at this index

    • isSlotDisabled

      public boolean isSlotDisabled(int i)
      Get if the slot at this index is disabled.
      Parameters:
      i - the index
      Returns:
      true if disabled

    • setSlotDisabled

      public void setSlotDisabled(int i, boolean boo)
      Set the disabled state of the slot at this index.
      Parameters:
      i - the index
      boo - the state

    • isSlotDisabledWhenOccupied

      public boolean isSlotDisabledWhenOccupied(int i)
      Get the disabled when occupied state of the slot at this index.
      Parameters:
      i - the index
      Returns:
      the state

    • setSlotDisabledWhenOccupied

      public void setSlotDisabledWhenOccupied(int i, boolean boo)
      Set the disabled when occupied state of the slot at this index.
      Parameters:
      i - the index
      boo - the state

    • getConnection

      public LayoutTrack getConnection(HitPointType connectionType) throws JmriException
      get the LayoutTrack connected at the specified connection type
      Specified by:
      getConnection in class LayoutTrack
      Parameters:
      connectionType - where on us to get the connection
      Returns:
      the LayoutTrack connected at the specified connection type
      Throws:
      JmriException - - if the connectionType is invalid

    • setConnection

      public void setConnection(HitPointType connectionType, @CheckForNull LayoutTrack o, HitPointType type) throws JmriException
      set the LayoutTrack connected at the specified connection type
      Specified by:
      setConnection in class LayoutTrack
      Parameters:
      connectionType - where on us to set the connection
      o - the LayoutTrack that is to be connected
      type - where on the LayoutTrack we are connected
      Throws:
      JmriException - - if connectionType or type are invalid

    • isMainlineIndexed

      public boolean isMainlineIndexed(int index)
      Test if slot with this index is a mainline track or not.

      Defaults to false (not mainline) if connecting track segment is missing.

      Parameters:
      index - the index
      Returns:
      true if connecting track segment is mainline

    • isMainlineOrdered

      public boolean isMainlineOrdered(int i)
      Test if slot at this index is a mainline track or not.

      Defaults to false (not mainline) if connecting track segment is missing

      Parameters:
      i - the index
      Returns:
      true if connecting track segment is mainline

    • isMainline

      public boolean isMainline()
      Specified by:
      isMainline in class LayoutTrack

    • setMainline

      public void setMainline(boolean main)
      Set the mainline status of the traverser bridge itself.
      Parameters:
      main - true if the bridge is mainline, false otherwise.

    • setObjects

      public void setObjects(@Nonnull LayoutEditor p)
      Initialization method The name of each track segment connected to a slot track is initialized by by LayoutTraverserXml, then the following method is called after the entire LayoutEditor is loaded to set the specific TrackSegment objects.
      Specified by:
      setObjects in class LayoutTrack
      Parameters:
      p - the layout editor

    • isTurnoutControlled

      public boolean isTurnoutControlled()
      Is this traverser turnout controlled?
      Returns:
      true if so

    • setTurnoutControlled

      public void setTurnoutControlled(boolean boo)
      Set if this traverser is turnout controlled.
      Parameters:
      boo - set true if so

    • setPosition

      public void setPosition(int index)
      Set traverser position to the slot with this index.
      Parameters:
      index - the index

    • getPosition

      public int getPosition()
      Get the traverser position.
      Returns:
      the traverser position

    • deleteTrackPair

      public void deleteTrackPair(int pairIndex)

    • moveSlotPairUp

      public void moveSlotPairUp(int pairIndex)

    • moveSlotPairDown

      public void moveSlotPairDown(int pairIndex)

    • remove

      public void remove()
      Remove this object from display and persistance.

    • isActive

      public boolean isActive()
      Get if traverser is active. "active" means that the object is still displayed, and should be stored.
      Returns:
      true if active, else false.

    • isApproachMast

      public boolean isApproachMast(SignalMast mast)
      Checks if the given mast is an approach mast for any slot on this traverser.
      Parameters:
      mast - The SignalMast to check.
      Returns:
      true if it is an approach mast for one of the slots.

    • isSlotBlock

      public boolean isSlotBlock(Block block)
      Checks if the given block is one of the slot blocks for this traverser.
      Parameters:
      block - The Block to check.
      Returns:
      true if it is a block for one of the slots.

    • reCheckBlockBoundary

      protected void reCheckBlockBoundary()
      abstract method... subclasses should implement _IF_ they need to recheck their block boundaries
      Specified by:
      reCheckBlockBoundary in class LayoutTrack

    • getLayoutConnectivity

      @CheckForNull protected List<LayoutConnectivity> getLayoutConnectivity()
      get the layout connectivity for this track
      Specified by:
      getLayoutConnectivity in class LayoutTrack
      Returns:
      the list of Layout Connectivity objects

    • checkForFreeConnections

      @Nonnull public List<HitPointType> checkForFreeConnections()
      return a list of the available connections for this layout track
      Specified by:
      checkForFreeConnections in class LayoutTrack
      Returns:
      the list of available connections

    • checkForUnAssignedBlocks

      public boolean checkForUnAssignedBlocks()
      determine if all the appropriate blocks have been assigned to this track
      Specified by:
      checkForUnAssignedBlocks in class LayoutTrack
      Returns:
      true if all appropriate blocks have been assigned

    • isTraverserBoundary

      public boolean isTraverserBoundary(Block block1, Block block2)
      Checks if the path represented by the blocks crosses this traverser.
      Parameters:
      block1 - A block in the path.
      block2 - Another block in the path.
      Returns:
      true if the path crosses this traverser.

    • getTurnoutList

      public List<LayoutTrackExpectedState<LayoutTurnout>> getTurnoutList(Block curBlock, Block prevBlock, Block nextBlock)
      Gets the list of turnouts and their required states to align the traverser for a path defined by the given blocks.
      Parameters:
      curBlock - The current block in the train's path.
      prevBlock - The previous block in the train's path.
      nextBlock - The next block in the train's path.
      Returns:
      A list of LayoutTrackExpectedState objects for the turnouts.

    • isSlotDeleteAllowed

      public boolean isSlotDeleteAllowed(int pairIndex)
      Check for conditions that will caused subsequent errors if the the traverser slot is removed. Both slot connections have to be clear.
      Parameters:
      pairIndex - The traverser slot to be deleted.
      Returns:
      true if the slot can be deleted.

    • isSlotConnectionClear

      public StringBuilder isSlotConnectionClear(LayoutTraverser.SlotTrack track)
      Check for a connected track segment, signal masts or SML.
      Parameters:
      track - The A or B side of a slot.
      Returns:
      an empty StringBuilder if clear or a set of messages.

    • isRemoveAllowed

      public boolean isRemoveAllowed()
      Check for conditions that will caused subsequent errors if the the traverser is removed or dispatcherManaged is changed from true to false. - The exit mast is a SML source. - The buffer mast is a SML destination. - Exit, buffer or approach masts are on the panel.

    • checkForNonContiguousBlocks

      public void checkForNonContiguousBlocks(@Nonnull HashMap<String,List<Set<String>>> blockNamesToTrackNameSetsMap)
      check this track and its neighbors for non-contiguous blocks

      For each (non-null) blocks of this track do: #1) If it's got an entry in the blockNamesToTrackNameSetMap then #2) If this track is not in one of the TrackNameSets for this block #3) add a new set (with this block/track) to blockNamesToTrackNameSetMap and #4) check all the connections in this block (by calling the 2nd method below)

      Basically, we're maintaining contiguous track sets for each block found (in blockNamesToTrackNameSetMap)

      Specified by:
      checkForNonContiguousBlocks in class LayoutTrack
      Parameters:
      blockNamesToTrackNameSetsMap - hashmap of key:block names to lists of track name sets for those blocks

    • collectContiguousTracksNamesInBlockNamed

      public void collectContiguousTracksNamesInBlockNamed(@Nonnull String blockName, @Nonnull Set<String> TrackNameSet)
      recursive routine to check for all contiguous tracks in this blockName
      Specified by:
      collectContiguousTracksNamesInBlockNamed in class LayoutTrack
      Parameters:
      blockName - the block that we're checking for
      TrackNameSet - the set of track names in this block

    • setAllLayoutBlocks

      public void setAllLayoutBlocks(LayoutBlock layoutBlock)
      Assign all the layout blocks in this track
      Specified by:
      setAllLayoutBlocks in class LayoutTrack
      Parameters:
      layoutBlock - to this layout block (used by the Tools menu's "Assign block to selection" item)

    • canRemove

      public boolean canRemove()
      Check for active block boundaries.

      If any connection point of a layout track object has attached objects, such as signal masts, signal heads or NX sensors, the layout track object cannot be deleted.

      Specified by:
      canRemove in class LayoutTrack
      Returns:
      true if the layout track object can be deleted.

    • getTypeName

      public String getTypeName()
      Get the type of this item.
      Specified by:
      getTypeName in class LayoutTrack
      Returns:
      the type