[BACK]Return to pa_hash.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/Attic/pa_hash.C between versions 1.18 and 1.36

version 1.18, 2001/03/07 11:14:12 version 1.36, 2001/06/28 07:41:59
Line 1 Line 1
 /*  /** @file
   $Id$          Parser: hash class.
   
           Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
   
           Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
   
           $Id$
 */  */
   static char *RCSId="$Id$"; 
   
 /*  /*
         The prime numbers used from zend_hash.c,          The prime numbers used from zend_hash.c,
Line 11 Line 18
 */  */
   
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_threads.h"  
   
 void *Hash::Pair::operator new(size_t size, Pool& apool) {  void *Hash::Pair::operator new(size_t size, Pool& apool) {
         return apool.malloc(size);          return apool.malloc(size);
Line 27  int Hash::allocates_count= Line 33  int Hash::allocates_count=
         sizeof(allocates)/sizeof(uint);          sizeof(allocates)/sizeof(uint);
   
   
 void Hash::construct(Pool& apool, bool athread_safe) {  void Hash::construct(Pool& apool) {
         thread_safe=athread_safe;  
           
         allocated=allocates[allocates_index=0];          allocated=allocates[allocates_index=0];
         threshold=allocated*THRESHOLD_PERCENT/100;          threshold=allocated*THRESHOLD_PERCENT/100;
         used=0;          used=0;
Line 43  void Hash::expand() { Line 47  void Hash::expand() {
         // allocated bigger refs array          // allocated bigger refs array
         allocates_index=allocates_index+1<allocates_count?allocates_index+1:allocates_count-1;          allocates_index=allocates_index+1<allocates_count?allocates_index+1:allocates_count-1;
         allocated=allocates[allocates_index];          allocated=allocates[allocates_index];
           threshold=allocated*THRESHOLD_PERCENT/100;
         refs=static_cast<Pair **>(calloc(sizeof(Pair *)*allocated));          refs=static_cast<Pair **>(calloc(sizeof(Pair *)*allocated));
   
         // rehash          // rehash
Line 74  uint Hash::generic_code(uint aresult, co Line 79  uint Hash::generic_code(uint aresult, co
         return result;          return result;
 }  }
   
 bool Hash::put(const Key& key, Value *value) {  SYNCHRONIZED(thread_safe);  bool Hash::put(const Key& key, Val *value) {
         if(full())           if(full()) 
                 expand();                  expand();
   
Line 95  bool Hash::put(const Key& key, Value *va Line 100  bool Hash::put(const Key& key, Value *va
         return false;          return false;
 }  }
   
 Hash::Value *Hash::get(const Key& key) const {  SYNCHRONIZED(thread_safe);  Hash::Val *Hash::get(const Key& key) const {
         uint code=key.hash_code();          uint code=key.hash_code();
         uint index=code%allocated;          uint index=code%allocated;
         for(Pair *pair=refs[index]; pair; pair=pair->link)          for(Pair *pair=refs[index]; pair; pair=pair->link)
Line 105  Hash::Value *Hash::get(const Key& key) c Line 110  Hash::Value *Hash::get(const Key& key) c
         return 0;          return 0;
 }  }
   
 bool Hash::put_replace(const Key& key, Value *value) {  SYNCHRONIZED(thread_safe);  bool Hash::put_replace(const Key& key, Val *value) {
         uint code=key.hash_code();          uint code=key.hash_code();
         uint index=code%allocated;          uint index=code%allocated;
         for(Pair *pair=refs[index]; pair; pair=pair->link)          for(Pair *pair=refs[index]; pair; pair=pair->link)
Line 119  bool Hash::put_replace(const Key& key, V Line 124  bool Hash::put_replace(const Key& key, V
         return false;          return false;
 }  }
   
 bool Hash::put_dont_replace(const Key& key, Value *value) {  SYNCHRONIZED(thread_safe);  bool Hash::put_dont_replace(const Key& key, Val *value) {
         if(full())           if(full()) 
                 expand();                  expand();
   
Line 139  bool Hash::put_dont_replace(const Key& k Line 144  bool Hash::put_dont_replace(const Key& k
         return false;          return false;
 }  }
   
 void Hash::merge_dont_replace(const Hash& src) {  SYNCHRONIZED(thread_safe);  void Hash::merge_dont_replace(const Hash& src) {
         for(int i=0; i<src.allocated; i++)          for(int i=0; i<src.allocated; i++)
                 for(Pair *pair=src.refs[i]; pair; pair=pair->link)                  for(Pair *pair=src.refs[i]; pair; pair=pair->link)
                         put_dont_replace(pair->key, pair->value);                          put_dont_replace(pair->key, pair->value);
         // MAY:optimize this.allocated==src.allocated case          // MAY:optimize this.allocated==src.allocated case
 }  }
   
   void Hash::for_each(For_each_func func, void *info) const {
           Pair **ref=refs;
           for(int index=0; index<allocated; index++)
                   for(Pair *pair=*ref++; pair; pair=pair->link)
                           if(pair->value)
                                   (*func)(pair->key, pair->value, info);
   }
   
   Hash::Val* Hash::first_that(First_that_func func, void *info) const {
           Pair **ref=refs;
           for(int index=0; index<allocated; index++)
                   for(Pair *pair=*ref++; pair; pair=pair->link)
                           if(pair->value)
                                   if((*func)(pair->key, pair->value, info))
                                           return pair->value;
           return 0;
   }
   
   void Hash::clear() {
           memset(refs, 0, sizeof(*refs)*allocated);
           used=0;
   }
Removed from v.1.18  
changed lines
  Added in v.1.36

E-mail: