/www/proggenOrg/dedupe/export/trunk/hash/hash.h

//Hash.h
//by Jochen Hebeler, 2010
//Representing a class providing a 32/64-bit fnv-1 hash

#ifndef ORG_PROGGEN_DEDUPE_HASH_HASH_H_
#define ORG_PROGGEN_DEDUPE_HASH_HASH_H_

#include <iostream>
#include <fstream>
#include <fileinfo.h>
#include <searchfiles.h>
#include <boost/filesystem/fstream.hpp>

using namespace std;



namespace Dedupe
{
        namespace Hash
        {
        //Bad workaround: long long isn't supportet by all compilers, but no problem yet?
        #define FILE_PACKET_SIZE 104857600   //We will always load 100MB of a file(or less if required)

        typedef unsigned long long uint64__;
        typedef unsigned long uint32__;

        template <typename T> class Hash
        {
        private:
                T hash; //our int for storing the hash, should be uint32 or uint64
                T offset;  //The offset base for generating the hash, look up wikipedia for it(fnv-1)
                T magic;  //The magic-number for generating hash, look also wikipedia up for it
        public:
        Hash()
        :hash ( 0 ),
         offset( (sizeof(T) > 4)?(14695981039346656037ULL):(2166136261UL) ),
         magic( (sizeof(T) > 4)?(1099511628211ULL):(16777619UL) )
        {

        }

        Hash(void *data, uint64__ length)
        :hash ( 0 ),
         offset( (sizeof(T) > 4)?(14695981039346656037ULL):(2166136261UL) ),
         magic( (sizeof(T) > 4)?(1099511628211ULL):(16777619UL) )
{
        hash = offset;
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        T *longdata = static_cast<T*>(data);
        if((length % sizeof(T)) != 0) //If the length isn't dividable by the size of the hashvar, hash the single bytes until it is easy hashable
        {
                for(; i < (length % sizeof(T)); i++)
                {
                        hash = (hash ^ *(data2++)) * magic;    //hashen
                }
        }
        longdata += (length % sizeof(T));
        for(; i < length; i+=sizeof(T))
        {
                hash = (hash ^ *(longdata++)) * magic;  //Hash the rest
        }
}

        void GenerateHash( void* data, uint64__ length )
{
        hash = offset;
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        T *longdata = static_cast<T>(data);
        if((length % sizeof(T)) != 0)
        {
                for(; i < (length % sizeof(T)); i++)
                {
                        hash = (hash ^ *data2++) * magic;
                }
        }
        longdata += (length % sizeof(T));
        for(; i < length; i += sizeof(T))
        {
                hash = (hash ^ *longdata++) * magic;
        }
}

        static T GetHash(void* data, uint64__ length, Hash &object)
{
        T nHash = object.offset;
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        T *longdata = static_cast<T*>(data);
        if((length % sizeof(T)) != 0)
        {
                for(; i < (length % sizeof(T)); i++)
                {
                        nHash = (nHash ^ *data2++) * object.magic;
                }
        }
        longdata += (length % sizeof(T));
        for(; i < length; i += sizeof(T))
        {
                nHash = (nHash ^ *longdata++) * object.magic;
        }
        return nHash;
}

        void HashFileInfo( Dedupe::FileInfo &info)
{
  boost::filesystem::ifstream *file = new boost::filesystem::ifstream();
        char *data = new char[FILE_PACKET_SIZE];
        unsigned long long int length = 0;
        file->open(info.GetPath(), ifstream::in);
        file->seekg(0, ios::end);
        length = file->tellg();
        file->seekg(0, ios::beg);

        file->read(data, (FILE_PACKET_SIZE > length)?(length):(FILE_PACKET_SIZE));
        Hash<T> hash(data, (FILE_PACKET_SIZE > length)?(length):(FILE_PACKET_SIZE));
        length -= (104857600 > length)?(length):(FILE_PACKET_SIZE);
        while(file->good() && length > 0)
        {
          file->read(data, (FILE_PACKET_SIZE > length)?(length):(FILE_PACKET_SIZE));
                hash.AddToHash(data, (FILE_PACKET_SIZE > length)?(length):(FILE_PACKET_SIZE));
                length -= FILE_PACKET_SIZE;
        }
        file->close();
        info.SetHash( hash.GetHash() );


        delete file;
        delete data;
}


        void HashMultiplyFileInfo(Dedupe::FileStream &stream)
{
        std::for_each( stream.begin(), stream.end(), HashFileInfo );
}

        void AddToHash( void* data, uint64__ length )
{
        if(hash == 0)
        {
                return;
        }
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        T *longdata = static_cast<T*>(data);
        if((length % sizeof(T)) != 0)
        {
                for(; i < (length % sizeof(T)); i++)
                {
                        hash = (hash ^ *data2++) * magic;
                }
        }
        longdata += (length % sizeof(T));
        for(; i < length; i += sizeof(T))
        {
                hash = (hash ^ *longdata++) * magic;
        }
}

        T GetHash()
        {
                return hash;
        }

        bool operator== (Hash<T> &h1 ) const
        {
                if(this->hash == h1.GetHash())
                {
                        return true;
                }
                return false;
        }

        bool operator!= (Hash<T> &h1 )
        {
                if(this->hash != h1.GetHash())
                {
                        return true;
                }
                return false;
        }

        void Display();
        };

        typedef Hash<uint64__> Hash64;
        typedef Hash<uint32__> Hash32;

        }
}

#endif