View Javadoc
   /*
    * Created on Dec 3, 2003
    * AbstractFileInputAdapter.java
    */
   package com.rhi.architecture.parc.adapter.file;
   
   import java.io.BufferedReader;
   import java.io.IOException;
   import java.io.Reader;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Properties;
  
  import com.rhi.architecture.lang.StringUtils;
  import com.rhi.architecture.logging.LogUtil;
  import com.rhi.architecture.logging.Logger;
  import com.rhi.architecture.parc.ProcessingException;
  import com.rhi.architecture.parc.Record;
  import com.rhi.architecture.parc.adapter.AbstractInputAdapter;
  import com.rhi.architecture.resource.InitializationException;
  
  /***
   * AbstractFileInputAdapter
   * 
   * Should serve as a common base classes that all kinds of file input adapters can
   * share. File input adapters can work with one fixed file or on a directory on 
   * polling basis or some other type. This base class should be flexible enough to
   * cater for different file input adapters.
   * 
   * @author Vaibhav Ranjangaonkar
   * @version 1.0
   */
  public abstract class AbstractFileInputAdapter extends AbstractInputAdapter {
  
  	private static Logger log = LogUtil.getLogger( AbstractFileInputAdapter.class );
  	
  	private static final String DELIMITER= "FlatFileInputAdapter.FLAT_FILE_DELIMITER";
  	
  	private static final String BATCH_SIZE= "FlatFileInputAdapter.FLAT_FILE_BATCH_SIZE";
  	 
  	private String delim; // column delimiter	 	
  	
  	private int batchSize; // size of records to be read in one batch
  
  	/***
  	 * constructor 
  	 */
  	public AbstractFileInputAdapter() {
  		super(); 
  	}	
  	
     /***
  	* <p>
  	* Performs any resource initialization.
  	* <br>Initilizes following things:
  	* <ul>
  	* <li> Logger object
  	* <li> Flat file related information like 1) file name {@link #delim}
  	* 2) no. of records to be read from file in the one batch {@link #batchSize}
  	* <li> BufferedReader {@link #m_BufferReader} , to read the file line 
  	* by line in different batches.
  	* </ul>
  	* </p>
  	* @param   props <b>Properties</b> Property object, to store the 
  	* initialization parameters.
  	* @exception   <b>InitializationException</b> It throws the 
  	* initialization exception, if it occurs during any of the
  	*               above mentioned initialization.
  	* @since 1.0
  	*/
  	public void init( Properties props ) throws InitializationException {      
  		super.init( props );      
  		initBatchSize( props );
  		initDelimiter( props );      
      }
  
     /***
  	* Reads the file one record at a time using readRecordString(), parses 
  	* each record into column values and passes this list of colums to the
  	* method readRow(). Subclasses provide implementation of readRow() that
  	* takes this list of columns and return a class implementing Record interface.
  	* 
  	* Although, default behaviour is to treat each line as a record, that may
  	* not be true always, subclasses can then extend this class using the hooks 
  	* provided. 
  	*
  	* @see readRecordString( String )
  	* @see parseRecordString( String )
  	* @see readRow( ArrayList )
  	* 
  	* @return      <b>Collection</b> contains the list of generic record, read from flat file.
  	* @exception   <b>ProcessingException</b> It throws the ProcessingException,
  	*              if there is a error during the reading of afile.
  	*
  	* @since 1.0
  	*/
  	protected Collection loadBatch() throws ProcessingException {
        log.debug( "AbstractFileInputAdapter : loadBatch()" );
 	  ArrayList records = new ArrayList();      
       
       try {         
          int counter = 0;		 
          // getBatchSize() is used instead of batchSize to give subclasses
          // an opportunity to override batch size from properties if they want.
          while ( ( counter < getBatchSize() ) ||
          		    ( getBatchSize() == 0 ) ) 
          {
             String strRec = readRecordString();
             if (strRec == null) {
                log.debug( "End of file: ");
                break;
             }            
 		    log.debug( "Line read from the file is : " + strRec );
 		    counter++;
 		    
 		    String[] cols = parseRecordString( strRec );
 		    if ( cols == null ){
 		    	continue;
 		    }
 		    // conversion to ArrayList is needed for backward compatibility as
 		    // signature of readRow() requires an ArrayList instead of a String[]
 		    // that signature can't be changed now as old code will break due to that.		    
 		    ArrayList columns = new ArrayList( Arrays.asList( cols ) ); 
 		   
 		    Record record = readRow( columns );
 		    if ( record == null ) {
 		    	continue;
 		    }
 	        // doesn't add null or errored records to the list of records to return.	    
 	        if ( !record.isErrored() ) {
 	           records.add( record );
 	        }
 	        else {
 	           log.error( "Invalid record : " + record );
 	           super.addToErrorChannel( record );
 	        }		    
          }
       }
       catch ( IOException ioe ) {
          log.error( "Error while reading a line from the file" );
          throw new ProcessingException(
             "Error while reading a line from the file", ioe );            
       }
       return records;
     }
 
 	/***
 	 * Hook provided for subclasses to change the way a record is read from a file.
 	 * Default behaviour is to treat each line as a record and read that line.
 	 * But, for some cases, multiple lines can form one record, this method should
 	 * then be overriden by the subclass and appropriate logic should be provided.
 	 * 
 	 * @return
 	 * @throws IOException
 	 */
 	protected String readRecordString() throws IOException {
 	   return getFileReader().readLine();
 	}
 	
 	/***
 	 * Hook provided for subclasses to control the way given string is parsed to
 	 * extract columns. Default behaviour is to split the string around a delimiter
 	 * configured or returned by the getDelimiter() method of the subclass. But, this
 	 * may not suit some classes that have different requirement to extract columns
 	 * from a given record string. An example for this could be support for comments
 	 * in the input file. Thus, a subclass can override this method and return null
 	 * if 'record' string is starting with a comment character ( say, '#' ).  
 	 * 
 	 * @param record
 	 * @return parsed record string 
 	 */
 	protected String[] parseRecordString( String record ){
 	   return StringUtils.parseString( record, getDelimiter() );
 	}
 	
 	/***
 	 * Returns batchSize configured through properties, if batch size needs to provided
 	 * by other means, then this method should be overridden.
 	 * 
 	 * @return Returns the batchSize.
 	 */
 	protected int getBatchSize() {
 		return batchSize;
 	}
 
 	/***
 	 * Returns delimiter configured through properties, if delimiter needs to provided
 	 * by other means, then this method should be overridden.
 	 * 
 	 * @return Returns the delimiter.
 	 */
 	protected String getDelimiter() {
 		return delim;
 	}
 
 	/***
 	 * Details of how to obtain a reader to read records are left to the 
 	 * concrete classes to provide flexibility. This reader is used in 
 	 * loadBatch() to read record strings.
 	 * 
 	 * @return Returns the fileReader.
 	 */
 	protected abstract BufferedReader getFileReader();		
 
 	/***
 	* Extract the attributes from the ArrayList and return a Record object.
 	* When overriding this method, create the appropriate Record type for
 	* the interface & return it through the generic Record interface.
 	*
 	* @param ArrayList
 	* @exception SQLException
 	*
 	* @return Record
 	*
 	* @since 1.0
 	*/
 	protected abstract Record readRow(ArrayList al) throws ProcessingException;
 
 	/***
 	 * Convenience method to avoid code duplication in sub-classes. Probably every
 	 * subclass will have to write its own close reader operation, so this should
 	 * serve that need and keep it one place. Can be moved to a common file utils
 	 * kind of class when we have one.
 	 *  
 	 * Closes the reader instance if one exists. Made protected so 
 	 * that subclasses can reuse this code.
 	 */
 	public static void closeReader( Reader reader ) {
 	  try {
 	  	 if (reader != null) {
 		    reader.close();
 		 }
 	  }
 	  catch (IOException exIO) {
 	  	 log.error( "Error while closing the file stream.", exIO );
 	  }
 	}
 
    /***
 	* Initializes file delimiter property. 
 	* @param props
 	* @throws InitializationException
 	*/
 	private void initDelimiter(Properties props) throws InitializationException {
 	  delim = props.getProperty(DELIMITER, "N/A");
       if (delim.equals("N/A")) {
          throw new InitializationException(
             "FlatFileInputAdapter initialization error. "
                + DELIMITER
                + " Delimiter Pattern not found.");
       }
    }
 
    /***
 	* Initializes batch size.
 	* @param props
 	* @throws InitializationException
 	*/
 	private void initBatchSize(Properties props) throws InitializationException {
 	  String strTempBatchSize = props.getProperty( BATCH_SIZE, "N/A" );
 	
 	  if (strTempBatchSize.equals("N/A")) {
 	     strTempBatchSize = "0";
 	  }
 	  try {
 	     batchSize = Integer.parseInt( strTempBatchSize );
 	  }
 	  catch (NumberFormatException exNumberFormat) {
 	     log.error(
 	        "Batch size value is not proper. Batch size read is "
 	           + strTempBatchSize );
 	     throw new InitializationException(
 	        "Batch size value is not proper. Batch size :"
 	           + strTempBatchSize,
 	        exNumberFormat);
 	  }
 	}
 
 }