/www/proggenOrg/dedupe/export/trunk/hash/hash64.cpp

//Hash.cpp
//by Jochen Hebeler, 2010

#include "hash.h"

using namespace std;
using namespace Dedupe::Hash;

Hash64::Hash64(void)
{
        hash = 0;
}

Hash64::Hash64(void *data, uint64__ length)
{
        hash = OFFSET_BASIS64;
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        uint64__ *longdata = static_cast<uint64__*>(data);
        if((length % sizeof(uint64__)) != 0)
        {
                for(; i < (length % sizeof(uint64__)); i++)
                {
                        hash = (hash ^ *data2++) * MAGIC64;
                }
        }
        longdata += (length % sizeof(uint64__));
        for(; i < length; i += sizeof(uint64__))
        {
                hash = (hash ^ *longdata++) * MAGIC64;
        }
}

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

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

void Hash64::Display()
{
        if(this->hash == 0)
        {
                cout << "Empty Hash" << endl;
                return;
        }
        cout << "Hash: " << hex << hash << endl;
}

uint64__ Hash64::GetHash(void* data, uint64__ length)
{
        uint64__ nHash = OFFSET_BASIS64;
        uint64__ i = 0;
        char *data2 = static_cast<char*>(data);
        uint64__ *longdata = static_cast<uint64__*>(data);
        if((length % sizeof(uint64__)) != 0)
        {
                for(; i < (length % sizeof(uint64__)); i++)
                {
                        nHash = (nHash ^ *data2++) * MAGIC64;
                }
        }
        longdata += (length % sizeof(uint64__));
        for(; i < length; i += sizeof(uint64__))
        {
                nHash = (nHash ^ *longdata++) * MAGIC64;
        }
        return nHash;
}

void Hash64::HashMultiplyFileInfo(Dedupe::FileStream &stream)
{
        Dedupe::FileStream::iterator it;
        ifstream *file = new ifstream();
        char *data = new char[104857600];
        unsigned long long int length = 0;
        for(it = stream.begin(); it < stream.end(); it++)
        {
                file->open(it->GetPath().c_str(), ifstream::in);
                file->seekg(0, ios::end);
                length = file->tellg();
                file->seekg(0, ios::beg);

                file->read(data, (104857600 > length)?(length):(104857600));
                Hash32 hash(data, (104857600 > length)?(length):(104857600));
                length -= (104857600 > length)?(length):(104857600);
                while(file->good() && length > 0)
                {
                        file->read(data, (104857600 > length)?(length):(104857600));
                        hash.AddToHash(data, (104857600 > length)?(length):(104857600));
                        length -= 104857600;
                }
                file->close();
                it->SetHash( hash.GetHash() );
        }
        delete file;
        delete data;
}