How to check if file contents read matches what was written

[John Vorwald]

I would like to check if the data read from a file is the same as what was written.
Does the following example which calculating, saves, reads, recalculates, and compares the hash code accomplish the goal of making sure the data read matches the data written?
Is there a simpler solution?

  package mooseSaloon;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Vector;
import java.util.logging.ConsoleHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* Collected methods which allow easy implementation of <tt>hashCode</tt>.
*
* Example use case:
* <pre>
*  public int hashCode(){
*    final int result = HashCodeUtil.SEED;
*    //collect the contributions of various fields
*    result = HashCodeUtil.hash(result, fPrimitive);
*    result = HashCodeUtil.hash(result, fObject);
*    result = HashCodeUtil.hash(result, fArray);
*    return result;
*  }
* </pre>
*/
class HashCodeUtil { 

  /**
  * An initial value for a <tt>hashCode</tt>, to which is added contributions
  * from fields. Using a non-zero value decreases collisons of <tt>hashCode</tt>
  * values.
  */
  public static final int SEED = 23;
  
  
  /**
  * ints.
  */
  public static int hash( int aSeed , int aInt ) {
    return firstTerm( aSeed ) + aInt;
  }
    
  /** Possibly-null Object fields.  */
  public static int hash( int aSeed , Object aObject ) {
    return hash( aSeed, (aObject == null ? 0 : aObject.hashCode()) );
  }
  
  /** Arrays of Objects.  */
  public static int hash( int aSeed , Object[] aArray ) {
    int result = aSeed;
    for ( int idx = 0; idx < aArray.length; ++idx ) {
      result = hash( result, aArray[idx] );
    }
    return result ;
  }
    
  // PRIVATE //
  private static final int fODD_PRIME_NUMBER = 37;
  
  private static int firstTerm( int aSeed ){
    return fODD_PRIME_NUMBER * aSeed;
  }
}


public final class AllHashCheck
{
    public AllHashCheck( )
    {
        super();
        this.fDate = null;
        this.fMyData = new ArrayList<MyDataObjects>();
    }

    private static final String fFileName = "hashCodeCheck.bin";

    private final static Logger fLogger = Logger.getLogger( AllHashCheck.class.getPackage().getName() );

    private static final String binaryFileVersion()
    {
        return "0.10";
    }

    public static void main( final String[] args )
        throws IOException, ClassNotFoundException
    {
        
        fLogger.setLevel( Level.FINEST );

        Logger root = Logger.getLogger("");
        Handler []handlers = root.getHandlers();  

        for (int i = 0; i < handlers.length; i++) {
           if (handlers[i] instanceof ConsoleHandler) {
              ((ConsoleHandler)handlers[i])
              .setLevel(Level.ALL);
              fLogger.info("Hanler " + handlers[i].toString()
                    + " Level is: " + handlers[i].getLevel());
           }
        }

        final AllHashCheck h = new AllHashCheck();
        final MyDataObjects o1 = new MyDataObjects( 1, "abc" );
        final MyDataObjects o2 = new MyDataObjects( 37, "Hello" );
        h.add( o1 );
        h.add( o2 );
        h.writeBinaryFile();
        AllHashCheck h2 = new AllHashCheck();
        h2.readBinaryFile();
    }

    private Date fDate;

    List<MyDataObjects> fMyData;

    /**
     * Add a data object
     * 
     * @since 0.10
     * @version 0.10 Sep 27, 2010
     */
    private void add( final MyDataObjects aO )
    {
        this.fMyData.add( aO );
    }

    /**
     * Determine the hash code
     * 
     * @since 0.10
     * @version 0.10 Sep 27, 2010
     */
    @Override
    public int hashCode()
    {

        int result = HashCodeUtil.SEED;
        result = HashCodeUtil.hash( result, this.fDate );
        result = HashCodeUtil.hash( result, AllHashCheck.fLogger );
        return result;
    }

    /**
     * Read data from a binary file.
     * 
     * @throws IOException
     * @throws ClassNotFoundException
     */
    private void readBinaryFile()
        throws IOException, ClassNotFoundException
    {
        /*
         * Strategy: 1. Open buffered output stream 2. Write data to stream
         */

        FileInputStream istream = null;
        final File tempFile = new File( AllHashCheck.fFileName );
        if ( tempFile.exists() )
        {
            try
            {
                istream = new FileInputStream( tempFile );
            }
            catch ( final FileNotFoundException ex )
            {
            }

        }
        else
        {
            // File does not exist
            final String newline = System.getProperty( "line.separator" );
            AllHashCheck.fLogger.log( Level.WARNING, "Unable to open file " + tempFile.getName() + newline
                + "   relative path: " + tempFile.getPath() + newline + "   absolute path: "
                + tempFile.getAbsolutePath() );
            return;

        }
        final BufferedInputStream bis = new BufferedInputStream( istream );
        final ObjectInputStream isObject = new ObjectInputStream( bis );

        String versionCheck = new String();
        versionCheck = "HashCodeCheck Binary File Version: " + AllHashCheck.binaryFileVersion();
        try
        {
            // Read the version
            final String version = (String) isObject.readObject();
            if ( !versionCheck.equals( version ) )
            {
                final IOException ioe = new IOException( "Version doesn't match" );
                final String parseErr =
                    "Reading binary file " + AllHashCheck.fFileName + ", version \"" + versionCheck
                        + "\" doesn't match";
                AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, ioe );
                throw ioe;
            }
            // Read the date written
            this.fDate = (Date) isObject.readObject();
            // Read the hash code
            final int fileHash = isObject.readInt();
            // Read the number of data objects
            final Integer nObjects = (Integer) isObject.readObject();
            this.fMyData = new Vector<MyDataObjects>( nObjects );
            // Read the objects
            for ( int iObject = 0; iObject < nObjects; iObject++ )
            {
                final MyDataObjects temp = new MyDataObjects();
                temp.readBinaryFile( isObject );
                this.fMyData.add( temp );
            }

            istream.close();
            // Check the hash code
            final int calculatedHash = this.hashCode();
            if ( fileHash != calculatedHash )
            {
                final IOException ioe = new IOException( "Calculated and read hash codes do not match" );
                final String parseErr =
                    "Read hash value" + fileHash + " and calculated value " + calculatedHash + " doen't match";
                AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, ioe );
                throw ioe;
            } else {
               fLogger.info( "Hash code read from file: " + fileHash + ", calculated: " + calculatedHash  );   
            }
        }
        catch ( final EOFException e) {
            final String parseErr = "Reached end of file on " + AllHashCheck.fFileName;
            AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, e );
            throw e;
        }
        catch ( final IOException e )
        {
            final String parseErr =
                "Reading binary file " + AllHashCheck.fFileName + ", version \"" + versionCheck + "\"";
            AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, e );
            throw e;
        }
        catch ( final ClassNotFoundException e )
        {
            final String parseErr = "Can't open binary file " + AllHashCheck.fFileName;
            AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, e );
            throw e;
        }
    }

    /**
     * Write data to a binary file.
     * 
     * @since 0.10
     * @version 0.10 Sep 25, 2010
     * @throws Exception
     */
    protected void writeBinaryFile()
        throws IOException
    {

        /*
         * Strategy: 1. Open buffered output stream 2. Write each fund in the portfolio to a file
         */

        final FileOutputStream ostream = new FileOutputStream( AllHashCheck.fFileName );
        final BufferedOutputStream bos = new BufferedOutputStream( ostream );
        final ObjectOutputStream osObject = new ObjectOutputStream( bos );

        String version = new String();
        version = "HashCodeCheck Binary File Version: " + AllHashCheck.binaryFileVersion();
        try
        {
            this.fDate = new Date();
            // Write out the version
            osObject.writeObject( version );
            // Write the last dates in the file
            osObject.writeObject( this.fDate );
            // Write the hash of the data (for checking data when read)
            final int iHash = this.hashCode();
            osObject.writeInt( iHash );
            // Write the number of funds
            final Integer nFunds = this.fMyData.size();
            osObject.writeObject( nFunds );
            // Write out the funds
            for ( final MyDataObjects tspStock : this.fMyData )
            {
                tspStock.writeBinary( osObject );
            }
            osObject.flush();
            ostream.close();
        }
        catch ( final IOException e )
        {

            final String parseErr = "Writing binary file " + AllHashCheck.fFileName + ", version \"" + version + "\"";
            AllHashCheck.fLogger.throwing( this.getClass().getName(), parseErr, e );
            throw e;
        }
    }

}

class MyDataObjects
{
    int fValue;
    String fString;
    public MyDataObjects( int aAValue, String aAString )
    {
        super();
        this.fValue = aAValue;
        this.fString = aAString;
    }
    public MyDataObjects()
    {
        fValue = -1;
        fString = null;
    }
    @Override public int hashCode() {
        
        int result = HashCodeUtil.SEED;
        result = HashCodeUtil.hash( result, this.fValue );
        result = HashCodeUtil.hash( result, this.fString );
        return result;
    }
    
    /**
     * Binary file version
     *
     * @since 0.10
     * @version 0.10  Sep 25, 2010
     */
    private final static String binaryFileVersion() {
        return "0.20";
    }

    /**
     * Read data from a binary file.
     *
     * @since 0.10
     * @version 0.10  Sep 25, 2010
     * @throws ClassNotFoundException 
     * @throws IOException 
     */
    public void readBinaryFile( ObjectInputStream aIsObject ) throws ClassNotFoundException, IOException {
        String fileCheck = ( String ) aIsObject.readObject();
        fString = ( String ) aIsObject.readObject();
        fValue = aIsObject.readInt();
        if (!fileCheck.equals( binaryFileVersion() )) {
            final IOException ioe = new IOException( "Version doesn't match" );
            throw ioe;
        }
    }

    /**
     * Write data to a binary file.
     *
     * @since 0.10
     * @version 0.10  Sep 25, 2010
     * @throws IOException 
     */
    public void writeBinary(ObjectOutputStream osObject) throws IOException {
        osObject.writeObject( binaryFileVersion() );
        osObject.writeObject( fString );
        osObject.writeInt(fValue);
    }
}

  

[David Newton]

That's actually pretty tough to read.

And what's up with your naming conventions? Does an "f" in front of a name mean something or not? If so, what on earth does it mean? What's the "a" prefix, in things like "aAValue"? What's with the comments of "Read data from a binary file" on a method named "readBinaryFile"? And naming an ObjectInputStream aIsObject? It's all quite distracting.

So, my two questions would be these: (a) does it do what you want, and (b) how could it be simpler than writing, reading, and comparing?

[Rob Spoor]

David Newton wrote:And what's up with your naming conventions? Does an "f" in front of a name mean something or not? If so, what on earth does it mean? What's the "a" prefix, in things like "aAValue"?

That's how some people name their variables: f for fields, a for arguments, nothing for local variables. I find it highly distracting too.

[David Newton]

Rob Prime wrote:That's how some people name their variables: f for fields, a for arguments, nothing for local variables. I find it highly distracting too.

It's not very consistent in the code above, which is one reason I asked.