Filter Library

Camera

Interface Physics

ToolHashBuilder.h

/*
 * ToolHashBuilder.h - incrementally build a hash from fundamental types.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2005, Leiden Probe Microscopy.
 * Copyright (C) 2005, Universiteit Leiden.
 *
 * Authors: Martin J. Moene
 *
 * $Id: ToolHashBuilder.h 233 2005-06-27 08:55:41Z moene $
 */

#ifndef _CFL_TOOLHASHBUILDER_H
#define _CFL_TOOLHASHBUILDER_H

/* -----------------------------------------------------------------------
** class declarations
** -----------------------------------------------------------------------
 */

/**
 * \addtogroup cfl_dialog
 *
 * @{
 */

/**
 * incrementally build a hash value from fundamental types.
 *
 * This class can incrementally build a hash value from fundamental types.
 * It is used to determine if settings on a dialog changed or have remained as
 * they where with respect to a previously taken snapshot.
 *
 * Example.
 * \code
 * char   character = 'a';
 * int    integer   =  0;
 * char*  string    = "";
 *
 * typedef CHashBuilder::ValueType HashType;
 *
 * HashType LastHash = 0;
 *
 * HashType ComputeHash()
 * {
 *    CHashBuilder NewHash;
 *
 *    return NewHash = character, integer, string;
 * }
 *
 * bool SomethingChanged()
 * {
 *    return ComputeHash() != LastHash;
 * }
 *
 * void MyInitialize()
 * {
 *    LastHash = ComputeHash();
 * }
 *
 * void MyAction()
 * {
 *    if ( SomethingChanged() )
 *    {
 *       // act on changes and save new hash value
 *
 *       LastHash = ComputeHash();
 *    }
 *    else
 *    {
 *       ; // no action required
 *    }
 * }
 * \endcode
 *
 * Class CHashBuilder was inspired on the article "A Checksum Algorithm"
 * by Joseph M. Newcomer \ref newcomer_checksumalgorithm "[CHECKSUM]".
 *
 * Class CHashBuilder uses the hash function by P.J. Weinberger from the dragon
 * book \ref dragon_1986 "[Aho et al., 1986]".
 *
 */
class CHashBuilder
{
public:
   /**
    * this type.
    */
   typedef CHashBuilder Self;

   /**
    * unsigned character type;
    */
   typedef unsigned char uchar;

   /**
    * unsigned integer type.
    */
   typedef unsigned int  uint;

   /**
    * unsigned long integer type.
    */
   typedef unsigned long ulong;

   /**
    * the hash type.
    */
   typedef ulong ValueType;

   ///
   /// \name Construction
   /// @{

   /**
    * default constructor.
    */
   inline CHashBuilder() : m_hash( 0 )
   {
      ; // do nothing
   }

   /**
    * construct from a character.
    */
   inline CHashBuilder( char c ) : m_hash( 0 )
   {
      (void) Add( c );
   }

   /**
    * construct from an integer.
    */
   inline CHashBuilder( int i ) : m_hash( 0 )
   {
      (void) Add( i );
   }

   /**
    * construct from a long integer.
    */
   inline CHashBuilder( long int i ) : m_hash( 0 )
   {
      (void) Add( i );
   }

   /**
    * construct from an unsigned character.
    */
   inline CHashBuilder( unsigned char c ) : m_hash( 0 )
   {
      (void) Add( c );
   }

   /**
    * construct from  an unsigned integer.
    */
   inline CHashBuilder( uint i ) : m_hash( 0 )
   {
      (void) Add( i );
   }

   /**
    * construct from  an unsigned long integer.
    */
   inline CHashBuilder( ulong i ) : m_hash( 0 )
   {
      (void) Add( i );
   }

   /**
    * construct from a float.
    */
   inline CHashBuilder( float f ) : m_hash( 0 )
   {
      (void) Add( f );
   }

   /**
    * construct from a double.
    */
   inline CHashBuilder( double d ) : m_hash( 0 )
   {
      (void) Add( d );
   }

   /**
    * construct from  a C-string.
    */
   inline CHashBuilder( const char* s ) : m_hash( 0 )
   {
      (void) Add( s );
   }

   /// @}
   /// \name Operators
   /// @{

   /**
    * assign a character.
    */
   inline Self& operator= ( char c )
   {
      Clear();
      return Add( c );
   }

   /**
    * assign an integer.
    */
   inline Self& operator= ( int i )
   {
      Clear();
      return Add( i );
   }

   /**
    * assign a long integer.
    */
   inline Self& operator= ( long int i )
   {
      Clear();
      return Add( i );
   }

   /**
    * assign an unsigned character.
    */
   inline Self& operator= ( unsigned char c )
   {
      Clear();
      return Add( c );
   }

   /**
    * assign an unsigned integer.
    */
   inline Self& operator= ( uint i )
   {
      Clear();
      return Add( i );
   }

   /**
    * assign an unsigned long integer.
    */
   inline Self& operator= ( ulong i )
   {
      Clear();
      return Add( i );
   }

   /**
    * assign a float.
    */
   inline Self& operator= ( float f )
   {
      Clear();
      return Add( f );
   }

   /**
    * assign a double.
    */
   inline Self& operator= ( double d )
   {
      Clear();
      return Add( d );
   }

   /**
    * assign a C-string.
    */
   inline Self& operator= ( const char* s )
   {
      Clear();
      return Add( s );
   }

   /**
    * add a character.
    */
   inline Self& operator, ( char chr )
   {
      return Add( chr );
   }

   /**
    * add a unsigned character.
    */
   inline Self& operator, ( uchar chr )
   {
      return Add( chr );
   }

   /**
    * add an integer.
    */
   inline Self& operator, ( int i )
   {
      return Add( i );
   }

   /**
    * add an unsigned integer.
    */
   inline Self& operator, ( uint i )
   {
      return Add( i );
   }

   /**
    * add a long integer.
    */
   inline Self& operator, ( long i )
   {
      return Add( i );
   }

   /**
    * add an unsigned long integer.
    */
   inline Self& operator, ( ulong i )
   {
      return Add( i );
   }

   /**
    * add a float.
    */
   inline Self& operator, ( float f )
   {
      return Add( f );
   }

   /**
    * add a double.
    */
   inline Self& operator, ( double d )
   {
      return Add( d );
   }

   /**
    * add a C-string.
    */
   inline Self& operator, ( const char* s )
   {
      return Add( s );
   }

   /**
    * convert to ValueType, return hash value; alias for GetHash().
    */
   inline operator ValueType () const
   {
      return GetHash();
   }


   /// @}
   /// \name Accessors
   /// @{

   /**
    * the current hash value.
    */
   inline ValueType GetHash() const
   {
      return m_hash;
   }

   /// @}
   /// \name Mutators
   /// @{

   /**
    * clear the hash value.
    */
   inline void Clear()
   {
      m_hash = 0;
   }

   /**
    * \brief add an unsigned character to the hash (P.J. Weinberger's hash, hash_pjw).
    */
   inline Self& Add( unsigned char chr )
   {
      m_hash = ( m_hash << 4 ) + ( chr * 13 );

      ValueType g = m_hash & 0xf0000000;

      if ( g )
      {
         m_hash ^= ( g >> 24 );
         m_hash ^=   g;
      }

      return *this;
   }

   /**
    * add a character to the hash.
    */
   inline Self& Add( char chr )
   {
      return Add( uchar( chr ) );
   }

   /**
    * add an integer to the hash.
    */
   inline Self& Add( int i )
   {
      return Add( uint( i ) );
   }

   /**
    * add an unsigned integer to the hash.
    */
   inline Self& Add( uint i )
   {
      return Add( uchar( i / 256 ) ).Add( uchar( i % 256 ) );
   }

   /**
    * add a long to the hash.
    */
   inline Self& Add( long i )
   {
      return Add( ulong( i ) );
   }

   /**
    * add an unsigned long to the hash.
    */
   inline Self& Add( ulong i )
   {
      return Add( uint( i / 65536L ) ).Add( uint( i % 65536L ) );
   }

   /**
    * add a float to the hash.
    */
   inline Self& Add( float f )
   {
      uchar* begin = (uchar*) &f;

      for ( uchar* p = begin; p < begin + sizeof( float ); ++p )
      {
         Add( *p );
      }

      return *this;
   }

   /**
    * add a float to the hash.
    */
   inline Self& Add( double d )
   {
      uchar* begin = (uchar*) &d;

      for ( uchar* p = begin; p < begin + sizeof( double ); ++p )
      {
         Add( *p );
      }

      return *this;
   }

   /**
    * add a C-string to the hash.
    */
   inline Self& Add( const char* string )
   {
      for ( ; *string; ++string )
      {
         (void) Add( *string );
      }

      return *this;
   }

   /// @}

private:
   /*
    * current hash value.
    */
   ValueType m_hash;
};

/// @} cfl_toolhashbuilder

#endif // _CFL_TOOLHASHBUILDER_H

/*
 * end of file
 */

---