SNAP Library 2.4, User Reference  2015-05-11 19:40:56
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
TStrHash< TDat, TStringPool, THashFunc > Class Template Reference

#include <hash.h>

Public Member Functions

 TStrHash ()
 
 TStrHash (const PStringPool &StrPool)
 
 TStrHash (const int &Ports, const bool &_AutoSizeP=false, const PStringPool &StrPool=PStringPool())
 
 TStrHash (const TStrHash &Hash)
 
 TStrHash (TSIn &SIn, bool PoolToo=true)
 
void Load (TSIn &SIn, bool PoolToo=true)
 
void Save (TSOut &SOut, bool PoolToo=true) const
 
void SetPool (const PStringPool &StrPool)
 
PStringPool GetPool () const
 
TStrHash & operator= (const TStrHash &Hash)
 
bool Empty () const
 
int Len () const
 
int Reserved () const
 
int GetPorts () const
 
bool IsAutoSize () const
 
int GetMxKeyIds () const
 
bool IsKeyIdEqKeyN () const
 
int AddKey (const char *Key)
 
int AddKey (const TStr &Key)
 
int AddKey (const TChA &Key)
 
int AddDat (const char *Key, const TDat &Dat)
 
int AddDat (const TStr &Key, const TDat &Dat)
 
int AddDat (const TChA &Key, const TDat &Dat)
 
TDat & AddDat (const char *Key)
 
TDat & AddDat (const TStr &Key)
 
TDat & AddDat (const TChA &Key)
 
TDat & AddDatId (const char *Key)
 
TDat & AddDatId (const TStr &Key)
 
TDat & AddDatId (const TChA &Key)
 
const TDat & operator[] (const int &KeyId) const
 
TDat & operator[] (const int &KeyId)
 
const TDat & operator() (const char *Key) const
 
const TDat & GetDat (const char *Key) const
 
const TDat & GetDat (const TStr &Key) const
 
TDat & GetDat (const char *Key)
 
const TDat & GetDat (const TStr &Key)
 
const TDat & GetDat (const TChA &Key)
 
TDat & GetDatId (const int &KeyId)
 
const TDat & GetDatId (const int &KeyId) const
 
void GetKeyDat (const int &KeyId, int &KeyO, TDat &Dat) const
 
void GetKeyDat (const int &KeyId, const char *&Key, TDat &Dat) const
 
void GetKeyDat (const int &KeyId, TStr &Key, TDat &Dat) const
 
void GetKeyDat (const int &KeyId, TChA &Key, TDat &Dat) const
 
int GetKeyId (const char *Key) const
 
int GetKeyId (const TStr &Key) const
 
const char * GetKey (const int &KeyId) const
 
int GetKeyOfs (const int &KeyId) const
 
const char * KeyFromOfs (const int &KeyO) const
 
bool IsKey (const char *Key) const
 
bool IsKey (const TStr &Key) const
 
bool IsKey (const TChA &Key) const
 
bool IsKey (const char *Key, int &KeyId) const
 
bool IsKeyGetDat (const char *Key, TDat &Dat) const
 
bool IsKeyGetDat (const TStr &Key, TDat &Dat) const
 
bool IsKeyGetDat (const TChA &Key, TDat &Dat) const
 
bool IsKeyId (const int &KeyId) const
 
int FFirstKeyId () const
 
bool FNextKeyId (int &KeyId) const
 
void GetKeyV (TVec< TStr > &KeyV) const
 
void GetStrIdV (TIntV &StrIdV) const
 
void GetDatV (TVec< TDat > &DatV) const
 
void GetKeyDatPrV (TVec< TPair< TStr, TDat > > &KeyDatPrV) const
 
void GetDatKeyPrV (TVec< TPair< TDat, TStr > > &DatKeyPrV) const
 
void Pack ()
 

Private Types

typedef TPt< TStringPool > PStringPool
 
typedef THashKeyDat< TInt, TDat > THKeyDat
 
typedef TPair< TInt, TDat > TKeyDatP
 
typedef TVec< THKeyDat > THKeyDatV
 

Private Member Functions

uint GetNextPrime (const uint &Val) const
 
void Resize ()
 
const THKeyDat & GetHashKeyDat (const int &KeyId) const
 
THKeyDat & GetHashKeyDat (const int &KeyId)
 

Private Attributes

TIntV PortV
 
THKeyDatV KeyDatV
 
TBool AutoSizeP
 
TInt FFreeKeyId
 
TInt FreeKeys
 
PStringPool Pool
 

Detailed Description

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
class TStrHash< TDat, TStringPool, THashFunc >

Definition at line 716 of file hash.h.

Member Typedef Documentation

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
typedef TPt<TStringPool> TStrHash< TDat, TStringPool, THashFunc >::PStringPool
private

Definition at line 719 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
typedef THashKeyDat<TInt, TDat> TStrHash< TDat, TStringPool, THashFunc >::THKeyDat
private

Definition at line 720 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
typedef TVec<THKeyDat> TStrHash< TDat, TStringPool, THashFunc >::THKeyDatV
private

Definition at line 722 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
typedef TPair<TInt, TDat> TStrHash< TDat, TStringPool, THashFunc >::TKeyDatP
private

Definition at line 721 of file hash.h.

Constructor & Destructor Documentation

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( )
inline

Definition at line 736 of file hash.h.

736 : PortV(), KeyDatV(), AutoSizeP(true), FFreeKeyId(-1), FreeKeys(0), Pool() { }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( const PStringPool &  StrPool)
inline

Definition at line 737 of file hash.h.

737 : PortV(), KeyDatV(), AutoSizeP(true), FFreeKeyId(-1), FreeKeys(0), Pool(StrPool) { }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( const int &  Ports,
const bool &  _AutoSizeP = false,
const PStringPool &  StrPool = PStringPool() 
)
inline

Definition at line 738 of file hash.h.

738  :
739  PortV(Ports), KeyDatV(Ports, 0), AutoSizeP(_AutoSizeP), FFreeKeyId(-1), FreeKeys(0), Pool(StrPool) { PortV.PutAll(-1); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::PutAll
void PutAll(const TVal &Val)
Sets all elements of the vector to value Val.
Definition: ds.h:1130
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( const TStrHash< TDat, TStringPool, THashFunc > &  Hash)
inline

Definition at line 740 of file hash.h.

740  : PortV(Hash.PortV), KeyDatV(Hash.KeyDatV), AutoSizeP(Hash.AutoSizeP),
741  FFreeKeyId(Hash.FFreeKeyId), FreeKeys(Hash.FreeKeys), Pool() {
742  if (! Hash.Pool.Empty()) { Pool=PStringPool(new TStringPool(*Hash.Pool)); } }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TPt::Empty
bool Empty() const
Definition: bd.h:501
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TStrHash::PStringPool
TPt< TStringPool > PStringPool
Definition: hash.h:719
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( TSIn &  SIn,
bool  PoolToo = true 
)
inline

Definition at line 743 of file hash.h.

743 : PortV(SIn), KeyDatV(SIn), AutoSizeP(SIn), FFreeKeyId(SIn), FreeKeys(SIn){ SIn.LoadCs(); if (PoolToo) Pool = PStringPool(SIn); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TSIn::LoadCs
void LoadCs()
Definition: fl.cpp:28
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TStrHash::PStringPool
TPt< TStringPool > PStringPool
Definition: hash.h:719

Member Function Documentation

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const char *  Key,
const TDat &  Dat 
)
inline

Definition at line 766 of file hash.h.

766 { const int KeyId = AddKey(Key); KeyDatV[KeyId].Dat = Dat; return KeyId; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TStr &  Key,
const TDat &  Dat 
)
inline

Definition at line 767 of file hash.h.

767 { const int KeyId = AddKey(Key.CStr()); KeyDatV[KeyId].Dat = Dat; return KeyId; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
TStr::CStr
char * CStr()
Definition: dt.h:476
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TChA &  Key,
const TDat &  Dat 
)
inline

Definition at line 768 of file hash.h.

768 { const int KeyId = AddKey(Key.CStr()); KeyDatV[KeyId].Dat = Dat; return KeyId; }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const char *  Key)
inline

Definition at line 769 of file hash.h.

769 { return KeyDatV[AddKey(Key)].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TStr &  Key)
inline

Definition at line 770 of file hash.h.

770 { return KeyDatV[AddKey(Key.CStr())].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
TStr::CStr
char * CStr()
Definition: dt.h:476
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TChA &  Key)
inline

Definition at line 771 of file hash.h.

771 { return KeyDatV[AddKey(Key.CStr())].Dat; }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const char *  Key)
inline

Definition at line 772 of file hash.h.

772 { const int KeyId = AddKey(Key); return KeyDatV[KeyId].Dat = KeyId; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const TStr &  Key)
inline

Definition at line 773 of file hash.h.

773 { const int KeyId = AddKey(Key.CStr()); return KeyDatV[KeyId].Dat = KeyId; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
TStr::CStr
char * CStr()
Definition: dt.h:476
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const TChA &  Key)
inline

Definition at line 774 of file hash.h.

774 { const int KeyId = AddKey(Key.CStr()); return KeyDatV[KeyId].Dat = KeyId; }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat , class TStringPool , class THashFunc >
int TStrHash< TDat, TStringPool, THashFunc >::AddKey ( const char *  Key)

Definition at line 870 of file hash.h.

870  {
871  if (Pool.Empty()) Pool = TStringPool::New();
872  if ((AutoSizeP && KeyDatV.Len() > PortV.Len()) || PortV.Empty()) Resize();
873  const int PortN = abs(THashFunc::GetPrimHashCd(Key) % PortV.Len());
874  const int HashCd = abs(THashFunc::GetSecHashCd(Key));
875  int PrevKeyId = -1;
876  int KeyId = PortV[PortN];
877  while (KeyId != -1 && ! (KeyDatV[KeyId].HashCd == HashCd && Pool->Cmp(KeyDatV[KeyId].Key, Key) == 0)) {
878  PrevKeyId = KeyId; KeyId = KeyDatV[KeyId].Next; }
879  if (KeyId == -1) {
880  const int StrId = Pool->AddStr(Key);
881  if (FFreeKeyId == -1) {
882  KeyId = KeyDatV.Add(THKeyDat(-1, HashCd, StrId));
883  } else {
884  KeyId = FFreeKeyId;
885  FFreeKeyId = KeyDatV[FFreeKeyId].Next;
886  FreeKeys--;
887  KeyDatV[KeyId] = THKeyDat(-1, HashCd, StrId);
888  }
889  if (PrevKeyId == -1) PortV[PortN] = KeyId;
890  else KeyDatV[PrevKeyId].Next = KeyId;
891  }
892  return KeyId;
893 }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TPt::Empty
bool Empty() const
Definition: bd.h:501
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::Empty
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:530
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::Resize
void Resize()
Definition: hash.h:833
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::AddKey ( const TStr &  Key)
inline

Definition at line 764 of file hash.h.

764 { return AddKey(Key.CStr()); }
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
TStr::CStr
char * CStr()
Definition: dt.h:476
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::AddKey ( const TChA &  Key)
inline

Definition at line 765 of file hash.h.

765 { return AddKey(Key.CStr()); }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::AddKey
int AddKey(const char *Key)
Definition: hash.h:870
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::Empty ( ) const
inline

Definition at line 755 of file hash.h.

755 {return ! Len(); }
TStrHash::Len
int Len() const
Definition: hash.h:756
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::FFirstKeyId ( ) const
inline

Definition at line 808 of file hash.h.

808 {return 0-1;}
template<class TDat , class TStringPool , class THashFunc >
bool TStrHash< TDat, TStringPool, THashFunc >::FNextKeyId ( int &  KeyId) const

Definition at line 907 of file hash.h.

907  {
908  do KeyId++; while (KeyId < KeyDatV.Len() && KeyDatV[KeyId].HashCd == -1);
909  return KeyId < KeyDatV.Len();
910 }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const char *  Key) const
inline

Definition at line 781 of file hash.h.

781 { return KeyDatV[GetKeyId(Key)].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const TStr &  Key) const
inline

Definition at line 782 of file hash.h.

782 { return GetDat(Key.CStr()); }
TStr::CStr
char * CStr()
Definition: dt.h:476
TStrHash::GetDat
const TDat & GetDat(const char *Key) const
Definition: hash.h:781
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const char *  Key)
inline

Definition at line 783 of file hash.h.

783 { return KeyDatV[GetKeyId(Key)].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const TStr &  Key)
inline

Definition at line 784 of file hash.h.

784 { return GetDat(Key.CStr()); }
TStr::CStr
char * CStr()
Definition: dt.h:476
TStrHash::GetDat
const TDat & GetDat(const char *Key) const
Definition: hash.h:781
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const TChA &  Key)
inline

Definition at line 785 of file hash.h.

785 { return GetDat(Key.CStr()); }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::GetDat
const TDat & GetDat(const char *Key) const
Definition: hash.h:781
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDatId ( const int &  KeyId)
inline

Definition at line 786 of file hash.h.

786 { return KeyDatV[KeyId].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDatId ( const int &  KeyId) const
inline

Definition at line 787 of file hash.h.

787 { return KeyDatV[KeyId].Dat; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::GetDatKeyPrV ( TVec< TPair< TDat, TStr > > &  DatKeyPrV) const

Definition at line 948 of file hash.h.

948  {
949  DatKeyPrV.Gen(Len(), 0);
950  TStr Str; TDat Dat;
951  int KeyId = FFirstKeyId();
952  while (FNextKeyId(KeyId)){
953  GetKeyDat(KeyId, Str, Dat);
954  DatKeyPrV.Add(TPair<TDat, TStr>(Dat, Str));
955  }
956 }
TStrHash::FFirstKeyId
int FFirstKeyId() const
Definition: hash.h:808
TStrHash::Len
int Len() const
Definition: hash.h:756
TStrHash::FNextKeyId
bool FNextKeyId(int &KeyId) const
Definition: hash.h:907
TStrHash::GetKeyDat
void GetKeyDat(const int &KeyId, int &KeyO, TDat &Dat) const
Definition: hash.h:788
TPair
Definition: ds.h:32
TStr
Definition: dt.h:412
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::GetDatV ( TVec< TDat > &  DatV) const

Definition at line 929 of file hash.h.

929  {
930  DatV.Gen(Len(), 0);
931  int KeyId = FFirstKeyId();
932  while (FNextKeyId(KeyId))
933  DatV.Add(GetHashKeyDat(KeyId).Dat);
934 }
TStrHash::FFirstKeyId
int FFirstKeyId() const
Definition: hash.h:808
TStrHash::Len
int Len() const
Definition: hash.h:756
TStrHash::FNextKeyId
bool FNextKeyId(int &KeyId) const
Definition: hash.h:907
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const THKeyDat& TStrHash< TDat, TStringPool, THashFunc >::GetHashKeyDat ( const int &  KeyId) const
inlineprivate

Definition at line 731 of file hash.h.

731  {
732  const THKeyDat& KeyDat = KeyDatV[KeyId]; Assert(KeyDat.HashCd != -1); return KeyDat; }
Assert
#define Assert(Cond)
Definition: bd.h:251
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
THKeyDat& TStrHash< TDat, TStringPool, THashFunc >::GetHashKeyDat ( const int &  KeyId)
inlineprivate

Definition at line 733 of file hash.h.

733  {
734  THKeyDat& KeyDat = KeyDatV[KeyId]; Assert(KeyDat.HashCd != -1); return KeyDat; }
Assert
#define Assert(Cond)
Definition: bd.h:251
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const char* TStrHash< TDat, TStringPool, THashFunc >::GetKey ( const int &  KeyId) const
inline

Definition at line 795 of file hash.h.

795 { return Pool->GetCStr(GetHashKeyDat(KeyId).Key); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDat ( const int &  KeyId,
int &  KeyO,
TDat &  Dat 
) const
inline

Definition at line 788 of file hash.h.

788 { const THKeyDat& KeyDat = GetHashKeyDat(KeyId); KeyO = KeyDat.Key; Dat = KeyDat.Dat; }
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDat ( const int &  KeyId,
const char *&  Key,
TDat &  Dat 
) const
inline

Definition at line 789 of file hash.h.

789 { const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat; }
TStrHash::KeyFromOfs
const char * KeyFromOfs(const int &KeyO) const
Definition: hash.h:797
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDat ( const int &  KeyId,
TStr &  Key,
TDat &  Dat 
) const
inline

Definition at line 790 of file hash.h.

790 { const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat;}
TStrHash::KeyFromOfs
const char * KeyFromOfs(const int &KeyO) const
Definition: hash.h:797
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDat ( const int &  KeyId,
TChA &  Key,
TDat &  Dat 
) const
inline

Definition at line 791 of file hash.h.

791 { const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat;}
TStrHash::KeyFromOfs
const char * KeyFromOfs(const int &KeyO) const
Definition: hash.h:797
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDatPrV ( TVec< TPair< TStr, TDat > > &  KeyDatPrV) const

Definition at line 937 of file hash.h.

937  {
938  KeyDatPrV.Gen(Len(), 0);
939  TStr Str; TDat Dat;
940  int KeyId = FFirstKeyId();
941  while (FNextKeyId(KeyId)){
942  GetKeyDat(KeyId, Str, Dat);
943  KeyDatPrV.Add(TPair<TStr, TDat>(Str, Dat));
944  }
945 }
TStrHash::FFirstKeyId
int FFirstKeyId() const
Definition: hash.h:808
TStrHash::Len
int Len() const
Definition: hash.h:756
TStrHash::FNextKeyId
bool FNextKeyId(int &KeyId) const
Definition: hash.h:907
TStrHash::GetKeyDat
void GetKeyDat(const int &KeyId, int &KeyO, TDat &Dat) const
Definition: hash.h:788
TPair
Definition: ds.h:32
TStr
Definition: dt.h:412
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat , class TStringPool , class THashFunc >
int TStrHash< TDat, TStringPool, THashFunc >::GetKeyId ( const char *  Key) const

Definition at line 896 of file hash.h.

896  {
897  if (PortV.Empty()) return -1;
898  const int PortN = abs(THashFunc::GetPrimHashCd(Key) % PortV.Len());
899  const int Hc = abs(THashFunc::GetSecHashCd(Key));
900  int KeyId = PortV[PortN];
901  while (KeyId != -1 && ! (KeyDatV[KeyId].HashCd == Hc && Pool->Cmp(KeyDatV[KeyId].Key, Key) == 0))
902  KeyId = KeyDatV[KeyId].Next;
903  return KeyId;
904 }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::Empty
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:530
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::GetKeyId ( const TStr &  Key) const
inline

Definition at line 794 of file hash.h.

794 { return GetKeyId(Key.CStr()); }
TStr::CStr
char * CStr()
Definition: dt.h:476
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::GetKeyOfs ( const int &  KeyId) const
inline

Definition at line 796 of file hash.h.

796 { return GetHashKeyDat(KeyId).Key; } // pool string id
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
THashKeyDat::Key
TKey Key
Definition: hash.h:11
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::GetKeyV ( TVec< TStr > &  KeyV) const

Definition at line 913 of file hash.h.

913  {
914  KeyV.Gen(Len(), 0);
915  int KeyId = FFirstKeyId();
916  while (FNextKeyId(KeyId))
917  KeyV.Add(GetKey(KeyId));
918 }
TStrHash::FFirstKeyId
int FFirstKeyId() const
Definition: hash.h:808
TStrHash::Len
int Len() const
Definition: hash.h:756
TStrHash::FNextKeyId
bool FNextKeyId(int &KeyId) const
Definition: hash.h:907
TStrHash::GetKey
const char * GetKey(const int &KeyId) const
Definition: hash.h:795
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::GetMxKeyIds ( ) const
inline

Definition at line 760 of file hash.h.

760 { return KeyDatV.Len(); }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat , class TStringPool , class THashFunc >
uint TStrHash< TDat, TStringPool, THashFunc >::GetNextPrime ( const uint &  Val) const
private

Definition at line 821 of file hash.h.

821  {
822  uint *f = (uint *) TIntH::HashPrimeT, *m, *l = (uint *) TIntH::HashPrimeT + (int) TIntH::HashPrimes;
823  int h, len = (int)TIntH::HashPrimes;
824  while (len > 0) {
825  h = len >> 1; m = f + h;
826  if (*m < Val) { f = m; f++; len = len - h - 1; }
827  else len = h;
828  }
829  return f == l ? *(l - 1) : *f;
830 }
uint
unsigned int uint
Definition: bd.h:11
THash< TInt, TInt >::HashPrimeT
static const unsigned int HashPrimeT[HashPrimes]
Definition: hash.h:91
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
PStringPool TStrHash< TDat, TStringPool, THashFunc >::GetPool ( ) const
inline

Definition at line 751 of file hash.h.

751 { return Pool; }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::GetPorts ( ) const
inline

Definition at line 758 of file hash.h.

758 { return PortV.Len(); }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::GetStrIdV ( TIntV &  StrIdV) const

Definition at line 921 of file hash.h.

921  {
922  StrIdV.Gen(Len(), 0);
923  int KeyId = FFirstKeyId();
924  while (FNextKeyId(KeyId))
925  StrIdV.Add(GetKeyOfs(KeyId));
926 }
TStrHash::GetKeyOfs
int GetKeyOfs(const int &KeyId) const
Definition: hash.h:796
TStrHash::FFirstKeyId
int FFirstKeyId() const
Definition: hash.h:808
TStrHash::Len
int Len() const
Definition: hash.h:756
TStrHash::FNextKeyId
bool FNextKeyId(int &KeyId) const
Definition: hash.h:907
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TVec::Add
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:559
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsAutoSize ( ) const
inline

Definition at line 759 of file hash.h.

759 { return AutoSizeP; }
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const char *  Key) const
inline

Definition at line 799 of file hash.h.

799 { return GetKeyId(Key) != -1; }
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const TStr &  Key) const
inline

Definition at line 800 of file hash.h.

800 { return GetKeyId(Key.CStr()) != -1; }
TStr::CStr
char * CStr()
Definition: dt.h:476
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const TChA &  Key) const
inline

Definition at line 801 of file hash.h.

801 { return GetKeyId(Key.CStr()) != -1; }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const char *  Key,
int &  KeyId 
) const
inline

Definition at line 802 of file hash.h.

802 { KeyId = GetKeyId(Key); return KeyId != -1; }
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyGetDat ( const char *  Key,
TDat &  Dat 
) const
inline

Definition at line 803 of file hash.h.

803 { const int KeyId = GetKeyId(Key); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyGetDat ( const TStr &  Key,
TDat &  Dat 
) const
inline

Definition at line 804 of file hash.h.

804 { const int KeyId = GetKeyId(Key.CStr()); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStr::CStr
char * CStr()
Definition: dt.h:476
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyGetDat ( const TChA &  Key,
TDat &  Dat 
) const
inline

Definition at line 805 of file hash.h.

805 { const int KeyId = GetKeyId(Key.CStr()); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }
TChA::CStr
char * CStr()
Definition: dt.h:255
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::GetKeyId
int GetKeyId(const char *Key) const
Definition: hash.h:896
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyId ( const int &  KeyId) const
inline

Definition at line 806 of file hash.h.

806 { return 0 <= KeyId && KeyId < KeyDatV.Len() && KeyDatV[KeyId].HashCd != -1; }
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyIdEqKeyN ( ) const
inline

Definition at line 761 of file hash.h.

761 {return ! FreeKeys; }
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const char* TStrHash< TDat, TStringPool, THashFunc >::KeyFromOfs ( const int &  KeyO) const
inline

Definition at line 797 of file hash.h.

797 { return Pool->GetCStr(KeyO); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::Len ( ) const
inline

Definition at line 756 of file hash.h.

756 { return KeyDatV.Len() - FreeKeys; }
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::Load ( TSIn &  SIn,
bool  PoolToo = true 
)
inline

Definition at line 745 of file hash.h.

745  { PortV.Load(SIn); KeyDatV.Load(SIn); AutoSizeP.Load(SIn); FFreeKeyId.Load(SIn);
746  FreeKeys.Load(SIn); SIn.LoadCs(); if (PoolToo) Pool = PStringPool(SIn); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TBool::Load
void Load(TSIn &SIn)
Definition: dt.h:901
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::Load
void Load(TSIn &SIn)
Definition: ds.h:877
TSIn::LoadCs
void LoadCs()
Definition: fl.cpp:28
TInt::Load
void Load(TSIn &SIn)
Definition: dt.h:1057
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TStrHash::PStringPool
TPt< TStringPool > PStringPool
Definition: hash.h:719
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::operator() ( const char *  Key) const
inline

Definition at line 778 of file hash.h.

778 { return GetDat(Key);}
TStrHash::GetDat
const TDat & GetDat(const char *Key) const
Definition: hash.h:781
template<class TDat , class TStringPool , class THashFunc >
TStrHash< TDat, TStringPool, THashFunc > & TStrHash< TDat, TStringPool, THashFunc >::operator= ( const TStrHash< TDat, TStringPool, THashFunc > &  Hash)

Definition at line 856 of file hash.h.

856  {
857  if (this != &Hash) {
858  PortV = Hash.PortV;
859  KeyDatV = Hash.KeyDatV;
860  AutoSizeP = Hash.AutoSizeP;
861  FFreeKeyId = Hash.FFreeKeyId;
862  FreeKeys = Hash.FreeKeys;
863  if (! Hash.Pool.Empty()) Pool = PStringPool(new TStringPool(*Hash.Pool));
864  else Pool = NULL;
865  }
866  return *this;
867 }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TPt::Empty
bool Empty() const
Definition: bd.h:501
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TStrHash::PStringPool
TPt< TStringPool > PStringPool
Definition: hash.h:719
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
const TDat& TStrHash< TDat, TStringPool, THashFunc >::operator[] ( const int &  KeyId) const
inline

Definition at line 776 of file hash.h.

776 {return GetHashKeyDat(KeyId).Dat;}
THashKeyDat::Dat
TDat Dat
Definition: hash.h:12
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TDat& TStrHash< TDat, TStringPool, THashFunc >::operator[] ( const int &  KeyId)
inline

Definition at line 777 of file hash.h.

777 {return GetHashKeyDat(KeyId).Dat;}
THashKeyDat::Dat
TDat Dat
Definition: hash.h:12
TStrHash::GetHashKeyDat
const THKeyDat & GetHashKeyDat(const int &KeyId) const
Definition: hash.h:731
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::Pack ( )
inline

Definition at line 817 of file hash.h.

817 {KeyDatV.Pack();}
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TVec::Pack
void Pack()
The vector reduces its capacity (frees memory) to match its size.
Definition: ds.h:987
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
int TStrHash< TDat, TStringPool, THashFunc >::Reserved ( ) const
inline

Definition at line 757 of file hash.h.

757 { return KeyDatV.Reserved(); }
TVec::Reserved
TSizeTy Reserved() const
Returns the size of allocated storage capacity.
Definition: ds.h:537
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
template<class TDat , class TStringPool , class THashFunc >
void TStrHash< TDat, TStringPool, THashFunc >::Resize ( )
private

Definition at line 833 of file hash.h.

833  {
834  // resize & initialize port vector
835  if (PortV.Empty()) { PortV.Gen(17); PortV.PutAll(-1); }
836  else
837  if (AutoSizeP && KeyDatV.Len() > 3 * PortV.Len()) {
838  const int NxPrime = GetNextPrime(KeyDatV.Len());
839  //printf("%s resize PortV: %d -> %d, Len: %d\n", GetTypeNm(*this).CStr(), PortV.Len(), NxPrime, Len());
840  PortV.Gen(NxPrime); PortV.PutAll(-1); }
841  else
842  return;
843  // rehash keys
844  const int NPorts = PortV.Len();
845  for (int i = 0; i < KeyDatV.Len(); i++) {
846  THKeyDat& KeyDat = KeyDatV[i];
847  if (KeyDat.HashCd != -1) {
848  const int Port = abs(THashFunc::GetPrimHashCd(Pool->GetCStr(KeyDat.Key)) % NPorts);
849  KeyDat.Next = PortV[Port];
850  PortV[Port] = i;
851  }
852  }
853 }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TVec::Len
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:535
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::Empty
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:530
TVec::PutAll
void PutAll(const TVal &Val)
Sets all elements of the vector to value Val.
Definition: ds.h:1130
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::GetNextPrime
uint GetNextPrime(const uint &Val) const
Definition: hash.h:821
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TVec::Gen
void Gen(const TSizeTy &_Vals)
Constructs a vector (an array) of _Vals elements.
Definition: ds.h:486
TStrHash::THKeyDat
THashKeyDat< TInt, TDat > THKeyDat
Definition: hash.h:720
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::Save ( TSOut &  SOut,
bool  PoolToo = true 
) const
inline

Definition at line 747 of file hash.h.

747  { PortV.Save(SOut); KeyDatV.Save(SOut);
748  AutoSizeP.Save(SOut); FFreeKeyId.Save(SOut); FreeKeys.Save(SOut); SOut.SaveCs(); if (PoolToo) Pool.Save(SOut); }
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TStrHash::FreeKeys
TInt FreeKeys
Definition: hash.h:726
TInt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1058
TStrHash::FFreeKeyId
TInt FFreeKeyId
Definition: hash.h:726
TBool::Save
void Save(TSOut &SOut) const
Definition: dt.h:902
TStrHash::PortV
TIntV PortV
Definition: hash.h:723
TVec::Save
void Save(TSOut &SOut) const
Definition: ds.h:885
TSOut::SaveCs
void SaveCs()
Definition: fl.h:171
TStrHash::KeyDatV
THKeyDatV KeyDatV
Definition: hash.h:724
TStrHash::AutoSizeP
TBool AutoSizeP
Definition: hash.h:725
TPt::Save
void Save(TSOut &SOut) const
Definition: xmlser.h:16
template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
void TStrHash< TDat, TStringPool, THashFunc >::SetPool ( const PStringPool &  StrPool)
inline

Definition at line 750 of file hash.h.

750 { IAssert(Pool.Empty() || Pool->Empty()); Pool = StrPool; }
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TStrHash::Pool
PStringPool Pool
Definition: hash.h:727
TPt::Empty
bool Empty() const
Definition: bd.h:501

Member Data Documentation

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TBool TStrHash< TDat, TStringPool, THashFunc >::AutoSizeP
private

Definition at line 725 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TInt TStrHash< TDat, TStringPool, THashFunc >::FFreeKeyId
private

Definition at line 726 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TInt TStrHash< TDat, TStringPool, THashFunc >::FreeKeys
private

Definition at line 726 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
THKeyDatV TStrHash< TDat, TStringPool, THashFunc >::KeyDatV
private

Definition at line 724 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
PStringPool TStrHash< TDat, TStringPool, THashFunc >::Pool
private

Definition at line 727 of file hash.h.

template<class TDat, class TStringPool = TStrPool, class THashFunc = TDefaultHashFunc<TStr>>
TIntV TStrHash< TDat, TStringPool, THashFunc >::PortV
private

Definition at line 723 of file hash.h.

The documentation for this class was generated from the following file: