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

Diff for /parser3/src/include/pa_hash.h between versions 1.17 and 1.26

version 1.17, 2001/02/23 14:18:26 version 1.26, 2001/03/18 12:10:55
Line 1 Line 1
 /*  /*
   $Id$          Parser
 */          Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
           Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
 /*  
   
   
           $Id$
 */  */
   
 #ifndef PA_HASH_H  #ifndef PA_HASH_H
Line 16 Line 15
 #include "pa_types.h"  #include "pa_types.h"
 #include "pa_string.h"  #include "pa_string.h"
   
 class Hash : virtual public Pooled {  class Hash : public Pooled {
 public:  public:
   
         typedef String Key;          typedef String Key;
         typedef void Value;          typedef void Value;
   
           typedef void (*Foreach_func)(const Key& key, Value *value, void *info);
   
 public:  public:
   
         Hash(Pool& apool,bool) : Pooled(apool) { construct(apool, true); }          Hash(Pool& apool,bool athread_safe=false) : Pooled(apool) { 
         Hash(Pool& apool) : Pooled(apool) { construct(apool, false); }                  construct(apool, athread_safe); 
           }
   
         // useful generic hash function          // useful generic hash function
         static uint generic_code(uint aresult, const char *start, uint size);          static uint generic_code(uint aresult, const char *start, uint allocated);
   
         // put a [value] under the [key]          // put a [value] under the [key], return existed or not
         /*SYNCHRONIZED*/ void put(const Key& key, Value *value);          /*SYNCHRONIZED*/ bool put(const Key& key, Value *value);
   
         // get associated [value] by the [key]          // get associated [value] by the [key]
         /*SYNCHRONIZED*/ Value *get(const Key& key) const;          /*SYNCHRONIZED*/ Value *get(const Key& key) const;
   
         // put a [value] under the [key] if that [key] existed, return existed or not          // put a [value] under the [key] if that [key] existed, return existed or not
         /*SYNCHRONIZED*/ bool replace(const Key& key, Value *value);          /*SYNCHRONIZED*/ bool put_replace(const Key& key, Value *value);
   
           // put a [value] under the [key] if that [key] NOT existed, return existed or not
           /*SYNCHRONIZED*/ bool put_dont_replace(const Key& key, Value *value);
   
           // put all 'src' values if NO with same key existed
           /*SYNCHRONIZED*/ void merge_dont_replace(const Hash& src);
   
         void put(const Key& key, int     value) { put(key, reinterpret_cast<Value *>(value)); }          void put(const Key& key, int     value) { put(key, reinterpret_cast<Value *>(value)); }
         void put(const Key& key, String *value) { put(key, static_cast<Value *>(value)); }          void put(const Key& key, String *value) { put(key, static_cast<Value *>(value)); }
   
         int get_int(const Key& key) { return reinterpret_cast<int>(get(key)); }          int get_int(const Key& key) { return reinterpret_cast<int>(get(key)); }
         String *get_string(const Key& key) { return static_cast<String *>(get(key)); }          const String *get_string(const Key& key) { return static_cast<String *>(get(key)); }
   
           int size() { return used; }
   
           void foreach(Foreach_func func, void *info=0);
   
 protected:  protected:
   
Line 51  protected: Line 63  protected:
   
 private:  private:
   
         // expand when these %% of size exausted          // expand when these %% of allocated exausted
         enum {          enum {
                 THRESHOLD_PERCENT=75                  THRESHOLD_PERCENT=75
         };          };
Line 59  private: Line 71  private:
         // am I thread-safe?          // am I thread-safe?
         bool thread_safe;          bool thread_safe;
   
         // the index of [size] in [sizes]          // the index of [allocated] in [allocates]
         int size_index;          int allocates_index;
   
         // possible [sizes]. prime numbers          // possible [allocates]. prime numbers
         static uint sizes[];          static uint allocates[];
         static int sizes_count;          static int allocates_count;
   
         // number of allocated pairs          // number of allocated pairs
         int size;          int allocated;
   
         // helper: expanding when used == threshold          // helper: expanding when used == threshold
         int threshold;          int threshold;
Line 84  private: Line 96  private:
                 Value *value;                  Value *value;
                 Pair *link;                  Pair *link;
                                   
                 void *operator new(size_t size, Pool& apool);                  void *operator new(size_t allocated, Pool& apool);
   
                 Pair(uint acode, const Key& akey, Value *avalue, Pair *alink) :                  Pair(uint acode, const Key& akey, Value *avalue, Pair *alink) :
                         code(acode),                          code(acode),
Removed from v.1.17  
changed lines
  Added in v.1.26

E-mail: