orderdetailsmanhourmap.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 com.power.pipeengine.InputData.*;
import com.power.pipeengine.Entity.*;
import java.io.*;
import com.power.pipe.*;
import com.power.util.Message.*;
import com.power.pipeengine.DispatchReport.*;
import java.text.*;

public class OrderDetailsManHourMap extends InputReader {

    private Vector allOdrs = new Vector();
    private Vector distinctStyles = new Vector();
    private Hashtable hashedDistinctStyles = new Hashtable();
    private Hashtable stylesByOrder = new Hashtable();
    private Hashtable stylesByOrderNew = new Hashtable();

    private Hashtable stylesByOrderUnique = new Hashtable();
    private Hashtable stylesByProcID = new Hashtable();

    private Hashtable orderByDueDate = new Hashtable();

	private String _fileName = "orderdetailsmanhour";

    private static final OrderDetailsManHourMap INSTANCE =
                              new OrderDetailsManHourMap();

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

    public static OrderDetailsManHourMap getInstance( ) {
        return INSTANCE;
    }


	protected String getFileName() {
		return _fileName;
	}

    public Vector getAllStyles() {
        return allOdrs;
    }

    public void addDistinctStyle( Style aStyle ) {
      /*ProductDemands prodDmds = DataModel.getInstance().getProductDemands();
      Hashtable lastRoutes = prodDmds.getLastRoutes();

      if( null == lastRoutes.get( aStyle.getRouteID() ) ) {
          return;
      }*/

    String key = aStyle.getOrderID() + "&" +
        aStyle.getStyleID() + "&" + new Integer( aStyle.getProcessID() ).toString();

    if( aStyle.getNextProcessID() < 0 ) {
      if( null == hashedDistinctStyles.get( key ) ) {
        hashedDistinctStyles.put( key, aStyle );
        for( int i=0; i<distinctStyles.size(); i++ ) {
          Style tmpStyle = (Style) distinctStyles.elementAt( i );
          if( tmpStyle.getDueDate().after( aStyle.getDueDate() ) ) {
            distinctStyles.insertElementAt( aStyle, i );
            return;
          }
        }
        distinctStyles.add(aStyle);
      }
      return;
    }

      /*if( distinctStyles.size() == 0 ) {
            distinctStyles.add( aStyle );
            return;
        }*/

        //distinctStyles.add( aStyle );

       /* for( int i=0; i<distinctStyles.size(); i++ ) {
            Style tmpStyle = (Style) distinctStyles.elementAt( i );
            if( tmpStyle.getOrderID().equals( aStyle.getOrderID() ) &&
                tmpStyle.getStyleID().equals( aStyle.getStyleID() ) ) {
                if( aStyle.getProcessID() > tmpStyle.getProcessID() ) {
                    distinctStyles.remove( tmpStyle );
                    distinctStyles.add( aStyle );
                    return;
                } else {
                    return;
                }
            }
        }

        distinctStyles.add( aStyle );*/
    }

    public Vector getDistinctStyles() {
        return distinctStyles;
    }

    public void computeStartTimeOffset() {
      int cycleTime = SimpleDispatchRule.getInstance().getCycleTime();
      double percent = 1/(double) cycleTime;
      for( int i=0; i<distinctStyles.size(); i++ ) {
        Style aStyle = (Style) distinctStyles.elementAt( i );
        Vector styles = getStyles( aStyle.getOrderID(),
                                   aStyle.getStyleID() );
        Vector reorderedStyles = new Vector();
        double cumProcTime = 0;
        for( int j=0; j<styles.size(); j++ ) {
          Style tmpStyle = (Style) styles.elementAt(j);
          reorderedStyles.add( tmpStyle );
          cumProcTime += tmpStyle.getProcessingTime();
        }

        for( int j=0; j<styles.size(); j++ ) {
          Style tmpStyle = (Style) styles.elementAt( j );
          reorderedStyles.remove( tmpStyle );
          if( tmpStyle.getNextProcessID() < 0 ) {
            reorderedStyles.add( tmpStyle );
            continue;
          }
          for( int k=0; k<reorderedStyles.size(); k++ ) {
            Style rStyle = (Style) reorderedStyles.elementAt( k );
            if( tmpStyle.getNextProcessID() == rStyle.getProcessID() ) {
              reorderedStyles.insertElementAt( tmpStyle, k );
              break;
            }
          }
        }
        /*for( int k=0; k<reorderedStyles.size(); k++ ) {
          Style rStyle = (Style) reorderedStyles.elementAt(k);
          System.out.println( rStyle.getProcessID() + "\t" +
                              rStyle.getNextProcessID() );
        }*/

        double cum = 0;
        for( int k=0; k<reorderedStyles.size(); k++ ) {
          Style rStyle = (Style) reorderedStyles.elementAt(k);
          cum += rStyle.getProcessingTime();
          double ratio = cum / cumProcTime;
          for( int m=0; m<cycleTime; m++ ) {
            if( rStyle.getNextProcessID() < 0 )
            if( ratio < (m+1)*percent + 0.0005 ) {
              rStyle.stStartDateOffset( m );
              break;
            }
          }
        }

      }
    }

    public Vector getDistinctStyleByOrder( String orderID ) {
      Vector rtnVec = new Vector();
      for( int i=0; i<distinctStyles.size(); i++ ) {
        Style aStyle = (Style) distinctStyles.elementAt( i );
        if( aStyle.getOrderID().equals( orderID ) ) {
          boolean inserted = false;
          for( int k=0; k<rtnVec.size(); k++ ) {
            Style tmpStyle = (Style) rtnVec.elementAt( k );
            if( tmpStyle.getDueDate().after( aStyle.getDueDate() ) ) {
              rtnVec.insertElementAt( aStyle, k );
              inserted = true;
              break;
            }
          }
          if( !inserted ) {
            rtnVec.add(aStyle);
          }
        }
      }
      return rtnVec;
    }

    public int getDemandForDetailedStyle( String orderID, String detailedStyleID ) {
      Vector vec = getDistinctStyleByOrder( orderID );
      for( int i=0; i<vec.size(); i++ ) {
        Style aStyle = (Style) vec.elementAt( i );
        if( aStyle.isPartOfStyle( detailedStyleID ) ) {
          return getDemand(orderID, aStyle.getStyleID() );
        }
      }
      return 0;
    }

    public void addStyleByOrder( Style aStyle ) {
      String orderID = aStyle.getOrderID();
      Hashtable styles = (Hashtable) stylesByOrder.get( orderID );
      if( null == styles ) {
        styles = new Hashtable();
        stylesByOrder.put( orderID, styles );
      }
      String styleID = aStyle.getStyleID();
      Vector vec = (Vector) styles.get( styleID );
      if( null == vec ) {
        vec = new Vector();
        styles.put( styleID, vec );
      }
      vec.add( aStyle );
      addStyleByOrderNew( aStyle );
    }

    public void addStyleByOrderNew( Style aStyle ) {
      String orderID = aStyle.getOrderID();
      if( PlanInUse.getInstance().isExistingOrder( orderID ) ) return;

      Hashtable styles = (Hashtable) stylesByOrderNew.get( orderID );
      if( null == styles ) {
        styles = new Hashtable();
        stylesByOrderNew.put( orderID, styles );
      }
      String styleID = aStyle.getStyleID();
      Vector vec = (Vector) styles.get( styleID );
      if( null == vec ) {
        vec = new Vector();
        styles.put( styleID, vec );
      }
      vec.add( aStyle );
    }

    public Hashtable getStylesByOrder() {
     // return stylesByOrder;
      return stylesByOrderNew;
    }

    public Hashtable getStylesByOrderNew() {
      return stylesByOrderNew;
    }

    public Vector getStyles( String orderID, String styleID ) {
      Hashtable styles = (Hashtable) stylesByOrder.get( orderID );
      if(null == styles ) return null;
      return (Vector) styles.get( styleID );
    }

    public int getDemand( String orderID, String styleID ) {
      Vector styles = getStyles( orderID, styleID );
      if( null == styles || styles.size() == 0 ) {
        return 0;
      }

      Style aStyle = (Style) styles.elementAt( 0 );
      return aStyle.getQuantity();
    }

    public Vector getOrderIDByDueDate() {
      Vector orderIDs = new Vector();
      Vector dueDates = new Vector();
      Enumeration keys = orderByDueDate.keys();
      while( keys.hasMoreElements() ) {
        String orderID = (String) keys.nextElement();
        Date aDate = (Date) orderByDueDate.get( orderID );
        boolean inserted = false;

        for( int i=0; i<orderIDs.size(); i++ ) {
          Date curDate = (Date) dueDates.elementAt( i );
          if( curDate.after( aDate ) ) {
            orderIDs.insertElementAt( orderID, i );
            dueDates.insertElementAt( aDate, i );
            inserted = true;
            break;
          }
        }
        if( !inserted ) {
          orderIDs.add( orderID );
          dueDates.add( aDate );
        }
      }
      return orderIDs;
    }

    private void updateDueDate( Style aStyle ) {
      Date earliestDueDate = (Date) orderByDueDate.get ( aStyle.getOrderID() );

      if( null == earliestDueDate ) {
        orderByDueDate.put( aStyle.getOrderID(), aStyle.getDueDate() );
        return;
      }

      if( earliestDueDate.after( aStyle.getDueDate() ) ) {
        orderByDueDate.put( aStyle.getOrderID(), aStyle.getDueDate()  );
      }
    }


    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() < 8) {
          MessageArea.getInstance().addMessage("File " + getFileName() +
                                               " reading error: " +
                                               "Insufficient number of columns: " +
                                               st.countTokens() + " found; " +
                                               " 8 required\n");
        }


        Integer rteID = new Integer(st.nextToken());
        String orderID = new String(st.nextToken());
        String detailedStyleID = new String(st.nextToken());
        String styleID = new String(st.nextToken());
        Integer procID = new Integer(st.nextToken());
        Integer nextProcID = new Integer(st.nextToken());
        Integer qty = new Integer(st.nextToken());
        Double procTime = new Double(st.nextToken());
        String dueDateStr = st.nextToken();
        Date dueDate = sdfInput.parse(dueDateStr);

        String key = orderID + "&" + styleID + "&" + procID.toString();

        Style aStyle = (Style) stylesByOrderUnique.get( key );

        if( null ==  aStyle ) {
          aStyle = new Style(rteID,
                             orderID,
                             styleID,
                             procID,
                             nextProcID,
                             new Integer( 0 ),
                             procTime);
          allOdrs.add(aStyle);
          aStyle.setDueDate(dueDate);
          addStyleByOrder( aStyle );
          stylesByOrderUnique.put( key, aStyle );

          Vector styles = (Vector) stylesByProcID.get( procID.toString() );
          if( null == styles ) {
            styles = new Vector();
            stylesByProcID.put( procID.toString(), styles );
          }
          insertByQty( styles, aStyle );
          updateDueDate( aStyle );
        }

        aStyle.addDetailedStyleID( detailedStyleID );
        aStyle.accumDemand( qty );

        addDistinctStyle(aStyle);

        ProcessRequirement.getInstance().updateRqmt( procID, qty.intValue(), procTime.doubleValue());

        aLine = d.readLine();
      }

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

    private void insertByQty( Vector vec, Style aStyle ) {
      for( int i=0; i<vec.size(); i++ ) {
        Style tmpStyle = (Style) vec.elementAt( i );
        if( aStyle.getQuantity() >= tmpStyle.getQuantity() ) {
          vec.insertElementAt( aStyle, i );
          return;
        }
      }
      vec.add( aStyle );
    }

    public int getNumOfStylesByProcID( int procID ) {
      String key = new Integer( procID ).toString();
      return ((Vector) stylesByProcID.get( key ) ).size();
    }

    public double getRank( Style aStyle ) {
      String key = new Integer( aStyle.getProcessID() ).toString();
      Vector styles = (Vector) stylesByProcID.get( key );
      for( int i=0; i<styles.size(); i++ ) {
        Style tmpStyle = (Style) styles.elementAt(i);
        if( aStyle.getQuantity() == tmpStyle.getQuantity() ) {
          return i+1;
        }
      }

      return styles.size();

    }

    public void readjustRank( Style aStyle ) {
      String key = new Integer( aStyle.getProcessID() ).toString();
      Vector styles = (Vector) stylesByProcID.get( key );
      for( int i=0; i<styles.size(); i++ ) {
        Style tmpStyle = (Style) styles.elementAt(i);
        if( aStyle.equals( tmpStyle ) ) {
          styles.remove( i );
          styles.add( tmpStyle );
          return;
        }
      }
    }

    public Vector getAllDetailedOrders() {
        return allOdrs;
    }

}