--- parser3/src/include/pa_hash.h 2003/03/20 09:41:45 1.58.2.18.2.3 +++ parser3/src/include/pa_hash.h 2005/07/27 09:18:33 1.64.2.1 @@ -1,7 +1,7 @@ /** @file Parser: hash class decl. - Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ @@ -17,11 +17,23 @@ #ifndef PA_HASH_H #define PA_HASH_H -static const char* IDENT_HASH_H="$Date: 2003/03/20 09:41:45 $"; +static const char * const IDENT_HASH_H="$Date: 2005/07/27 09:18:33 $"; #include "pa_memory.h" #include "pa_types.h" +const int HASH_ALLOCATES_COUNT=29; + +/** Zend comment: Generated on an Octa-ALPHA 300MHz CPU & 2.5GB RAM monster + + paf: HPUX ld could not handle static member: unsatisfied symbols +*/ +static uint Hash_allocates[HASH_ALLOCATES_COUNT]={ + 5, 11, 19, 53, 107, 223, 463, 983, 1979, 3907, 7963, + 16229, 32531, 65407, 130987, 262237, 524521, 1048793, + 2097397, 4194103, 8388857, 16777447, 33554201, 67108961, + 134217487, 268435697, 536870683, 1073741621, 2147483399}; + /** Simple hash. @@ -37,10 +49,10 @@ public: typedef V value_type; Hash() { - allocated=allocates[allocates_index=0]; + allocated=Hash_allocates[allocates_index=0]; threshold=allocated*THRESHOLD_PERCENT/100; fpairs_count=fused_refs=0; - refs=new(0) Pair*[allocated]; + refs=new(UseGC) Pair*[allocated]; } Hash(const Hash& source) { @@ -49,7 +61,7 @@ public: threshold=source.threshold; fused_refs=source.fused_refs; fpairs_count=source.fpairs_count; - refs=new(0) Pair*[allocated]; + refs=new(UseGC) Pair*[allocated]; // clone & rehash Pair **old_ref=source.refs; @@ -63,10 +75,6 @@ public: pair=next; } } - ~Hash() { - destroy_pairs(); - delete refs; - } /// put a [value] under the [key] @returns existed or not bool put(K key, V value) { @@ -95,6 +103,66 @@ public: return false; } + /// put a [value] under the [key] @returns existed or not + template R maybe_put(K key, V value, F prevent) { + assert(value); + + if(is_full()) + expand(); + + uint code=hash_code(key); + uint index=code%allocated; + Pair **ref=&refs[index]; + for(Pair *pair=*ref; pair; pair=pair->link) + if(pair->code==code && pair->key==key) { + // found a pair with the same key + + // prevent-function intercepted put? + if(R result=prevent(pair->value)) + return result; + + pair->value=value; + return reinterpret_cast(1); + } + + // proper pair not found -- create&link_in new pair + if(!*ref) // root cell were fused_refs? + fused_refs++; // not, we'll use it and record the fact + *ref=new Pair(code, key, value, *ref); + fpairs_count++; + return 0; + } + + /// put a [value] under the [key] @returns existed or not + template R maybe_append(K key, V value, F prevent, I info) { + assert(value); + + if(is_full()) + expand(); + + uint code=hash_code(key); + uint index=code%allocated; + Pair **ref=&refs[index]; + for(Pair *pair=*ref; pair; pair=pair->link) + if(pair->code==code && pair->key==key) { + // found a pair with the same key + pair->value=value; + return reinterpret_cast(1); + } + + // proper pair not found + // prevent-function intercepted put? + if(R result=prevent(value, info)) + return result; + + //create&link_in new pair + if(!*ref) // root cell were fused_refs? + fused_refs++; // not, we'll use it and record the fact + *ref=new Pair(code, key, value, *ref); + fpairs_count++; + return 0; + } + /// remove the [key] @returns existed or not bool remove(K key) { uint code=hash_code(key); @@ -124,7 +192,7 @@ public: } /// put a [value] under the [key] if that [key] existed @returns existed or not - bool put_replace(K key, V value) { + bool put_replaced(K key, V value) { if(!value) { remove(key); return false; @@ -142,6 +210,27 @@ public: return false; } + /// put a [value] under the [key] if that [key] existed @returns existed or not + template R maybe_put_replaced(K key, V value, F prevent) { + assert(value); + + uint code=hash_code(key); + uint index=code%allocated; + for(Pair *pair=refs[index]; pair; pair=pair->link) + if(pair->code==code && pair->key==key) { + // found a pair with the same key, replacing + // prevent-function intercepted put? + if(R result=prevent(pair->value)) + return result; + + pair->value=value; + return reinterpret_cast(1); + } + + // proper pair not found + return 0; + } + /// put a [value] under the [key] if that [key] NOT existed @returns existed or not bool put_dont_replace(K key, V value) { if(!value) { @@ -188,6 +277,14 @@ public: callback(pair->key, pair->value, info); } + /// iterate over all pairs + template void for_each_ref(void callback(K, V&, I), I info) const { + Pair **ref=refs; + for(int index=0; indexlink) + callback(pair->key, pair->value, info); + } + /// iterate over all pairs until condition becomes true, return that element template V first_that(bool callback(K, V, I), I info) const { Pair **ref=refs; @@ -201,7 +298,7 @@ public: /// remove all elements void clear() { - destroy_pairs(); memset(refs, 0, sizeof(*refs)*allocated); + memset(refs, 0, sizeof(*refs)*allocated); fpairs_count=fused_refs=0; } @@ -212,14 +309,9 @@ private: THRESHOLD_PERCENT=75 }; - /// the index of [allocated] in [allocates] + /// the index of [allocated] in [Hash_allocates] int allocates_index; - /// possible [allocates]. prime numbers - static uint allocates[]; - - static int allocates_count; - /// number of allocated pairs int allocated; @@ -255,11 +347,11 @@ private: int old_allocated=allocated; Pair **old_refs=refs; - allocates_index=allocates_index+1link; - delete pair; - pair=next; - } - } + delete[] old_refs; } private: //disabled @@ -295,17 +375,14 @@ private: //disabled Hash& operator = (const Hash&) { return *this; } }; -/* Zend comment: Generated on an Octa-ALPHA 300MHz CPU & 2.5GB RAM monster */ -template -uint Hash::allocates[]={ - 5, 11, 19, 53, 107, 223, 463, 983, 1979, 3907, 7963, - 16229, 32531, 65407, 130987, 262237, 524521, 1048793, - 2097397, 4194103, 8388857, 16777447, 33554201, 67108961, - 134217487, 268435697, 536870683, 1073741621, 2147483399}; - -template -int Hash::allocates_count=sizeof(allocates)/sizeof(uint); - +/// useful generic hash function +inline void generic_hash_code(uint& result, char c) { + result=(result<<4)+c; + if(uint g=(result&0xF0000000)) { + result=result^(g>>24); + result=result^g; + } +} /// useful generic hash function inline void generic_hash_code(uint& result, const char* s) { while(char c=*s++) {