modelreader.java

著名IT公司ILog的APS高级排产优化引擎

package com.power.lpsolver.LPSolve;

import java.io.*;
import java.util.ResourceBundle;
import com.power.pipeengine.*;

public class ModelReader
{
    static ResourceBundle res = ResourceBundle.getBundle("com.power.lpsolver.LPSolve.Res",
                                                          EngineConfig.getInstance().getLocale() );
    private File _inputFile;
	private String _fileName;

	public ModelReader() {
		_fileName = "d:\\Paraster\\POE\\DataModel\\lpmodel.lp";
		_inputFile = new File( _fileName );
	}

	public void setFileName( String fileName ) {
		_fileName = fileName;
	}

	private void testFile() throws IOException {
		if( !_inputFile.exists() ) {
			abort( res.getString("File_does_not_exist_") + _fileName );
		}

		if( !_inputFile.isFile() ) {
			abort( res.getString("File_is_a_directory") + _fileName );
		}

		if( !_inputFile.canRead() ) {
			abort( res.getString("File_is_unreadable_") + _fileName );
		}
	}

	private static void abort( String msg ) throws IOException {
		throw new IOException( msg );
	}

	private void readParseObjectiveFunction( StreamTokenizer st ) throws IOException {
		String s = null;
		Model mdl = Model.getInstance();

		//read Maximize/Minimize
		st.nextToken();
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				s = Double.toString(st.nval);
				errorExit( res.getString("Error_1_unable_to_get") );
				break;
			case StreamTokenizer.TT_WORD:
				s = st.sval; // Already a String
				break;
			default: // single character in ttype
				s = String.valueOf((char)st.ttype);
				errorExit( res.getString("Error_2_unable_to_get") );
		}

		String upperCasedS = s.toUpperCase();
		if( upperCasedS.indexOf( "MAX" ) != -1 &&
			upperCasedS.indexOf( "MIN" ) != -1 ) {
			errorExit( res.getString("Error_3_unable_to_get") );
		}

		ObjectiveFunction objFunc = new ObjectiveFunction( upperCasedS );
		mdl.setObjectiveFunction( objFunc );

		//skip a colon if any
		if( isNextTokenColon( st ) ) {
			st.nextToken();
		}

		//read obj label
		st.nextToken();
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				errorExit( res.getString("Error_7_unexpected") );
				break;
			case StreamTokenizer.TT_WORD:
				objFunc.setName( st.sval );
				break;
			default: // single character in ttype
				objFunc.setName( String.valueOf((char)st.ttype) );
		}

		readFirstElement( objFunc, st );

		while(st.nextToken() != StreamTokenizer.TT_EOF) {
			switch(st.ttype) {
				case StreamTokenizer.TT_NUMBER:
					st.pushBack();
					readParseAnElement( objFunc, st );
					break;
				case StreamTokenizer.TT_WORD:
					s = st.sval; // Already a String
					if( s.toLowerCase().indexOf( "subject" ) >= 0 ) {
						st.nextToken(); //read and discard "to"
						return;
					} else {
						st.pushBack();
						readParseAnElement( objFunc, st );
					}
					break;
				default: // single character in ttype
					st.pushBack();
					readParseAnElement( objFunc, st );
			}
			//System.out.println( s );
		}

	}

	private void errorExit( String msg ) {
		System.out.println( msg );
		System.exit( 0 );
	}


	private void readParseAnElement( Constraint con,
									 StreamTokenizer st ) throws IOException {
		String s = null;
		double coeff = 1;
		String varName = null;
		String sign = null;

		st.nextToken(); //must be a '+' or '-'
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				errorExit( res.getString("Error_5_unexpected") );
				break;
			case StreamTokenizer.TT_WORD:
				System.out.println( st.sval );
				errorExit( res.getString("Error_6_unexpected") );
				break;
			default: // single character in ttype
				sign = String.valueOf((char)st.ttype);
		}

		//next either a number or a word/character
		st.nextToken();
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				coeff = st.nval;
				st.nextToken(); //read var name
				switch(st.ttype) {
					case StreamTokenizer.TT_NUMBER:
						errorExit( res.getString("Error_7_unexpected") );
						break;
					case StreamTokenizer.TT_WORD:
						varName = st.sval;
						break;
					default: // single character in ttype
						varName = String.valueOf((char)st.ttype);
				}
				break;
			case StreamTokenizer.TT_WORD:
				varName = st.sval;
				break;
			default: // single character in ttype
				varName = String.valueOf((char)st.ttype);
		}

		if( sign.equals( "-" ) ) {
			coeff *= -1;
		}

		int colIdx = Model.getInstance().getModelVariables().addVariable( varName );

		con.addElement( new Element( colIdx, coeff ) );
	}

	public boolean isNextTokenColon( StreamTokenizer st ) throws IOException {
		st.nextToken();
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				st.pushBack();
				return false;
			case StreamTokenizer.TT_WORD:
				st.pushBack();
				return false;
			default: // single character in ttype
				String s = String.valueOf((char)st.ttype);
				st.pushBack();
				if( s.equals( ":" ) ) {
					return true;
				} else {
					return false;
				}
		}

	}


	public void readModel() throws IOException {
		testFile();

		//long fileLength = _inputFile.length();

		FileReader fr = new FileReader( _inputFile );
		StreamTokenizer st = new StreamTokenizer( fr );
		st.wordChars( '#', '#' );
		st.wordChars( '~', '~' );
		st.ordinaryChar( '-' );
		st.eolIsSignificant( false );
		st.whitespaceChars( ':', ':' );
		st.whitespaceChars( ';', ';' );
		String s = null;

		readParseObjectiveFunction( st );
		int cnt = 0;

		while(st.nextToken() != StreamTokenizer.TT_EOF) {
			Constraint con = new Constraint( "row" + cnt, cnt );
			boolean rowLabelRead = false;

			switch(st.ttype) {
				case StreamTokenizer.TT_NUMBER:
					if( !rowLabelRead ) {
						errorExit( res.getString("Error_row_label") );
					}
					st.pushBack();
					readParseOneConstraint( con, st );
					break;
				case StreamTokenizer.TT_WORD:
					s = st.sval; // Already a String
					if( s.toLowerCase().indexOf( "end" ) >= 0 ) {
						return;
					} else if( !rowLabelRead ) {
						con.setName( s );
						rowLabelRead = true;
						readParseOneConstraint( con, st );
					} else {
						st.pushBack();
						readParseOneConstraint( con, st );
					}
					break;
				default: // single character in ttype
					if( !rowLabelRead ) {
						con.setName( String.valueOf((char)st.ttype) );
						rowLabelRead = true;
						readParseOneConstraint( con, st );
					} else {
						st.pushBack();
						readParseOneConstraint( con, st );
					}
			}
			cnt++;
			con.print();
			Model.getInstance().addConstraint( con );
		}

		fr.close();

	}

	public void readParseOneConstraint( Constraint con,
										StreamTokenizer st ) throws IOException {
		readFirstElement( con, st );
		String s = null;
		String signs = ">=<";

		while(st.nextToken() != StreamTokenizer.TT_EOF) {
			switch(st.ttype) {
				case StreamTokenizer.TT_NUMBER:
					st.pushBack();
					readParseAnElement( con, st );
					break;
				case StreamTokenizer.TT_WORD:
					st.pushBack();
					readParseAnElement( con, st );
					break;
				default: // single character in ttype
					s = String.valueOf((char)st.ttype);
					if( signs.indexOf( s ) < 0 ) {
						st.pushBack();
						readParseAnElement( con, st );
					} else {
						st.nextToken();
						switch(st.ttype) {
							case StreamTokenizer.TT_NUMBER:
								con.setSign( s );
								con.setRHS( st.nval );
								return;
							default: // single character in ttype
								String s1 = String.valueOf((char)st.ttype);
								if( signs.indexOf( s1 ) >= 0 ) {
									con.setSign( s + s1 );
									st.nextToken();
									switch( st.ttype ) {
										case StreamTokenizer.TT_NUMBER:
											con.setRHS( st.nval );
											return;
										case StreamTokenizer.TT_WORD:
											errorExit( res.getString("Error_unexpected") );
											break;
										default:
											s1 = String.valueOf((char)st.ttype);
											st.nextToken();
											if( s1.equals( "-" ) ) {
												con.setRHS( st.nval * -1 );
											} else {
												con.setRHS( st.nval );
											}
											return;
									}
								}
						}
					}
			}
			//System.out.println( s );
		}


	}


	private void readFirstElement( Constraint con,
								   StreamTokenizer st ) throws IOException {
		String s = null;
		double coeff = 1;
		String varName = null;
		String sign = "+";

		st.nextToken(); //must be a '+' or '-'
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				st.pushBack();
				break;
			case StreamTokenizer.TT_WORD:
				st.pushBack();
				break;
			default: // single character in ttype
				sign = String.valueOf((char)st.ttype);
		}

		//next either a number or a word/character
		st.nextToken();
		switch(st.ttype) {
			case StreamTokenizer.TT_NUMBER:
				coeff = st.nval;
				st.nextToken(); //read var name
				switch(st.ttype) {
					case StreamTokenizer.TT_NUMBER:
						errorExit( res.getString("Error_4_unexpected") );
						break;
					case StreamTokenizer.TT_WORD:
						varName = st.sval;
						break;
					default: // single character in ttype
						varName = String.valueOf((char)st.ttype);
				}
				break;
			case StreamTokenizer.TT_WORD:
				varName = st.sval;
				break;
			default: // single character in ttype
				varName = String.valueOf((char)st.ttype);
		}

		if( sign.equals( "-" ) ) {
			coeff *= -1;
		}

		int colIdx = Model.getInstance().getModelVariables().addVariable( varName );

		con.addElement( new Element( colIdx, coeff ) );

	}

}