From fbc75a5372d8b28d1afabf05e2784718e5ab566a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Sundstr=C3=B6m?= Date: Fri, 5 Mar 2010 20:50:58 +0000 Subject: [PATCH] Partial clean-up git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35767 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/apps/mail/MailWindow.cpp | 1 - src/apps/mail/WIndex.cpp | 416 ++++++++++++++++++++--------------- src/apps/mail/WIndex.h | 101 +++++---- src/apps/mail/Words.cpp | 8 +- 4 files changed, 298 insertions(+), 228 deletions(-) diff --git a/src/apps/mail/MailWindow.cpp b/src/apps/mail/MailWindow.cpp index 75bed809a3..6ad64f646e 100644 --- a/src/apps/mail/MailWindow.cpp +++ b/src/apps/mail/MailWindow.cpp @@ -83,7 +83,6 @@ All rights reserved. #include "Status.h" #include "String.h" #include "Utilities.h" -#include "Words.h" #define TR_CONTEXT "Mail" diff --git a/src/apps/mail/WIndex.cpp b/src/apps/mail/WIndex.cpp index 0af3836c22..40142227b9 100644 --- a/src/apps/mail/WIndex.cpp +++ b/src/apps/mail/WIndex.cpp @@ -32,69 +32,78 @@ names are registered trademarks or trademarks of their respective holders. All rights reserved. */ -#include -#include -#include + +#include "WIndex.h" + #include -#include #include #include -#include "WIndex.h" +#include + +#include +#include +#include + #define IVERSION 1 + static int32 kCRCTable = 0; -int32 cmp_i_entries( const WIndexEntry *e1, const WIndexEntry *e2 ); + +int32 cmp_i_entries(const WIndexEntry *e1, const WIndexEntry *e2); void gen_crc_table(); -unsigned long update_crc( unsigned long crc_accum, const char *data_blk_ptr, int data_blk_size ); +unsigned long update_crc(unsigned long crc_accum, const char *data_blk_ptr, + int data_blk_size); -FileEntry::FileEntry( void ) +FileEntry::FileEntry(void) { } -FileEntry::FileEntry( const char *entryStr ) - : BString( entryStr ) + +FileEntry::FileEntry(const char *entryString) + : + BString(entryString) { } -status_t WIndex::SetTo( const char *dataPath, const char *indexPath ) + +status_t +WIndex::SetTo(const char *dataPath, const char *indexPath) { - BFile *dataFile; - BFile indexFile; + BFile* dataFile; + BFile indexFile; dataFile = new BFile(); - - if( dataFile->SetTo( dataPath, B_READ_ONLY ) != B_OK ) + + if (dataFile->SetTo(dataPath, B_READ_ONLY) != B_OK) { return B_ERROR; - else - { + } else { bool buildIndex = true; - SetTo( dataFile ); + SetTo(dataFile); time_t mtime; time_t modified; - dataFile->GetModificationTime( &mtime ); + dataFile->GetModificationTime(&mtime); - if( indexFile.SetTo( indexPath, B_READ_ONLY ) == B_OK ) - { + if (indexFile.SetTo(indexPath, B_READ_ONLY) == B_OK) { attr_info info; - if( (indexFile.GetAttrInfo( "WINDEX:version", &info ) == B_NO_ERROR) ) - { + if ((indexFile.GetAttrInfo("WINDEX:version", &info) == B_OK)) { uint32 version = 0; - indexFile.ReadAttr( "WINDEX:version", B_UINT32_TYPE, 0, &version, 4 ); - if( IVERSION == version ) - { - if( (indexFile.GetAttrInfo( "WINDEX:modified", &info ) == B_NO_ERROR) ) - { - indexFile.ReadAttr( "WINDEX:modified", B_UINT32_TYPE, 0, &modified, 4 ); - if( mtime == modified ) - { - if (UnflattenIndex( &indexFile ) == B_OK) + indexFile.ReadAttr("WINDEX:version", B_UINT32_TYPE, 0, + &version, 4); + if (IVERSION == version) { + if ((indexFile.GetAttrInfo("WINDEX:modified", &info) + == B_OK)) { + indexFile.ReadAttr("WINDEX:modified", B_UINT32_TYPE, 0, + &modified, 4); + + if (mtime == modified) { + if (UnflattenIndex(&indexFile) == B_OK) buildIndex = false; } } @@ -102,169 +111,189 @@ status_t WIndex::SetTo( const char *dataPath, const char *indexPath ) } indexFile.Unset(); } - if( buildIndex ) - { - // printf( "Building Index...\n" ); + if (buildIndex) { InitIndex(); BuildIndex(); - if( indexFile.SetTo( indexPath, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE ) == B_OK ) - { - FlattenIndex( &indexFile ); - indexFile.WriteAttr( "WINDEX:modified", B_UINT32_TYPE, 0, &mtime, 4 ); + if (indexFile.SetTo(indexPath, + B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE) == B_OK) { + FlattenIndex(&indexFile); + indexFile.WriteAttr("WINDEX:modified", B_UINT32_TYPE, 0, + &mtime, 4); uint32 version = IVERSION; - indexFile.WriteAttr( "WINDEX:version", B_UINT32_TYPE, 0, &version, 4 ); + indexFile.WriteAttr("WINDEX:version", B_UINT32_TYPE, 0, + &version, 4); } } } return B_OK; } -FileEntry::~FileEntry( void ) + +FileEntry::~FileEntry(void) { - + } -WIndex::WIndex( int32 count ) + +WIndex::WIndex(int32 count) { - entryList = NULL; - dataFile = NULL; - ePerB = count; - entrySize = sizeof( WIndexEntry ); - if( !atomic_or( &kCRCTable, 1 ) ) + fEntryList = NULL; + fDataFile = NULL; + fEntriesPerBlock = count; + fEntrySize = sizeof(WIndexEntry); + if (!atomic_or(&kCRCTable, 1)) gen_crc_table(); } -WIndex::WIndex( BPositionIO *dataFile, int32 count ) + +WIndex::WIndex(BPositionIO *dataFile, int32 count) { - entryList = NULL; - this->dataFile = dataFile; - ePerB = count; - entrySize = sizeof( WIndexEntry ); - if( !atomic_or( &kCRCTable, 1 ) ) + fEntryList = NULL; + fDataFile = dataFile; + fEntriesPerBlock = count; + fEntrySize = sizeof(WIndexEntry); + if (!atomic_or(&kCRCTable, 1)) gen_crc_table(); } -WIndex::~WIndex( void ) + +WIndex::~WIndex(void) { - if( entryList ) - free( entryList ); - delete dataFile; + if (fEntryList) + free(fEntryList); + delete fDataFile; } -status_t WIndex::UnflattenIndex( BPositionIO *io ) + +status_t +WIndex::UnflattenIndex(BPositionIO *io) { - if( entryList ) - free( entryList ); + if (fEntryList) + free(fEntryList); WIndexHead head; - io->Seek( 0, SEEK_SET ); - io->Read( &head, sizeof( head ) ); - io->Seek( head.offset, SEEK_SET ); + io->Seek(0, SEEK_SET); + io->Read(&head, sizeof(head)); + io->Seek(head.offset, SEEK_SET); - entrySize = head.entrySize; - entries = head.entries; - maxEntries = ePerB; - blockSize = ePerB * entrySize; - blocks = entries/ePerB+1;; - isSorted = true; + fEntrySize = head.entrySize; + fEntries = head.entries; + fMaxEntries = fEntriesPerBlock; + fBlockSize = fEntriesPerBlock * fEntrySize; + fBlocks = fEntries / fEntriesPerBlock + 1;; + fIsSorted = true; - int32 size = (head.entries+1) * head.entrySize; - if( !(entryList = (uint8 *)malloc( size )) ) + int32 size = (head.entries + 1) * head.entrySize; + if (!(fEntryList = (uint8 *)malloc(size))) return B_ERROR; - if( entries ) - io->Read( entryList, size ); + if (fEntries) + io->Read(fEntryList, size); return B_OK; } -status_t WIndex::FlattenIndex( BPositionIO *io ) + +status_t +WIndex::FlattenIndex(BPositionIO *io) { - if( entries && !isSorted ) + if (fEntries && !fIsSorted) SortItems(); WIndexHead head; - head.entries = entries; - head.entrySize = entrySize; - head.offset = sizeof( WIndexHead ); - io->Seek( 0, SEEK_SET ); - io->Write( &head, sizeof( head ) ); - if( entries ) - io->Write( entryList, head.entries * head.entrySize ); + head.entries = fEntries; + head.entrySize = fEntrySize; + head.offset = sizeof(WIndexHead); + io->Seek(0, SEEK_SET); + io->Write(&head, sizeof(head)); + if (fEntries) + io->Write(fEntryList, head.entries * head.entrySize); return B_OK; } -int32 WIndex::Lookup( int32 key ) + +int32 +WIndex::Lookup(int32 key) { - if( !entries ) + if (!fEntries) return -1; - if( !isSorted ) + if (!fIsSorted) SortItems(); // Binary Search int32 M, Lb, Ub; Lb = 0; - Ub = entries-1; - while( true ) - { - M = (Lb + Ub)/2; - if( key < ((WIndexEntry *)(entryList+(M*entrySize)))->key ) + Ub = fEntries - 1; + while (true) { + M = (Lb + Ub) / 2; + if (key < ((WIndexEntry *)(fEntryList + (M * fEntrySize)))->key) Ub = M - 1; - else if(key > ((WIndexEntry *)(entryList+(M*entrySize)))->key ) + else if (key > ((WIndexEntry *)(fEntryList + (M * fEntrySize)))->key) Lb = M + 1; else return M; - if( Lb > Ub ) - return -1; + if (Lb > Ub) + return -1; } } -status_t WIndex::AddItem( WIndexEntry *entry ) + +status_t +WIndex::AddItem(WIndexEntry *entry) { - if( BlockCheck() == B_ERROR ) + if (_BlockCheck() == B_ERROR) return B_ERROR; - memcpy( ((WIndexEntry *)(entryList+(entries*entrySize))), entry, entrySize ); - entries++; - isSorted = false; + memcpy(((WIndexEntry *)(fEntryList + (fEntries * fEntrySize))), entry, + fEntrySize); + fEntries++; + fIsSorted = false; return B_OK; } -void WIndex::SortItems( void ) + +void +WIndex::SortItems(void) { - qsort( entryList, entries, entrySize, (int (*)(const void *, const void *))cmp_i_entries ); - isSorted = true; - //for( int32 i = 0; i < entries; i++ ) - // printf( "Key = %ld\n", entryList[i].key ); + qsort(fEntryList, fEntries, fEntrySize, + (int(*)(const void *, const void *))cmp_i_entries); + + fIsSorted = true; } -status_t WIndex::BlockCheck( void ) + +status_t +WIndex::_BlockCheck(void) { - if( entries < maxEntries ) + if (fEntries < fMaxEntries) return B_OK; - blocks = entries/ePerB+1; - entryList = (uint8 *)realloc( entryList, blockSize*blocks ); - if( !entryList ) + fBlocks = fEntries / fEntriesPerBlock + 1; + fEntryList = (uint8 *)realloc(fEntryList, fBlockSize * fBlocks); + if (!fEntryList) return B_ERROR; return B_OK; } -status_t WIndex::InitIndex( void ) + +status_t +WIndex::InitIndex(void) { - if( entryList ) - free( entryList ); - isSorted = 0; - entries = 0; - maxEntries = ePerB; - blockSize = ePerB * entrySize; - blocks = 1; - entryList = (uint8 *)malloc( blockSize ); - if( !entryList ) + if (fEntryList) + free(fEntryList); + fIsSorted = 0; + fEntries = 0; + fMaxEntries = fEntriesPerBlock; + fBlockSize = fEntriesPerBlock * fEntrySize; + fBlocks = 1; + fEntryList = (uint8 *)malloc(fBlockSize); + if (!fEntryList) return B_ERROR; return B_OK; } -int32 WIndex::GetKey( const char *s ) + +int32 +WIndex::GetKey(const char *s) { int32 key = 0; @@ -272,61 +301,70 @@ int32 WIndex::GetKey( const char *s ) int32 a = 84589; int32 b = 45989; int32 m = 217728; - while( *s ) - { + while (*s) { x = *s++ - 'a'; - key ^= (a*x + b) % m; + key ^= (a * x + b) % m; key <<= 1; }*/ - key = update_crc( 0, s, strlen(s) ); + key = update_crc(0, s, strlen(s)); - if( key < 0 ) // No negavite values! + if (key < 0) // No negative values! key = ~key; return key; } -int32 cmp_i_entries( const WIndexEntry *e1, const WIndexEntry *e2 ) + +int32 +cmp_i_entries(const WIndexEntry *e1, const WIndexEntry *e2) { return e1->key - e2->key; } -status_t WIndex::SetTo( BPositionIO *dataFile ) + +status_t +WIndex::SetTo(BPositionIO *dataFile) { - this->dataFile = dataFile; + fDataFile = dataFile; return B_OK; } -void WIndex::Unset( void ) + +void +WIndex::Unset(void) { - dataFile = NULL; + fDataFile = NULL; } -int32 WIndex::FindFirst( const char *word ) + +int32 +WIndex::FindFirst(const char *word) { - if( !entries ) + if (!fEntries) return -1; int32 index; char nword[256]; int32 key; - NormalizeWord( word, nword ); - key = GetKey( nword ); + NormalizeWord(word, nword); + key = GetKey(nword); - if( (index = Lookup( key )) < 0 ) + if ((index = Lookup(key)) < 0) return -1; // Find first instance of key - while( (ItemAt( index-1 ))->key == key ) + while ((ItemAt(index - 1))->key == key) index--; return index; } -FileEntry *WIndex::GetEntry( int32 index ) + +FileEntry* +WIndex::GetEntry(int32 index) { - if( (index >= entries)||(index < 0) ) + if ((index >= fEntries)||(index < 0)) return NULL; WIndexEntry *ientry; FileEntry *dentry; @@ -334,34 +372,40 @@ FileEntry *WIndex::GetEntry( int32 index ) dentry = new FileEntry(); - ientry = ItemAt( index ); + ientry = ItemAt(index); int32 size; - dataFile->Seek( ientry->offset, SEEK_SET ); - buffer = dentry->LockBuffer( 256 ); - dataFile->Read( buffer, 256 ); - size = GetEntrySize( ientry, buffer ); + fDataFile->Seek(ientry->offset, SEEK_SET); + buffer = dentry->LockBuffer(256); + fDataFile->Read(buffer, 256); + size = _GetEntrySize(ientry, buffer); //buffer[256] = 0; - //printf( "Entry: = %s\n", buffer ); - dentry->UnlockBuffer( size ); + //printf("Entry: = %s\n", buffer); + dentry->UnlockBuffer(size); return dentry; } -size_t WIndex::GetEntrySize( WIndexEntry *entry, const char *entryData ) + +size_t +WIndex::_GetEntrySize(WIndexEntry *entry, const char *entryData) { // eliminate unused parameter warning (void)entry; - return strcspn( entryData, "\n\r" ); + return strcspn(entryData, "\n\r"); } -FileEntry *WIndex::GetEntry( const char *word ) + +FileEntry* +WIndex::GetEntry(const char *word) { - return GetEntry( FindFirst( word ) ); + return GetEntry(FindFirst(word)); } -char *WIndex::NormalizeWord( const char *word, char *dest ) + +char* +WIndex::NormalizeWord(const char *word, char *dest) { const char *src; char *dst; @@ -369,9 +413,8 @@ char *WIndex::NormalizeWord( const char *word, char *dest ) // remove dots and copy src = word; dst = dest; - while( *src ) - { - if( *src != '.' ) + while (*src) { + if (*src != '.') *dst++ = *src; src++; } @@ -379,11 +422,12 @@ char *WIndex::NormalizeWord( const char *word, char *dest ) // convert to lower-case dst = dest; - while( *dst ) - *dst++ = tolower( *dst ); + while (*dst) + *dst++ = tolower(*dst); return dest; } + /* crc32h.c -- package to compute 32-bit CRC one byte at a time using */ /* the high-bit first (Big-Endian) bit ordering convention */ /* */ @@ -418,30 +462,48 @@ char *WIndex::NormalizeWord( const char *word, char *dest ) /* The table lookup technique was adapted from the algorithm described */ /* by Avram Perez, Byte-wise CRC Calculations, IEEE Micro 3, 40 (1983).*/ + #define POLYNOMIAL 0x04c11db7L + static unsigned long crc_table[256]; -void gen_crc_table() - /* generate the table of CRC remainders for all possible bytes */ - { register int i, j; register unsigned long crc_accum; - for ( i = 0; i < 256; i++ ) - { crc_accum = ( (unsigned long) i << 24 ); - for ( j = 0; j < 8; j++ ) - { if ( crc_accum & 0x80000000L ) - crc_accum = - ( crc_accum << 1 ) ^ POLYNOMIAL; - else - crc_accum = - ( crc_accum << 1 ); } - crc_table[i] = crc_accum; } - return; } -unsigned long update_crc( unsigned long crc_accum, const char *data_blk_ptr, int data_blk_size ) - /* update the CRC on the data block one byte at a time */ - { register int i, j; - for ( j = 0; j < data_blk_size; j++ ) - { i = ( (int) ( crc_accum >> 24) ^ *data_blk_ptr++ ) & 0xff; - crc_accum = ( crc_accum << 8 ) ^ crc_table[i]; } - return crc_accum; } - +void +gen_crc_table() +{ + // generate the table of CRC remainders for all possible bytes + + register int i, j; + register unsigned long crc_accum; + + for (i = 0; i < 256; i++) { + crc_accum = ((unsigned long) i << 24); + for (j = 0; j < 8; j++) { + if (crc_accum & 0x80000000L) + crc_accum = (crc_accum << 1) ^ POLYNOMIAL; + else + crc_accum = (crc_accum << 1); + } + crc_table[i] = crc_accum; + } + + return; +} + + +unsigned long +update_crc(unsigned long crc_accum, const char *data_blk_ptr, int data_blk_size) +{ + // update the CRC on the data block one byte at a time + + register int i, j; + + for (j = 0; j < data_blk_size; j++) { + i = ((int) (crc_accum >> 24) ^ *data_blk_ptr++) & 0xff; + crc_accum = (crc_accum << 8) ^ crc_table[i]; + } + + return crc_accum; +} + diff --git a/src/apps/mail/WIndex.h b/src/apps/mail/WIndex.h index add63f0642..0752235b95 100644 --- a/src/apps/mail/WIndex.h +++ b/src/apps/mail/WIndex.h @@ -31,77 +31,86 @@ of Be Incorporated in the United States and other countries. Other brand product names are registered trademarks or trademarks of their respective holders. All rights reserved. */ - #ifndef _WORD_INDEX_H #define _WORD_INDEX_H + #include #include + struct WIndexHead { int32 entries; int32 entrySize; int32 offset; }; + struct WIndexEntry { int32 key; int32 offset; }; + class FileEntry : public BString { public: - FileEntry(void); - FileEntry(const char *entryStr); - virtual ~FileEntry(void); + FileEntry(); + FileEntry(const char* entryStr); + virtual ~FileEntry(); }; + class WIndex { public: - WIndex(BPositionIO *dataFile, int32 count = 100); - WIndex(int32 count = 100); - virtual ~WIndex(void); - - status_t InitIndex(void); - status_t UnflattenIndex(BPositionIO *io); - status_t FlattenIndex(BPositionIO *io); - - int32 Lookup(int32 key); - - inline WIndexEntry *ItemAt(int32 index) - { return (WIndexEntry *)(entryList+(index*entrySize)); } - status_t AddItem(WIndexEntry *entry); - inline int32 CountItems(void) - { return entries; } - void SortItems(void); - - virtual int32 GetKey(const char *s); - virtual char *NormalizeWord(const char *word, char *dest); - - status_t SetTo(BPositionIO *dataFile); - status_t SetTo(const char *dataPath, const char *indexPath); - void Unset(void); - - virtual status_t BuildIndex(void) = 0; - - virtual int32 FindFirst(const char *word); - virtual FileEntry *GetEntry(int32 index); - FileEntry *GetEntry(const char *word); + WIndex(BPositionIO* dataFile, int32 count = 100); + WIndex(int32 count = 100); + virtual ~WIndex(); + + status_t InitIndex(); + status_t UnflattenIndex(BPositionIO* io); + status_t FlattenIndex(BPositionIO* io); + + int32 Lookup(int32 key); + + inline WIndexEntry* ItemAt(int32 index) { + return (WIndexEntry*) + (fEntryList + (index * fEntrySize)); + } + + status_t AddItem(WIndexEntry* entry); + inline int32 CountItems() { + return fEntries; + } + void SortItems(); + + virtual int32 GetKey(const char* s); + virtual char* NormalizeWord(const char* word, char* dest); + status_t SetTo(BPositionIO* dataFile); + status_t SetTo(const char* dataPath, const char* indexPath); + void Unset(); + + virtual status_t BuildIndex() = 0; + + virtual int32 FindFirst(const char* word); + virtual FileEntry* GetEntry(int32 index); + FileEntry* GetEntry(const char* word); + protected: - status_t BlockCheck(void); - virtual size_t GetEntrySize(WIndexEntry *entry, const char *entryData); - - int32 entrySize; - int32 entries; - int32 maxEntries; - int32 ePerB; - int32 blockSize; - int32 blocks; - bool isSorted; - uint8 *entryList; - BPositionIO *dataFile; + status_t _BlockCheck(); + virtual size_t _GetEntrySize(WIndexEntry* entry, + const char* entryData); + + int32 fEntrySize; + int32 fEntries; + int32 fMaxEntries; + int32 fEntriesPerBlock; + int32 fBlockSize; + int32 fBlocks; + bool fIsSorted; + uint8* fEntryList; + BPositionIO* fDataFile; }; -#endif // #ifndef _WORD_INDEX_H +#endif // _WORD_INDEX_H diff --git a/src/apps/mail/Words.cpp b/src/apps/mail/Words.cpp index 4050447746..1fb8f8d762 100644 --- a/src/apps/mail/Words.cpp +++ b/src/apps/mail/Words.cpp @@ -104,7 +104,7 @@ Words::Words(const char* dataPath, const char* indexPath, bool useMetaphone) fUseMetaphone(useMetaphone) { if (!useMetaphone) - entrySize = sizeof(uint32); + fEntrySize = sizeof(uint32); SetTo(dataPath, indexPath); } @@ -130,14 +130,14 @@ Words::BuildIndex(void) int32 state = FIND_WORD; // Make sure we are at start of file - dataFile->Seek(0, SEEK_SET); + fDataFile->Seek(0, SEEK_SET); entry.offset = -1; // Read blocks from thes until eof while (true) { // Get next block - blockOffset = dataFile->Position(); - if ((blockSize = dataFile->Read(buffer, 16384)) == 0) + blockOffset = fDataFile->Position(); + if ((blockSize = fDataFile->Read(buffer, 16384)) == 0) break; // parse block