filllxbianma.java

基于Java的地图数据管理软件。使用MySQL数据库管理系统。

package net.aetherial.gis.jiaotongbu.outputJTB.txtOutput.module.gpsdata.lxld.lx;

import org.w3c.dom.Node;
import net.aetherial.gis.surface.ItemValue;
import net.aetherial.gis.jiaotongbu.outputJTB.txtOutput.module.gpsdata.bianma.
    RoadBianma;
import net.aetherial.gis.jiaotongbu.output.publicuse.Item;
import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;

/**
 * <p>Title: </p>
 *
 * <p>Description: </p>
 *
 * <p>Copyright: Copyright (c) 2004</p>
 *
 * <p>Company: </p>
 *
 * @author not attributable
 * @version 1.0
 */
public class FillLXBianma {
  private Hashtable haveBMNodes = new Hashtable();
  private Hashtable haveBMTNodes = new Hashtable();
  private LXNodeManager manager = null;
  /**
   * 路线编码注意的问题有:
   * 1.编码不能有重复的
   *    已有的编码要记录并在新生成的编码里面去除
   * 2.准确判断路线的等级
   */
  public FillLXBianma(LXNodeManager manager) {
    this.manager = manager;
  }

  /**
   * 将已经有编码的路线编码填充好,
   * 并分别记录在haveBMNodes,haveBMTNodes里面
   */
  public void setHaveBianmasRoad() {

//    Node[] trks = this.manager.getAllIndependentLXNodes();
    Enumeration keys = ItemValue.namedTracks.keys();
    String bianma = "";
//    if (keys != null) {
//      for (int i = 0; i < trks.length; i++) {
//        bianma = ItemValue.getTracksNumber(trks[i]);
//        System.out.print(bianma);
//        if (RoadBianma.isBianmaSuitable(bianma)) {
//          bianma = this.getHaveBianmasRoad(trks[i]);
//          this.haveBMNodes.put(trks[i], bianma);
//          ItemValue.setTracksNumber(trks[i], bianma);
//          System.out.println(" ==>" + bianma);
//        }
//      }
//    }

    while(keys.hasMoreElements()){
      String key = (String) keys.nextElement();
      if (RoadBianma.isBianmaSuitable(key)) {
          bianma = RoadBianma.getBianmaSuitable(key) + Item.getSix_6_XianNumber();
          ItemValue.numberedTracks.put(key, bianma);
//          ItemValue.setTracksNumber(trks[i], bianma);
//          System.out.println(" ==>" + bianma);
        }else{
          String flag = RoadBianma.FLAG_C;

          ItemValue.numberedTracks.put(key, RoadBianma.getRoadNewRightNUmber(flag));

        }
    }

//    TwoNode[] ttrks = this.manager.getTwoNode();
//    if (ttrks != null) {
//      for (int i = 0; i < ttrks.length; i++) {
//        bianma = getHaveBianmasRoad(ttrks[i]);
//        if (RoadBianma.isBianmaSuitable(bianma)) {
//          haveBMTNodes.put(ttrks[i], bianma);
//          ItemValue.setTracksNumber(ttrks[i].getNode1(), bianma);
//          ItemValue.setTracksNumber(ttrks[i].getNode2(), bianma);
//        }
//      }
//    }

  }

  /**
   * 得到没有编码的路线节点
   */
  private Node[] getNoBMNodes() {
    Vector temp = new Vector();
    Node[] independentNodes = manager.getAllIndependentLXNodes();
    for (int i = 0; i < independentNodes.length; i++) {
      if (!haveBMNodes.containsKey(independentNodes[i])) {
        temp.addElement(independentNodes[i]);
      }
    }
    independentNodes = new Node[temp.size()];
    for (int i = 0; i < temp.size(); i++) {
      independentNodes[i] = (Node)temp.elementAt(i);
    }
    return independentNodes;
  }

  /**
   * 得到没有编码的路线双节点
   */
  private TwoNode[] getNoBMTNodes() {
    Vector temp = new Vector();
    TwoNode[] doubleNodes = manager.getTwoNode();
    for (int i = 0; doubleNodes != null && i < doubleNodes.length; i++) {
      if (!haveBMTNodes.containsKey(doubleNodes[i])) {
        temp.addElement(doubleNodes[i]);
      }
    }
    doubleNodes = new TwoNode[temp.size()];
    for (int i = 0; i < temp.size(); i++) {
      doubleNodes[i] = (TwoNode)temp.elementAt(i);
    }
    return doubleNodes;
  }


  /**
   * 判断新生成的编码是否使用过
   */
  private boolean isNewBMInUse(String newBianma) {
    if (haveBMNodes.containsValue(newBianma)) {
      return true;
    }else if(haveBMTNodes.containsValue(newBianma)){
      return true;
    }else{
      return false;
    }
  }

  /**
   * 得到新的编码
   */
  private String getNewBianma(Object lx) {
    if (Node.class.isInstance(lx)) {
      return RoadBianma.getRoadNewRightNUmber((Node)lx);
    }else{
      return RoadBianma.getRoadNewRightNUmber(((TwoNode)lx).getNode1());
    }
  }

  private void fillBianMa(Object lx){
    String newBianma = "";
    if (Node.class.isInstance(lx)) {
      Node node = (Node)lx;
      newBianma = getNewBianma(node);
      if (!isNewBMInUse(newBianma)) {
        ItemValue.setTracksNumber(node, newBianma);
      }else{
        fillBianMa(node);
      }
    }else{
      TwoNode node = (TwoNode)lx;
      newBianma = getNewBianma(node);
      if (!isNewBMInUse(newBianma)) {
        ItemValue.setTracksNumber(node.getNode1(), newBianma);
        ItemValue.setTracksNumber(node.getNode2(), newBianma);
      }else{
        fillBianMa(node);
      }
    }

  }
  /**
   * 将没有编码的路线按次序填充编码
   */
  public void fillNoBMWithBM() {
    Node[] noFBNodes = this.getNoBMNodes();
    if (noFBNodes != null) {
      for (int i = 0; i < noFBNodes.length; i++) {
        this.fillBianMa(noFBNodes[i]);
      }
    }

    TwoNode[] tn = this.getNoBMTNodes();
    if (tn != null) {
      for (int i = 0; i < tn.length; i++) {
        this.fillBianMa(tn[i]);
      }
    }
  }



  /**
   * 将已经有编码的路线编码填充好
   */
  private String getHaveBianmasRoad(TwoNode ttrk) {
    Node n1 = ttrk.getNode1();
    Node n2 = ttrk.getNode2();
    String bm1 = ItemValue.getTracksNumber(n1);
    String bm2 = ItemValue.getTracksNumber(n2);
    String bianma = "";
    if (RoadBianma.isBianmaSuitable(bm1)) {
      bianma = RoadBianma.getBianmaSuitable(bm1) + Item.getSix_6_XianNumber();
    }
    else if (RoadBianma.isBianmaSuitable(bm2)) {
      bianma = RoadBianma.getBianmaSuitable(bm1) + Item.getSix_6_XianNumber();
    }
    return bianma;
  }

  /**
   * 将已经有编码的路线编码填充好
   */
  private String getHaveBianmasRoad(Node trk) {
    String bianma = ItemValue.getTracksNumber(trk);
    Item.setXianName(ItemValue.getTracksT2(trk));
    return RoadBianma.getBianmaSuitable(bianma) + Item.getSix_6_XianNumber();
  }
}