perioddatemap.java

今天为网友提供的是JAVA源码

package com.power.pipeengine.DispatchReportMap;

/**
 * <p>Title: PIPE Engine</p>
 * <p>Description: Global Planning Optimization Engine</p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: Paraster, Inc.</p>
 * @author unascribed
 * @version 1.0
 */

import java.util.*;
import java.io.*;
import java.text.*;
import com.power.pipeengine.*;
import com.power.pipeengine.Entity.*;
import com.power.pipeengine.InputData.*;
import com.power.pipe.*;
import com.power.util.Message.*;
import com.power.pipeengine.DispatchReportMap.*;

public class PeriodDateMap
    extends InputReader {
  static ResourceBundle res = ResourceBundle.getBundle(
      "com.power.pipeengine.Res",
      EngineConfig.getInstance().getLocale());
  private String _fileName = "perioddatemap";

  private Vector mapTable = new Vector();
  private Hashtable groupByDate = new Hashtable();

  private double[] hoursInBuckets = new double[DataModel.getInstance().
      getCalendar().getTotalNumOfBuckets()];

  private static final PeriodDateMap INSTANCE =
      new PeriodDateMap();

  // Private constructor supresses
  // default public constructor
  private PeriodDateMap() {
  }

  public static PeriodDateMap getInstance() {
    return INSTANCE;
  }

  public Vector getPeriodsInDate(Date aDate) {
    return (Vector) groupByDate.get(aDate.toString());
  }

  public boolean isLastBucketInDate(Date aDate, int bucketID) {
    Vector buckets = getPeriodsInDate(aDate);
    for (int i = 0; i < buckets.size(); i++) {
      PeriodDate pd = (PeriodDate) buckets.elementAt(i);
      if (pd.getBucketID() > bucketID) {
        return false;
      }
    }

    return true;
  }

  public double getDateEndTime(Date aDate) {
    Vector buckets = getPeriodsInDate(aDate);

    double workHoursInDate = 0;
    for (int i = 0; i < buckets.size(); i++) {
      PeriodDate pd = (PeriodDate) buckets.elementAt(i);
      workHoursInDate += hoursInBuckets[pd.getBucketID() - 1];
    }

    WorkingHours wh = WorkingHours.getInstance();

    return workHoursInDate + wh.getAMStartTime() +
        wh.getLunchBreakLenght() +
        wh.getDinnerBreakLength();
  }

  public boolean haveSameStartDate(int bucket1, int bucket2) {
    PeriodDate pd1 = (PeriodDate) mapTable.elementAt(bucket1 - 1);
    PeriodDate pd2 = (PeriodDate) mapTable.elementAt(bucket2 - 1);
    if (pd1.getStartingDate().compareTo(pd2.getStartingDate()) == 0) {
      return true;
    }

    return false;
  }

  protected String getFileName() {
    return _fileName;
  }

  double[] startingHours = null;

  private void setStartingHours() {
    startingHours = new double[8];
    //AM
    startingHours[0] = WorkingHours.getInstance().getAMStartTime();
    startingHours[1] = startingHours[0] + 2;

    //PM
    startingHours[2] = WorkingHours.getInstance().getPMStartTime();
    startingHours[3] = startingHours[2] + 2;

    //Evening
    for (int i = 4; i < startingHours.length; i++) {
      startingHours[i] = WorkingHours.getInstance().getEveningStartTime()
          + 2 * (i - 4);
    }
  }

  private double getHoursInDay(int seqNum) {
    return startingHours[seqNum - 1];
  }

  private long inMilliSecs = 60 * 60 * 1000;

  public Date getDateBucketBelongsTo(int bucketID) {
    PeriodDate pd = (PeriodDate) mapTable.elementAt(bucketID - 1);
    return pd.getStartingDate();
  }

  public Date getStartingTime(int bucketID) {
    PeriodDate pd = (PeriodDate) mapTable.elementAt(bucketID - 1);
    //Date startingDate = new Date( pd.getStartingDate().getTime() );
    Date startingDate = new Date(pd.getStartingDate().getTime() +
                                 (long) (getHoursInDay(pd.getSequenceNumber()) *
                                         inMilliSecs));

    return startingDate;
  }

  public Date getEndingTime(int bucketID) {
    PeriodDate pd = (PeriodDate) mapTable.elementAt(bucketID - 1);
    Vector tmpVec = (Vector) groupByDate.get(pd.getStartingDate().toString());
    Date rtnDate;
    if (tmpVec.size() == 1) {
      double elapsedHours = WorkingHours.getInstance().getAMStartTime() +
          hoursInBuckets[bucketID - 1] +
          WorkingHours.getInstance().getLunchBreakLenght() +
          WorkingHours.getInstance().getDinnerBreakLength();

      rtnDate = new Date(pd.getStartingDate().getTime() +
                         (long) (elapsedHours * inMilliSecs));
    }
    else {
      rtnDate = new Date(pd.getStartingDate().getTime() +
                         (long) ( (2 + getHoursInDay(pd.getSequenceNumber())) *
                                 inMilliSecs));
    }

    return rtnDate;

  }

  public Date getFirstBucketDate() {
    PeriodDate pd = (PeriodDate) mapTable.firstElement();
    return pd.getStartingDate();
  }

  public Date getLastBucketDate() {
    PeriodDate pd = (PeriodDate) mapTable.lastElement();
    return pd.getStartingDate();
  }

  public void readData() throws Exception {
    BufferedReader d = super.getReader();

    if (null == d) {
      return;
    }

    String token = GlobalConfig.getInstance().getSeparator();
    String aLine = d.readLine();
    SimpleDateFormat sdfInput = new SimpleDateFormat("yyyy-MM-dd");
    sdfInput.setDateFormatSymbols(new DateFormatSymbols(Locale.CHINA));

    while (aLine != null) {
      if (aLine.length() <= 1) {
        aLine = d.readLine();
        continue;
      }
      StringTokenizer st = new StringTokenizer(aLine, token);

      if (st.countTokens() < 3) {
        MessageArea.getInstance().addMessage("File " + getFileName() +
                                             " reading error: " +
                                             "Insufficient number of columns: " +
                                             st.countTokens() + " found; " +
                                             " 3 required\n");
      }

      int seqID = new Integer(st.nextToken()).intValue();
      int bucketID = new Integer(st.nextToken()).intValue();
      String startDate = st.nextToken();
      Date date = sdfInput.parse(startDate);

      PeriodDate pd = new PeriodDate(bucketID, seqID, date);
      mapTable.add(pd);
      hoursInBuckets[bucketID - 1] = workHoursInBucket(bucketID);

      pd.setBucketLength(hoursInBuckets[bucketID - 1]);

      Vector bucketsInDate = (Vector) groupByDate.get(date.toString());
      if (null == bucketsInDate) {
        bucketsInDate = new Vector();
        groupByDate.put(date.toString(), bucketsInDate);
      }
      bucketsInDate.add(pd);

      aLine = d.readLine();
    }

    this.setStartingHours();

    d.close();
    super.closeURLConnection();
  }

  private double workHoursInBucket(int bucketID) {
    Facilities allFacilities = DataModel.getInstance().getFacilities();

    Facility anMFacility = (Facility) allFacilities.getManuFacilities().
        elementAt(0);

    return 2 * anMFacility.getNumWorkingDaysForBucket(bucketID);
  }

  public double[] getCopyOfHoursInBuckets() {
    double[] aCopy = new double[DataModel.getInstance().getCalendar().
        getTotalNumOfBuckets()];
    for (int i = 0; i < aCopy.length; i++) {
      aCopy[i] = hoursInBuckets[i];
    }

    return aCopy;
  }

}