Examples with Section jmri.Section used on opensource projects

Example 1 with Section

use of jmri.Section in project JMRI by JMRI.

the class SectionManagerXmlTest method testLoadCurrent.

public void testLoadCurrent() throws Exception {
    // load file
    JUnitUtil.resetInstanceManager();
    JUnitUtil.initConfigureManager();
    JUnitUtil.initInternalTurnoutManager();
    JUnitUtil.initInternalLightManager();
    JUnitUtil.initInternalSensorManager();
    JUnitUtil.initMemoryManager();
    JUnitUtil.initLayoutBlockManager();
    JUnitUtil.initSectionManager();
    InstanceManager.getDefault(ConfigureManager.class).load(new java.io.File("java/test/jmri/configurexml/load/SectionManagerXmlTest.xml"));
    // Note: This test assumes that BlockManagerXMLTest passes and more importantly (weakly)
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    // check existance of sections
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0001"));
    Assert.assertNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("no section"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0002"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0003"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0004"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0005"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0006"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0007"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0008"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0009"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0010"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0011"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("IY:AUTO:0012"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthWest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("North"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthSiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthEast"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("East"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("EastSiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthEast"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("South"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthSiding"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthWest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("West"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.SectionManager.class).getSection("WestSiding"));
    // check existance of a couple of blocks just to be sure 
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB1"));
    Assert.assertNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("no block"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("IB12"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthwest"));
    Assert.assertNotNull(InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwestsiding"));
    //Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB1"));
    //Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("ILB12"));
    //Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blocknorthwest"));
    //Assert.assertNotNull(InstanceManager.getDefault(LayoutBlockManager.class).getLayoutBlock("blockwestsiding"));
    // check existance of a couple of turmouts just to be sure
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT1"));
    Assert.assertNull(InstanceManager.turnoutManagerInstance().getTurnout("no turnout"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT2"));
    Assert.assertNotNull(InstanceManager.turnoutManagerInstance().getTurnout("IT8"));
    // check existance of a couple of memories just to be sure        
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0001"));
    Assert.assertNull(InstanceManager.memoryManagerInstance().getMemory("no memory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0002"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("IM:AUTO:0012"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blocknorthwestmemory"));
    Assert.assertNotNull(InstanceManager.memoryManagerInstance().getMemory("blockwestsidingmemory"));
    // check existance of a couple of sensors just to be sure
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO1"));
    Assert.assertNull(InstanceManager.sensorManagerInstance().getSensor("no sensor"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO2"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("ISBO12"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blocknorthwestoccupied"));
    Assert.assertNotNull(InstanceManager.sensorManagerInstance().getSensor("blockwestsidingoccupied"));
    // check existance of a couple of paths between blocks just to be sure
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    Block[] blockstotest;
    Sensor[] occupiedsensor;
    int[] expectedpreviouspaths;
    int[] expectednextpaths;
    //Make sure this is bigger than the list below
    blockstotest = new Block[12];
    //Make sure this is bigger than the list below
    occupiedsensor = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedpreviouspaths = new int[12];
    //Make sure this is bigger than the list below
    expectednextpaths = new int[12];
    Boolean[] passprevioustest;
    Boolean[] passnexttest;
    //Make sure this is bigger than needed
    passprevioustest = new Boolean[4];
    //Make sure this is bigger than needed
    passnexttest = new Boolean[4];
    Block[][] previousblock;
    //Make sure this is bigger than the list below
    previousblock = new Block[12][4];
    Block[][] nextblock;
    //Make sure this is bigger than the list below
    nextblock = new Block[12][4];
    //  This matches up with the test file, ..., just be sure
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    blockstotest[0] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthwest");
    Assert.assertNotNull(blockstotest[0]);
    occupiedsensor[0] = InstanceManager.sensorManagerInstance().getSensor("blocknorthwestoccupied");
    Assert.assertNotNull(occupiedsensor[0]);
    blockstotest[1] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorth");
    Assert.assertNotNull(blockstotest[1]);
    occupiedsensor[1] = InstanceManager.sensorManagerInstance().getSensor("blocknorthoccupied");
    Assert.assertNotNull(occupiedsensor[1]);
    blockstotest[2] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknorthsiding");
    Assert.assertNotNull(blockstotest[2]);
    occupiedsensor[2] = InstanceManager.sensorManagerInstance().getSensor("blocknorthsidingoccupied");
    Assert.assertNotNull(occupiedsensor[2]);
    blockstotest[3] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocknortheast");
    Assert.assertNotNull(blockstotest[3]);
    occupiedsensor[3] = InstanceManager.sensorManagerInstance().getSensor("blocknortheastoccupied");
    Assert.assertNotNull(occupiedsensor[3]);
    blockstotest[4] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeast");
    Assert.assertNotNull(blockstotest[4]);
    occupiedsensor[4] = InstanceManager.sensorManagerInstance().getSensor("blockeastoccupied");
    Assert.assertNotNull(occupiedsensor[4]);
    blockstotest[5] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockeastsiding");
    Assert.assertNotNull(blockstotest[5]);
    occupiedsensor[5] = InstanceManager.sensorManagerInstance().getSensor("blockeastsidingoccupied");
    Assert.assertNotNull(occupiedsensor[5]);
    blockstotest[6] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksoutheast");
    Assert.assertNotNull(blockstotest[6]);
    occupiedsensor[6] = InstanceManager.sensorManagerInstance().getSensor("blocksoutheastoccupied");
    Assert.assertNotNull(occupiedsensor[6]);
    blockstotest[7] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouth");
    Assert.assertNotNull(blockstotest[7]);
    occupiedsensor[7] = InstanceManager.sensorManagerInstance().getSensor("blocksouthoccupied");
    Assert.assertNotNull(occupiedsensor[7]);
    blockstotest[8] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthsiding");
    Assert.assertNotNull(blockstotest[8]);
    occupiedsensor[8] = InstanceManager.sensorManagerInstance().getSensor("blocksouthsidingoccupied");
    Assert.assertNotNull(occupiedsensor[8]);
    blockstotest[9] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blocksouthwest");
    Assert.assertNotNull(blockstotest[9]);
    occupiedsensor[9] = InstanceManager.sensorManagerInstance().getSensor("blocksouthwestoccupied");
    Assert.assertNotNull(occupiedsensor[9]);
    blockstotest[10] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwest");
    Assert.assertNotNull(blockstotest[10]);
    occupiedsensor[10] = InstanceManager.sensorManagerInstance().getSensor("blockwestoccupied");
    Assert.assertNotNull(occupiedsensor[10]);
    blockstotest[11] = InstanceManager.getDefault(jmri.BlockManager.class).getBlock("blockwestsiding");
    Assert.assertNotNull(blockstotest[11]);
    occupiedsensor[11] = InstanceManager.sensorManagerInstance().getSensor("blockwestsidingoccupied");
    Assert.assertNotNull(occupiedsensor[11]);
    // The references are circular so the definitons are split up, ..., just be sure
    //       that LoadSectionManagerFileText.xml and LoadBlockManagerFileText.xml refer to the
    //       same block / section layout definition.
    expectedpreviouspaths[0] = 2;
    previousblock[0][0] = blockstotest[10];
    previousblock[0][1] = blockstotest[11];
    expectednextpaths[0] = 2;
    nextblock[0][0] = blockstotest[1];
    nextblock[0][1] = blockstotest[2];
    expectedpreviouspaths[1] = 1;
    previousblock[1][0] = blockstotest[0];
    expectednextpaths[1] = 1;
    nextblock[1][0] = blockstotest[3];
    expectedpreviouspaths[2] = 1;
    previousblock[2][0] = blockstotest[0];
    expectednextpaths[2] = 1;
    nextblock[2][0] = blockstotest[3];
    expectedpreviouspaths[3] = 2;
    previousblock[3][0] = blockstotest[1];
    previousblock[3][1] = blockstotest[2];
    expectednextpaths[3] = 2;
    nextblock[3][0] = blockstotest[4];
    nextblock[3][1] = blockstotest[5];
    expectedpreviouspaths[4] = 1;
    previousblock[4][0] = blockstotest[3];
    expectednextpaths[4] = 1;
    nextblock[4][0] = blockstotest[6];
    expectedpreviouspaths[5] = 1;
    previousblock[5][0] = blockstotest[3];
    expectednextpaths[5] = 1;
    nextblock[5][0] = blockstotest[6];
    expectedpreviouspaths[6] = 2;
    previousblock[6][0] = blockstotest[4];
    previousblock[6][1] = blockstotest[5];
    expectednextpaths[6] = 2;
    nextblock[6][0] = blockstotest[7];
    nextblock[6][1] = blockstotest[8];
    expectedpreviouspaths[7] = 1;
    previousblock[7][0] = blockstotest[6];
    expectednextpaths[7] = 1;
    nextblock[7][0] = blockstotest[9];
    expectedpreviouspaths[8] = 1;
    previousblock[8][0] = blockstotest[6];
    expectednextpaths[8] = 1;
    nextblock[8][0] = blockstotest[9];
    expectedpreviouspaths[9] = 2;
    previousblock[9][0] = blockstotest[7];
    previousblock[9][1] = blockstotest[8];
    expectednextpaths[9] = 2;
    nextblock[9][0] = blockstotest[10];
    nextblock[9][1] = blockstotest[11];
    expectedpreviouspaths[10] = 1;
    previousblock[10][0] = blockstotest[9];
    expectednextpaths[10] = 1;
    nextblock[10][0] = blockstotest[0];
    expectedpreviouspaths[11] = 1;
    previousblock[11][0] = blockstotest[9];
    expectednextpaths[11] = 1;
    nextblock[11][0] = blockstotest[0];
    for (int testblockfocus = 0; testblockfocus < 12; testblockfocus++) {
        // Set to one greater than above
        int expectedcentrepaths = expectedpreviouspaths[testblockfocus] + expectednextpaths[testblockfocus];
        Block focusBlock = blockstotest[testblockfocus];
        Memory expectedtestmemory = InstanceManager.memoryManagerInstance().getMemory("blocknorthmemory");
        expectedtestmemory.setValue("Memory test: " + testblockfocus);
        Assert.assertNotNull(expectedtestmemory);
        // TODO: BOB C: Memory Test
        //            Memory actualtestmemory = (Memory) focusBlock.getValue();
        //            Assert.assertNotNull(actualtestmemory);
        //            Assert.assertEquals("Memory where Focus was: " + testblockfocus, expectedtestmemory, actualtestmemory);
        Assert.assertEquals("Sensor where Focus was: " + testblockfocus, occupiedsensor[testblockfocus].getSystemName(), focusBlock.getSensor().getSystemName());
        List<Path> testpaths = focusBlock.getPaths();
        Assert.assertEquals("Block Path size where Block Focus was: " + testblockfocus, expectedcentrepaths, testpaths.size());
        for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
            passprevioustest[p] = false;
        }
        for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
            passnexttest[n] = false;
        }
        for (int i = 0; i < testpaths.size(); i++) {
            Block testblock = testpaths.get(i).getBlock();
            Assert.assertNotNull(testblock);
            for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
                if (testblock == previousblock[testblockfocus][p]) {
                    passprevioustest[p] = true;
                }
            }
            for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
                if (testblock == nextblock[testblockfocus][n]) {
                    passnexttest[n] = true;
                }
            }
        }
        for (int p = 0; p < expectedpreviouspaths[testblockfocus]; p++) {
            Assert.assertTrue("Block Focus was: " + testblockfocus + " previous path: " + p, passprevioustest[p]);
        }
        for (int n = 0; n < expectednextpaths[testblockfocus]; n++) {
            Assert.assertTrue("Block Focus was: " + testblockfocus + " next path: " + n, passnexttest[n]);
        }
    }
    Section[] sectionstotest;
    Block[] expectedsectionentryblock;
    Block[][] expectedsectionforwardblock;
    Block[][] expectedsectionreverseblock;
    Sensor[] expectedForwardBlockingSensors;
    Sensor[] expectedReverseBlockingSensors;
    Sensor[] expectedForwardStoppingSensors;
    Sensor[] expectedReverseStoppingSensors;
    int[] expectedsectionblocklistsize;
    int[] expectedforwardEntryPointList;
    int[] expectedreverseEntryPointList;
    //        Sensor[] occupiedsensor;
    //        int[] expectedpreviouspaths;
    //        int[] expectednextpaths;
    //Make sure this is bigger than the list below
    sectionstotest = new Section[12];
    //Make sure this is bigger than the list below
    expectedsectionentryblock = new Block[12];
    //Make sure this is bigger than the list below
    expectedsectionforwardblock = new Block[12][2];
    //Make sure this is bigger than the list below
    expectedsectionreverseblock = new Block[12][2];
    //Make sure this is bigger than the list below
    expectedForwardBlockingSensors = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedReverseBlockingSensors = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedForwardStoppingSensors = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedReverseStoppingSensors = new Sensor[12];
    //Make sure this is bigger than the list below
    expectedsectionblocklistsize = new int[12];
    //Make sure this is bigger than the list below
    expectedforwardEntryPointList = new int[12];
    //Make sure this is bigger than the list below
    expectedreverseEntryPointList = new int[12];
    //        occupiedsensor = new Sensor[12];      //Make sure this is bigger than the list below
    //        expectedpreviouspaths = new int[12];  //Make sure this is bigger than the list below
    //        expectednextpaths = new int[12];      //Make sure this is bigger than the list below
    //  This matches up with the test file, ...
    sectionstotest[0] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthWest");
    Assert.assertNotNull(sectionstotest[0]);
    expectedsectionblocklistsize[0] = 1;
    expectedsectionentryblock[0] = blockstotest[0];
    expectedforwardEntryPointList[0] = 2;
    expectedsectionforwardblock[0][0] = blockstotest[10];
    expectedsectionforwardblock[0][1] = blockstotest[11];
    expectedreverseEntryPointList[0] = 2;
    expectedsectionreverseblock[0][0] = blockstotest[1];
    expectedsectionreverseblock[0][1] = blockstotest[2];
    expectedForwardBlockingSensors[0] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF1");
    expectedReverseBlockingSensors[0] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR1");
    expectedForwardStoppingSensors[0] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF1");
    expectedReverseStoppingSensors[0] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR1");
    sectionstotest[1] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("North");
    Assert.assertNotNull(sectionstotest[1]);
    expectedsectionblocklistsize[1] = 1;
    expectedsectionentryblock[1] = blockstotest[1];
    expectedforwardEntryPointList[1] = 1;
    expectedsectionforwardblock[1][0] = blockstotest[0];
    expectedreverseEntryPointList[1] = 1;
    expectedsectionreverseblock[1][0] = blockstotest[3];
    expectedForwardBlockingSensors[1] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF2");
    expectedReverseBlockingSensors[1] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR2");
    expectedForwardStoppingSensors[1] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF2");
    expectedReverseStoppingSensors[1] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR2");
    sectionstotest[2] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthSiding");
    Assert.assertNotNull(sectionstotest[2]);
    expectedsectionblocklistsize[2] = 1;
    expectedsectionentryblock[2] = blockstotest[2];
    expectedforwardEntryPointList[2] = 1;
    expectedsectionforwardblock[2][0] = blockstotest[0];
    expectedreverseEntryPointList[2] = 1;
    expectedsectionreverseblock[2][0] = blockstotest[3];
    expectedForwardBlockingSensors[2] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF3");
    expectedReverseBlockingSensors[2] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR3");
    expectedForwardStoppingSensors[2] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF3");
    expectedReverseStoppingSensors[2] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR3");
    sectionstotest[3] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("NorthEast");
    Assert.assertNotNull(sectionstotest[3]);
    expectedsectionblocklistsize[3] = 1;
    expectedsectionentryblock[3] = blockstotest[3];
    expectedforwardEntryPointList[3] = 2;
    expectedsectionforwardblock[3][0] = blockstotest[1];
    expectedsectionforwardblock[3][1] = blockstotest[2];
    expectedreverseEntryPointList[3] = 2;
    expectedsectionreverseblock[3][0] = blockstotest[4];
    expectedsectionreverseblock[3][1] = blockstotest[5];
    expectedForwardBlockingSensors[3] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF4");
    expectedReverseBlockingSensors[3] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR4");
    expectedForwardStoppingSensors[3] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF4");
    expectedReverseStoppingSensors[3] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR4");
    sectionstotest[4] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("East");
    Assert.assertNotNull(sectionstotest[4]);
    expectedsectionblocklistsize[4] = 1;
    expectedsectionentryblock[4] = blockstotest[4];
    expectedforwardEntryPointList[4] = 1;
    expectedsectionforwardblock[4][0] = blockstotest[3];
    expectedreverseEntryPointList[4] = 1;
    expectedsectionreverseblock[4][0] = blockstotest[6];
    expectedForwardBlockingSensors[4] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF5");
    expectedReverseBlockingSensors[4] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR5");
    expectedForwardStoppingSensors[4] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF5");
    expectedReverseStoppingSensors[4] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR5");
    sectionstotest[5] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("EastSiding");
    Assert.assertNotNull(sectionstotest[5]);
    expectedsectionblocklistsize[5] = 1;
    expectedsectionentryblock[5] = blockstotest[5];
    expectedforwardEntryPointList[5] = 1;
    expectedsectionforwardblock[5][0] = blockstotest[3];
    expectedreverseEntryPointList[5] = 1;
    expectedsectionreverseblock[5][0] = blockstotest[6];
    expectedForwardBlockingSensors[5] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF6");
    expectedReverseBlockingSensors[5] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR6");
    expectedForwardStoppingSensors[5] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF6");
    expectedReverseStoppingSensors[5] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR6");
    sectionstotest[6] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthEast");
    Assert.assertNotNull(sectionstotest[6]);
    expectedsectionblocklistsize[6] = 1;
    expectedsectionentryblock[6] = blockstotest[6];
    expectedforwardEntryPointList[6] = 2;
    expectedsectionforwardblock[6][0] = blockstotest[4];
    expectedsectionforwardblock[6][1] = blockstotest[5];
    expectedreverseEntryPointList[6] = 2;
    expectedsectionreverseblock[6][0] = blockstotest[7];
    expectedsectionreverseblock[6][1] = blockstotest[8];
    expectedForwardBlockingSensors[6] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF7");
    expectedReverseBlockingSensors[6] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR7");
    expectedForwardStoppingSensors[6] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF7");
    expectedReverseStoppingSensors[6] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR7");
    sectionstotest[7] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("South");
    Assert.assertNotNull(sectionstotest[7]);
    expectedsectionblocklistsize[7] = 1;
    expectedsectionentryblock[7] = blockstotest[7];
    expectedforwardEntryPointList[7] = 1;
    expectedsectionforwardblock[7][0] = blockstotest[6];
    expectedreverseEntryPointList[7] = 1;
    expectedsectionreverseblock[7][0] = blockstotest[9];
    expectedForwardBlockingSensors[7] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF8");
    expectedReverseBlockingSensors[7] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR8");
    expectedForwardStoppingSensors[7] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF8");
    expectedReverseStoppingSensors[7] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR8");
    sectionstotest[8] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthSiding");
    Assert.assertNotNull(sectionstotest[8]);
    expectedsectionblocklistsize[8] = 1;
    expectedsectionentryblock[8] = blockstotest[8];
    expectedforwardEntryPointList[8] = 1;
    expectedsectionforwardblock[8][0] = blockstotest[6];
    expectedreverseEntryPointList[8] = 1;
    expectedsectionreverseblock[8][0] = blockstotest[9];
    expectedForwardBlockingSensors[8] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF9");
    expectedReverseBlockingSensors[8] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR9");
    expectedForwardStoppingSensors[8] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF9");
    expectedReverseStoppingSensors[8] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR9");
    sectionstotest[9] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("SouthWest");
    Assert.assertNotNull(sectionstotest[9]);
    expectedsectionblocklistsize[9] = 1;
    expectedsectionentryblock[9] = blockstotest[9];
    expectedforwardEntryPointList[9] = 2;
    expectedsectionforwardblock[9][0] = blockstotest[7];
    expectedsectionforwardblock[9][1] = blockstotest[8];
    expectedreverseEntryPointList[9] = 2;
    expectedsectionreverseblock[9][0] = blockstotest[10];
    expectedsectionreverseblock[9][1] = blockstotest[11];
    expectedForwardBlockingSensors[9] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF10");
    expectedReverseBlockingSensors[9] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR10");
    expectedForwardStoppingSensors[9] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF10");
    expectedReverseStoppingSensors[9] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR10");
    sectionstotest[10] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("West");
    Assert.assertNotNull(sectionstotest[10]);
    expectedsectionblocklistsize[10] = 1;
    expectedsectionentryblock[10] = blockstotest[10];
    expectedforwardEntryPointList[10] = 1;
    expectedsectionforwardblock[10][0] = blockstotest[9];
    expectedreverseEntryPointList[10] = 1;
    expectedsectionreverseblock[10][0] = blockstotest[0];
    expectedForwardBlockingSensors[10] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF11");
    expectedReverseBlockingSensors[10] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR11");
    expectedForwardStoppingSensors[10] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF11");
    expectedReverseStoppingSensors[10] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR11");
    sectionstotest[11] = InstanceManager.getDefault(jmri.SectionManager.class).getSection("WestSiding");
    Assert.assertNotNull(sectionstotest[11]);
    expectedsectionblocklistsize[11] = 1;
    expectedsectionentryblock[11] = blockstotest[11];
    expectedforwardEntryPointList[11] = 1;
    expectedsectionforwardblock[11][0] = blockstotest[9];
    expectedreverseEntryPointList[11] = 1;
    expectedsectionreverseblock[11][0] = blockstotest[0];
    expectedForwardBlockingSensors[11] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRF12");
    expectedReverseBlockingSensors[11] = InstanceManager.sensorManagerInstance().getSensor("ISSDIRR12");
    expectedForwardStoppingSensors[11] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPF12");
    expectedReverseStoppingSensors[11] = InstanceManager.sensorManagerInstance().getSensor("ISSSTOPR12");
    for (int testsectionfocus = 0; testsectionfocus < 12; testsectionfocus++) {
        // Set to one greater than above
        // check existance of sections
        Section testsection = sectionstotest[testsectionfocus];
        ArrayList<Block> blockList = testsection.getBlockList();
        Assert.assertEquals("Section size where Focus was: " + testsectionfocus, expectedsectionblocklistsize[testsectionfocus], blockList.size());
        Block entryblock = testsection.getEntryBlock();
        Assert.assertNotNull(entryblock);
        Assert.assertEquals("Section entry block where Focus was: " + testsectionfocus, expectedsectionentryblock[testsectionfocus].getSystemName(), entryblock.getSystemName());
        List<EntryPoint> forwardEntryPointList = testsection.getForwardEntryPointList();
        Assert.assertEquals("Section forward size where Focus was: " + testsectionfocus, expectedforwardEntryPointList[testsectionfocus], forwardEntryPointList.size());
        for (int e = 0; e < forwardEntryPointList.size(); e++) {
            EntryPoint get = forwardEntryPointList.get(e);
            Assert.assertEquals("Focus was: " + testsectionfocus + " next forward entry point: " + e, expectedsectionentryblock[testsectionfocus].getSystemName(), get.getBlock().getSystemName());
            Assert.assertEquals("Focus was: " + testsectionfocus + " next forward from: " + e, expectedsectionforwardblock[testsectionfocus][e].getUserName(), get.getFromBlock().getUserName());
            Assert.assertEquals("Focus was: " + testsectionfocus + " next forward dir: " + e, 4, get.getDirection());
        }
        List<EntryPoint> reverseEntryPointList = testsection.getReverseEntryPointList();
        Assert.assertEquals("Section forward size where Focus was: " + testsectionfocus, expectedreverseEntryPointList[testsectionfocus], reverseEntryPointList.size());
        for (int e = 0; e < reverseEntryPointList.size(); e++) {
            EntryPoint get = reverseEntryPointList.get(e);
            Assert.assertEquals("Focus was: " + testsectionfocus + " next reverse entry point: " + e, expectedsectionentryblock[testsectionfocus].getSystemName(), get.getBlock().getSystemName());
            Assert.assertEquals("Focus was: " + testsectionfocus + " next reverse from: " + e, expectedsectionreverseblock[testsectionfocus][e].getUserName(), get.getFromBlock().getUserName());
            Assert.assertEquals("Focus was: " + testsectionfocus + " next reverse dir: " + e, 8, get.getDirection());
        }
        Sensor expectedForwardBlockingSensor = expectedForwardBlockingSensors[testsectionfocus];
        Sensor actualForwardBlockingSensor = testsection.getForwardBlockingSensor();
        Assert.assertNotNull("Focus was: " + testsectionfocus + " expectedForwardBlockingSensor", expectedForwardBlockingSensor);
        Assert.assertNotNull("Focus was: " + testsectionfocus + " actualForwardBlockingSensor", actualForwardBlockingSensor);
        Assert.assertTrue("Focus was: " + testsectionfocus + " ForwardBlockingSensor", expectedForwardBlockingSensor.getSystemName().equals(actualForwardBlockingSensor.getSystemName()));
        Sensor expectedReverseBlockingSensor = expectedReverseBlockingSensors[testsectionfocus];
        Sensor actualReverseBlockingSensor = testsection.getReverseBlockingSensor();
        Assert.assertNotNull("Focus was: " + testsectionfocus + " expectedReverseBlockingSensor", expectedReverseBlockingSensor);
        Assert.assertNotNull("Focus was: " + testsectionfocus + " actualReverseBlockingSensor", actualReverseBlockingSensor);
        Assert.assertTrue("Focus was: " + testsectionfocus + " ReverseBlockingSensor", expectedReverseBlockingSensor.getSystemName().equals(actualReverseBlockingSensor.getSystemName()));
        Sensor expectedForwardStoppingSensor = expectedForwardStoppingSensors[testsectionfocus];
        Sensor actualForwardStoppingSensor = testsection.getForwardStoppingSensor();
        Assert.assertNotNull("Focus was: " + testsectionfocus + " expectedForwardStoppingSensor", expectedForwardStoppingSensor);
        Assert.assertNotNull("Focus was: " + testsectionfocus + " actualForwardStoppingSensor", actualForwardStoppingSensor);
        Assert.assertTrue("Focus was: " + testsectionfocus + " ForwardStoppingSensor", expectedForwardStoppingSensor.getSystemName().equals(actualForwardStoppingSensor.getSystemName()));
        Sensor expectedReverseStoppingSensor = expectedReverseStoppingSensors[testsectionfocus];
        Sensor actualReverseStoppingSensor = testsection.getReverseStoppingSensor();
        Assert.assertNotNull("Focus was: " + testsectionfocus + " expectedReverseStoppingSensor", expectedReverseStoppingSensor);
        Assert.assertNotNull("Focus was: " + testsectionfocus + " actualReverseStoppingSensor", actualReverseStoppingSensor);
        Assert.assertTrue("Focus was: " + testsectionfocus + " ReverseStoppingSensor", expectedReverseStoppingSensor.getSystemName().equals(actualReverseStoppingSensor.getSystemName()));
    }
}

Example 2 with Section

use of jmri.Section in project JMRI by JMRI.

the class DispatcherFrame method allocateSection.

/**
     * Allocates a Section to an Active Train according to the information in an
     * AllocationRequest.
     *
     * If successful, returns an AllocatedSection and removes the
     * AllocationRequest from the queue. If not successful, returns null and
     * leaves the AllocationRequest in the queue.
     *
     * To be allocatable, a Section must be FREE and UNOCCUPIED. If a Section is
     * OCCUPIED, the allocation is rejected unless the dispatcher chooses to
     * override this restriction. To be allocatable, the Active Train must not
     * be waiting for its start time. If the start time has not been reached,
     * the allocation is rejected, unless the dispatcher chooses to override the
     * start time.
     *
     * @param ar the request containing the section to allocate
     * @param ns the next section; use null to allow the next section to be
     *           automatically determined, if the next section is the last
     *           section, of if an extra section is being allocated
     * @return the allocated section or null if not successful
     */
public AllocatedSection allocateSection(AllocationRequest ar, Section ns) {
    AllocatedSection as = null;
    Section nextSection = null;
    int nextSectionSeqNo = 0;
    if (ar != null) {
        ActiveTrain at = ar.getActiveTrain();
        if (at.holdAllocation() || at.reachedRestartPoint()) {
            return null;
        }
        Section s = ar.getSection();
        if (s.getState() != Section.FREE) {
            return null;
        }
        // skip occupancy check if this is the first allocation and the train is occupying the Section
        boolean checkOccupancy = true;
        if ((at.getLastAllocatedSection() == null) && (s.containsBlock(at.getStartBlock()))) {
            checkOccupancy = false;
        }
        // check if section is occupied
        if (checkOccupancy && (s.getOccupancy() == Section.OCCUPIED)) {
            if (_AutoAllocate) {
                // autoAllocate never overrides occupancy
                return null;
            }
            int selectedValue = JOptionPane.showOptionDialog(dispatcherFrame, Bundle.getMessage("Question1"), Bundle.getMessage("WarningTitle"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[] { Bundle.getMessage("ButtonYes"), Bundle.getMessage("ButtonNo") }, Bundle.getMessage("ButtonNo"));
            if (selectedValue == 1) {
                // return without allocating if "No" response
                return null;
            }
        }
        // check if train has reached its start time if delayed start
        if (checkOccupancy && (!at.getStarted()) && at.getDelayedStart() != ActiveTrain.NODELAY) {
            if (_AutoAllocate) {
                // autoAllocate never overrides start time
                return null;
            }
            int selectedValue = JOptionPane.showOptionDialog(dispatcherFrame, Bundle.getMessage("Question4"), Bundle.getMessage("WarningTitle"), JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, new Object[] { Bundle.getMessage("ButtonYes"), Bundle.getMessage("ButtonNo") }, Bundle.getMessage("ButtonNo"));
            if (selectedValue == 1) {
                return null;
            } else {
                at.setStarted();
                for (int i = delayedTrains.size() - 1; i >= 0; i--) {
                    if (delayedTrains.get(i) == at) {
                        delayedTrains.remove(i);
                    }
                }
            }
        }
        //check here to see if block is already assigned to an allocated section;
        if (getSignalType() == SIGNALMAST && checkBlocksNotInAllocatedSection(s, ar) != null) {
            return null;
        }
        //  code must do all validity checks on a non-null ns.
        if (ns != null) {
            nextSection = ns;
        } else if ((ar.getSectionSeqNumber() != -99) && (at.getNextSectionSeqNumber() == ar.getSectionSeqNumber()) && (!((s == at.getEndBlockSection()) && (ar.getSectionSeqNumber() == at.getEndBlockSectionSequenceNumber()))) && (!(at.isAllocationReversed() && (ar.getSectionSeqNumber() == 1)))) {
            // not at either end - determine the next section 
            int seqNum = ar.getSectionSeqNumber();
            if (at.isAllocationReversed()) {
                seqNum -= 1;
            } else {
                seqNum += 1;
            }
            ArrayList<Section> secList = at.getTransit().getSectionListBySeq(seqNum);
            if (secList.size() == 1) {
                nextSection = secList.get(0);
            } else if (secList.size() > 1) {
                if (_AutoAllocate) {
                    nextSection = autoChoice(secList, ar);
                } else {
                    nextSection = dispatcherChoice(secList, ar);
                }
            }
            nextSectionSeqNo = seqNum;
        } else if (at.getReverseAtEnd() && (!at.isAllocationReversed()) && (s == at.getEndBlockSection()) && (ar.getSectionSeqNumber() == at.getEndBlockSectionSequenceNumber())) {
            // need to reverse Transit direction when train is in the last Section, set next section.
            nextSectionSeqNo = at.getEndBlockSectionSequenceNumber() - 1;
            at.setAllocationReversed(true);
            ArrayList<Section> secList = at.getTransit().getSectionListBySeq(nextSectionSeqNo);
            if (secList.size() == 1) {
                nextSection = secList.get(0);
            } else if (secList.size() > 1) {
                if (_AutoAllocate) {
                    nextSection = autoChoice(secList, ar);
                } else {
                    nextSection = dispatcherChoice(secList, ar);
                }
            }
        } else if (((!at.isAllocationReversed()) && (s == at.getEndBlockSection()) && (ar.getSectionSeqNumber() == at.getEndBlockSectionSequenceNumber())) || (at.isAllocationReversed() && (ar.getSectionSeqNumber() == 1))) {
            //      has reached the beginning of the Transit--check for automatic restart
            if (at.getResetWhenDone()) {
                if (at.getDelayedRestart() != ActiveTrain.NODELAY) {
                    at.holdAllocation(true);
                }
                nextSection = at.getSecondAllocatedSection();
                nextSectionSeqNo = 2;
                at.setAllocationReversed(false);
            }
        }
        //This might be the location to check to see if we have an intermediate section that we then need to perform extra checks on.
        //Working on the basis that if the nextsection is not null, then we are not at the end of the transit.
        ArrayList<Section> intermediateSections = new ArrayList<>();
        Section mastHeldAtSection = null;
        if (nextSection != null && ar.getSection().getProperty("intermediateSection") != null && ((Boolean) ar.getSection().getProperty("intermediateSection")).booleanValue()) {
            String property = "forwardMast";
            if (at.isAllocationReversed()) {
                property = "reverseMast";
            }
            if (ar.getSection().getProperty(property) != null) {
                SignalMast endMast = InstanceManager.getDefault(jmri.SignalMastManager.class).getSignalMast(ar.getSection().getProperty(property).toString());
                if (endMast != null) {
                    if (endMast.getHeld()) {
                        mastHeldAtSection = ar.getSection();
                    }
                }
            }
            ArrayList<TransitSection> tsList = ar.getActiveTrain().getTransit().getTransitSectionList();
            boolean found = false;
            if (at.isAllocationReversed()) {
                for (int i = tsList.size() - 1; i > 0; i--) {
                    TransitSection ts = tsList.get(i);
                    if (ts.getSection() == ar.getSection() && ts.getSequenceNumber() == ar.getSectionSeqNumber()) {
                        found = true;
                    } else if (found) {
                        if (ts.getSection().getProperty("intermediateSection") != null && ((Boolean) ts.getSection().getProperty("intermediateSection")).booleanValue()) {
                            intermediateSections.add(ts.getSection());
                        } else {
                            //we add the section after the last intermediate in, so that the last allocation request can be built correctly
                            intermediateSections.add(ts.getSection());
                            break;
                        }
                    }
                }
            } else {
                for (int i = 0; i <= tsList.size() - 1; i++) {
                    TransitSection ts = tsList.get(i);
                    if (ts.getSection() == ar.getSection() && ts.getSequenceNumber() == ar.getSectionSeqNumber()) {
                        found = true;
                    } else if (found) {
                        if (ts.getSection().getProperty("intermediateSection") != null && ((Boolean) ts.getSection().getProperty("intermediateSection")).booleanValue()) {
                            intermediateSections.add(ts.getSection());
                        } else {
                            //we add the section after the last intermediate in, so that the last allocation request can be built correctly
                            intermediateSections.add(ts.getSection());
                            break;
                        }
                    }
                }
            }
            boolean intermediatesOccupied = false;
            for (int i = 0; i < intermediateSections.size() - 1; i++) {
                // ie do not check last section which is not an intermediate section
                Section se = intermediateSections.get(i);
                if (se.getState() == Section.FREE) {
                    //If the section state is free, we need to look to see if any of the blocks are used else where
                    Section conflict = checkBlocksNotInAllocatedSection(se, null);
                    if (conflict != null) {
                        //We might need to find out if the section which the block is allocated to is one in our transit, and if so is it running in the same direction.
                        return null;
                    } else {
                        if (mastHeldAtSection == null) {
                            if (se.getProperty(property) != null) {
                                SignalMast endMast = InstanceManager.getDefault(jmri.SignalMastManager.class).getSignalMast(se.getProperty(property).toString());
                                if (endMast != null && endMast.getHeld()) {
                                    mastHeldAtSection = se;
                                }
                            }
                        }
                    }
                } else if (at.getLastAllocatedSection() != null && se.getState() != at.getLastAllocatedSection().getState()) {
                    //Last allocated section and the checking section direction are not the same
                    return null;
                } else {
                    intermediatesOccupied = true;
                }
            }
            //If the intermediate sections are already occupied or allocated then we clear the intermediate list and only allocate the original request.
            if (intermediatesOccupied) {
                intermediateSections = new ArrayList<>();
            }
        }
        // Note: Turnout checking and/or setting is not performed when allocating an extra section.
        if ((_UseConnectivity) && (ar.getSectionSeqNumber() != -99)) {
            if (!checkTurnoutStates(s, ar.getSectionSeqNumber(), nextSection, at, at.getLastAllocatedSection())) {
                return null;
            }
            Section preSec = s;
            Section tmpcur = nextSection;
            int tmpSeqNo = nextSectionSeqNo;
            //The first section in the list will be the same as the nextSection, so we skip that.
            for (int i = 1; i < intermediateSections.size(); i++) {
                Section se = intermediateSections.get(i);
                if (preSec == mastHeldAtSection) {
                    log.debug("Section is beyond held mast do not set turnouts " + (tmpcur != null ? tmpcur.getDisplayName() : "null"));
                    break;
                }
                if (!checkTurnoutStates(tmpcur, tmpSeqNo, se, at, preSec)) {
                    return null;
                }
                preSec = tmpcur;
                tmpcur = se;
                if (at.isAllocationReversed()) {
                    tmpSeqNo -= 1;
                } else {
                    tmpSeqNo += 1;
                }
            }
        }
        as = allocateSection(at, s, ar.getSectionSeqNumber(), nextSection, nextSectionSeqNo, ar.getSectionDirection());
        if (intermediateSections.size() > 1 && mastHeldAtSection != s) {
            Section tmpcur = nextSection;
            int tmpSeqNo = nextSectionSeqNo;
            int tmpNxtSeqNo = tmpSeqNo;
            if (at.isAllocationReversed()) {
                tmpNxtSeqNo -= 1;
            } else {
                tmpNxtSeqNo += 1;
            }
            //The first section in the list will be the same as the nextSection, so we skip that.
            for (int i = 1; i < intermediateSections.size(); i++) {
                if (tmpcur == mastHeldAtSection) {
                    log.debug("Section is beyond held mast do not allocate any more sections " + (tmpcur != null ? tmpcur.getDisplayName() : "null"));
                    break;
                }
                Section se = intermediateSections.get(i);
                as = allocateSection(at, tmpcur, tmpSeqNo, se, tmpNxtSeqNo, ar.getSectionDirection());
                tmpcur = se;
                if (at.isAllocationReversed()) {
                    tmpSeqNo -= 1;
                    tmpNxtSeqNo -= 1;
                } else {
                    tmpSeqNo += 1;
                    tmpNxtSeqNo += 1;
                }
            }
        }
        int ix = -1;
        for (int i = 0; i < allocationRequests.size(); i++) {
            if (ar == allocationRequests.get(i)) {
                ix = i;
            }
        }
        allocationRequests.remove(ix);
        ar.dispose();
        allocationRequestTableModel.fireTableDataChanged();
        activeTrainsTableModel.fireTableDataChanged();
        if (allocatedSectionTableModel != null) {
            allocatedSectionTableModel.fireTableDataChanged();
        }
        if (extraFrame != null) {
            cancelExtraRequested(null);
        }
        if (_AutoAllocate) {
            requestNextAllocation(at);
            autoAllocate.scanAllocationRequestList(allocationRequests);
        }
    } else {
        log.error("Null Allocation Request provided in request to allocate a section");
    }
    return as;
}

Example 3 with Section

use of jmri.Section in project JMRI by JMRI.

the class DispatcherFrame method checkAutoRelease.

/**
     * Check if any allocation requests need to be allocated, or if any
     * allocated sections need to be released
     */
private void checkAutoRelease() {
    if ((autoReleaseBox != null) && (autoReleaseBox.isSelected())) {
        // Auto release of exited sections has been requested - because of possible noise in block detection 
        //    hardware, allocated sections are automatically released in the order they were allocated only
        // Only unoccupied sections that have been exited are tested.
        // The next allocated section must be assigned to the same train, and it must have been entered for 
        //    the exited Section to be released.
        // Extra allocated sections are not automatically released (allocation number = -1).
        boolean foundOne = true;
        while ((allocatedSections.size() > 0) && foundOne) {
            try {
                foundOne = false;
                AllocatedSection as = null;
                for (int i = 0; (i < allocatedSections.size()) && !foundOne; i++) {
                    as = allocatedSections.get(i);
                    if (as.getExited() && (as.getSection().getOccupancy() != Section.OCCUPIED) && (as.getAllocationNumber() != -1)) {
                        // possible candidate for deallocation - check order
                        foundOne = true;
                        for (int j = 0; (j < allocatedSections.size()) && foundOne; j++) {
                            if (j != i) {
                                AllocatedSection asx = allocatedSections.get(j);
                                if ((asx.getActiveTrain() == as.getActiveTrain()) && (asx.getAllocationNumber() != -1) && (asx.getAllocationNumber() < as.getAllocationNumber())) {
                                    foundOne = false;
                                }
                            }
                        }
                        if (foundOne) {
                            // check if the next section is allocated to the same train and has been entered
                            ActiveTrain at = as.getActiveTrain();
                            Section ns = as.getNextSection();
                            AllocatedSection nas = null;
                            for (int k = 0; (k < allocatedSections.size()) && (nas == null); k++) {
                                if (allocatedSections.get(k).getSection() == ns) {
                                    nas = allocatedSections.get(k);
                                }
                            }
                            if ((nas == null) || (at.getStatus() == ActiveTrain.WORKING) || (at.getStatus() == ActiveTrain.STOPPED) || (at.getStatus() == ActiveTrain.READY) || (at.getMode() == ActiveTrain.MANUAL)) {
                                // do not autorelease allocated sections from an Active Train that is 
                                //    STOPPED, READY, or WORKING, or is in MANUAL mode.
                                foundOne = false;
                                //But do so if the active train has reached its restart point
                                if (at.reachedRestartPoint()) {
                                    foundOne = true;
                                }
                            } else {
                                if ((nas.getActiveTrain() != as.getActiveTrain()) || (!nas.getEntered())) {
                                    foundOne = false;
                                }
                            }
                            if (foundOne) {
                                // have section to release - delay before release
                                try {
                                    Thread.sleep(500);
                                } catch (InterruptedException e) {
                                // ignore this exception
                                }
                                // if section is still allocated, release it
                                foundOne = false;
                                for (int m = 0; m < allocatedSections.size(); m++) {
                                    if ((allocatedSections.get(m) == as) && (as.getActiveTrain() == at)) {
                                        foundOne = true;
                                    }
                                }
                                if (foundOne) {
                                    log.debug("{}: releasing {}", at.getTrainName(), as.getSectionName());
                                    releaseAllocatedSection(as, false);
                                }
                            }
                        }
                    }
                }
            } catch (Exception e) {
                log.warn("checkAutoRelease failed  - maybe the AllocatedSection was removed due to a terminating train?? " + e.toString());
                continue;
            }
        }
    }
}

Example 4 with Section

use of jmri.Section in project JMRI by JMRI.

the class DispatcherFrame method dispatcherChoice.

// manually make a choice of next section
private Section dispatcherChoice(ArrayList<Section> sList, AllocationRequest ar) {
    Object[] choices = new Object[sList.size()];
    for (int i = 0; i < sList.size(); i++) {
        Section s = sList.get(i);
        String txt = s.getSystemName();
        String user = s.getUserName();
        if ((user != null) && (!user.equals("")) && (!user.equals(txt))) {
            txt = txt + "(" + user + ")";
        }
        choices[i] = txt;
    }
    Object secName = JOptionPane.showInputDialog(dispatcherFrame, Bundle.getMessage("ExplainChoice") + " " + ar.getSectionName() + ".", Bundle.getMessage("ChoiceFrameTitle"), JOptionPane.QUESTION_MESSAGE, null, choices, choices[0]);
    if (secName == null) {
        JOptionPane.showMessageDialog(dispatcherFrame, Bundle.getMessage("WarnCancel"));
        return sList.get(0);
    }
    for (int j = 0; j < sList.size(); j++) {
        if (secName.equals(choices[j])) {
            return sList.get(j);
        }
    }
    return sList.get(0);
}

Example 5 with Section

use of jmri.Section in project JMRI by JMRI.

the class SectionManagerXml method loadSections.

/**
     * Utility method to load the individual Section objects. If there's no
     * additional info needed for a specific Section type, invoke this with the
     * parent of the set of Section elements.
     *
     * @param sharedSections  Element containing the Section elements to load.
     * @param perNodeSections Per-node Element containing the Section elements
     *                        to load.
     */
public void loadSections(Element sharedSections, Element perNodeSections) {
    List<Element> sectionList = sharedSections.getChildren("section");
    if (log.isDebugEnabled()) {
        log.debug("Found " + sectionList.size() + " sections");
    }
    SectionManager tm = InstanceManager.getDefault(jmri.SectionManager.class);
    for (int i = 0; i < sectionList.size(); i++) {
        String sysName = getSystemName(sectionList.get(i));
        String userName = getUserName(sectionList.get(i));
        Section x = tm.createNewSection(sysName, userName);
        if (x != null) {
            // load common part
            loadCommon(x, (sectionList.get(i)));
            if (sectionList.get(i).getAttribute("creationtype") != null) {
                String creationType = sectionList.get(i).getAttribute("creationtype").getValue();
                if (creationType.equals("userdefined")) {
                    x.setSectionType(Section.USERDEFINED);
                } else if (creationType.equals("signalmastlogic")) {
                    x.setSectionType(Section.SIGNALMASTLOGIC);
                }
            }
            if (sectionList.get(i).getAttribute("fsensorname") != null) {
                String forName = (sectionList.get(i)).getAttribute("fsensorname").getValue();
                x.delayedSetForwardBlockingSensorName(forName);
            }
            if (sectionList.get(i).getAttribute("rsensorname") != null) {
                String revName = sectionList.get(i).getAttribute("rsensorname").getValue();
                x.delayedSetReverseBlockingSensorName(revName);
            }
            if (sectionList.get(i).getAttribute("fstopsensorname") != null) {
                String forName = sectionList.get(i).getAttribute("fstopsensorname").getValue();
                x.delayedSetForwardStoppingSensorName(forName);
            }
            if (sectionList.get(i).getAttribute("rstopsensorname") != null) {
                String revName = sectionList.get(i).getAttribute("rstopsensorname").getValue();
                x.delayedSetReverseStoppingSensorName(revName);
            }
            // load block entry children
            List<Element> sectionBlockList = sectionList.get(i).getChildren("blockentry");
            for (int n = 0; n < sectionBlockList.size(); n++) {
                Element elem = sectionBlockList.get(n);
                x.delayedAddBlock(elem.getAttribute("sName").getValue());
            // insert code here to verify sequence number if needed in the future
            }
            // load entry point children
            List<Element> sectionEntryPointList = sectionList.get(i).getChildren("entrypoint");
            for (int n = 0; n < sectionEntryPointList.size(); n++) {
                Element elem = sectionEntryPointList.get(n);
                String blockName = elem.getAttribute("toblock").getValue();
                String fromBlockName = elem.getAttribute("fromblock").getValue();
                String fromBlockDirection = "";
                if (elem.getAttribute("fromblockdirection") != null) {
                    fromBlockDirection = elem.getAttribute("fromblockdirection").getValue();
                }
                EntryPoint ep = new EntryPoint(blockName, fromBlockName, fromBlockDirection);
                //if (ep!=null) {
                try {
                    ep.setDirection(elem.getAttribute("direction").getIntValue());
                } catch (Exception e) {
                    log.error("Data Conversion Exception when loading direction of entry point - " + e);
                }
                boolean fixed = true;
                if (elem.getAttribute("fixed").getValue().equals("no")) {
                    fixed = false;
                }
                ep.setFixed(fixed);
                if (ep.isForwardType()) {
                    x.addToForwardList(ep);
                } else if (ep.isReverseType()) {
                    x.addToReverseList(ep);
                }
            //}
            }
        }
    }
}