source: tmcsimulator/trunk/src/atmsdriver/model/Highways.java @ 88

package atmsdriver.model;



import atmsdriver.NetworkLoader;

import atmsdriver.model.Station.DIRECTION;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.io.Writer;

import java.net.Socket;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Map;

import java.util.Scanner;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import org.w3c.dom.Element;



/**

 *

 * @author John A. Torres

 */

public class Highways {



    final private ArrayList<FEPLine> lines;

    final private String FEPHostName;

    final private int FEPPortNum;

    final private ArrayList<Highway> highways;

    

    // NEED FINISH final private ArrayList<Highway> highways;

    public Highways(String ldsFileName, String loopsFileName,

            String highwayMetaFileName, String FEPHostName, int FEPPortNum) {

        /*

         lines = loadLines(highwayMetaFileName);

         System.out.println("SIZE: " + toXML().toCharArray().length);

         */



        NetworkLoader ldr = new NetworkLoader(new File(ldsFileName), new File(loopsFileName));

        this.lines = (ArrayList<FEPLine>) ldr.getFEPLines();

        this.FEPHostName = FEPHostName;

        this.FEPPortNum = FEPPortNum;

        this.highways = loadHighways();

        //writeHighwaysMeta("hard.txt");

    }



    

    private ArrayList<Highway> loadHighways() {

        System.out.println("Loading highways...");

        ArrayList<Highway> highways = new ArrayList<Highway>();

        Hashtable<Hashtable<Integer, DIRECTION>, ArrayList<Station>>

                highwayTable = new Hashtable<>();

        

        for (FEPLine line : lines)

        {

            ArrayList<Station> lineStations = (ArrayList<Station>) line.getStations();

            for(Station station : lineStations)

            {

                Integer hwyNum = station.getHighwayNumber();

                DIRECTION dir = station.getDirection();

                Hashtable<Integer, DIRECTION> check = new Hashtable<>();

                check.put(hwyNum, dir);

                if(highwayTable.get(check) == null)

                {

                    ArrayList<Station> stnList = new ArrayList<>();

                    stnList.add(station);

                    Hashtable<Hashtable<Integer, DIRECTION>, ArrayList<Station>>

                            newEntry = new Hashtable();

                    newEntry.put(check, stnList);

                    highwayTable.putAll(newEntry);

                }

                else

                {

                    highwayTable.get(check).add(station);

                }

            }

        }

        

        Set<Hashtable<Integer, DIRECTION>> hwyKeys = highwayTable.keySet();

        for(Hashtable<Integer, DIRECTION> hwyKey : hwyKeys)

        {

            Enumeration<Integer> hwyNumEnum = hwyKey.keys();

            Integer hwyNum = hwyNumEnum.nextElement();

            ArrayList<Station> hwyStations = highwayTable.get(hwyKey);

            DIRECTION hwyDir = hwyKey.get(hwyNum);

            Collections.sort(highwayTable.get(hwyKey));

            System.out.println("Adding highway: " + hwyNum + " " + hwyDir.name + " " + hwyStations.size());

            highways.add(new Highway(hwyNum, 

                    hwyDir, hwyStations));

        }

        return highways;

    }

    /*

     private ArrayList<FEPLine> loadLines(String highwayMetaFileName) {

     ArrayList<FEPLine> lines = new ArrayList<>();

     try {

     Scanner sc = new Scanner(new File(highwayMetaFileName));

     String firstLine = sc.nextLine();



     Scanner linesc = new Scanner(firstLine);

     int numLines = linesc.nextInt();

     linesc.close();



     for (int i = 0; i < numLines; i++) {

     System.out.println("CURR: " + i);

     lines.add(loadLine(sc));

     }

     sc.close();



     } catch (FileNotFoundException ex) {

     Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);

     }

     return lines;

     }



     private FEPLine loadLine(Scanner sc) {

     String line = sc.nextLine();

     System.out.println(line);

     Scanner scline = new Scanner(line);



     int lineNum = scline.nextInt();

     int count = scline.nextInt();

     int numStations = scline.nextInt();

     ArrayList<Station> stations = new ArrayList<>();

     for (int i = 0; i < numStations; i++) {

     stations.add(loadStation(sc, lineNum));

     }



     return new FEPLine(lineNum, stations, count);

     }



     private Station loadStation(Scanner sc, int lineNum) {

     String line = sc.nextLine();

     System.out.println(line);

     Scanner scline = new Scanner(line);

     int ldsID = scline.nextInt();

     int drop = scline.nextInt();

     int fwy = scline.nextInt();

     DIRECTION dir = DIRECTION.getEnum(scline.next());

     double postmile = scline.nextDouble();

     int numLoops = scline.nextInt();

     String location = getStationLoc(line);

     ArrayList<LoopDetector> loops = new ArrayList<>();

     for (int i = 0; i < numLoops; i++) {

     loops.add(loadLoop(sc));

     }



     return new Station(lineNum, ldsID, drop, location, loops, fwy, dir, postmile);

     }



     private LoopDetector loadLoop(Scanner sc) {

     String line = sc.nextLine();

     Scanner scline = new Scanner(line);



     int loopID = scline.nextInt();

     int laneNum = scline.nextInt();

     String loopLoc = getLoopLoc(line); // NEED GET LOOPLOC

     scline.close();

     return new LoopDetector(loopID, loopLoc, laneNum);

     }



     private String getLoopLoc(String line) {

     Scanner sc = new Scanner(line);

     sc.nextInt();

     sc.nextInt();



     // GRABS FROM CURRENT TO END OF LINE

         

     sc.useDelimiter("\\z");

     String loc = sc.next().trim();

     sc.close();

     return loc;

     }



     // Returns the loction given the whole line from the lookup file

     private String getStationLoc(String line) {

     Scanner scline = new Scanner(line);

     scline.nextInt();

     scline.nextInt();

     scline.nextInt();

     scline.next();

     scline.nextDouble();

     scline.nextInt();



     // GRABS FROM CURRENT TO END OF LINE

     scline.useDelimiter("\\z");

     String loc = scline.next().trim();

     scline.close();

     return loc;

     }

     */



    public void writeToFEP() {

        try {

            Socket sock = new Socket(FEPHostName, FEPPortNum);

            PrintWriter out = new PrintWriter(sock.getOutputStream(), true);

            out.println(this.toXML());

            sock.close();

        } catch (IOException ex) {

            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);

        }

    }



    // CHECK: DO WE EVEN NEED TO DO THIS?

    private void updateSequences() {

        for (FEPLine line : lines) {

            line.updateSequences();

        }

    }



    /**

     * Returns the network metadata in condensed form. This is just a quick

     * script function to make a proper highway metadata configuration file, so

     * that we can read the network faster.

     *

     * @return Network metadata

     */

    public void writeHighwaysMeta(String fileName) {



        try {

            FileWriter fw = new FileWriter(new File(fileName));

            StringBuilder build = new StringBuilder();

            build.append(lines.size());

            build.append("\n");

            System.out.println(lines.size());

            fw.write(build.toString());

            int count = 1;

            for (FEPLine line : lines) {

                System.out.println("Writing num: " + count);

                count++;

                fw.write(line.getLineMeta());



            }

        } catch (IOException ex) {

            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);

        }

    }



    public String toXML() {

        String xml = null;

        try {

            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

            DocumentBuilder builder = factory.newDocumentBuilder();

            Document theDoc = builder.newDocument();



            Element networkElement = theDoc.createElement(XML_TAGS.NETWORK.tag);

            theDoc.appendChild(networkElement);



            for (FEPLine line : lines) {

                line.toXML(networkElement);

            }



            Transformer tf = TransformerFactory.newInstance().newTransformer();



            tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");

            tf.setOutputProperty(OutputKeys.INDENT, "yes");

            tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");



            Writer out = new StringWriter();

            tf.transform(new DOMSource(theDoc), new StreamResult(out));

            xml = out.toString();

            out.close();

        } catch (Exception ex) {

            Logger.getLogger(Highways.class.getName()).log(Level.SEVERE, null, ex);

        }

        return xml;



    }



    private static enum XML_TAGS {



        NETWORK("Network");



        String tag;



        private XML_TAGS(String n) {

            tag = n;

        }

    }

}