TStrHash< TDat, TStringPool, THashFunc > Class Template Reference

#include <hash.h>

Collaboration diagram for TStrHash< TDat, TStringPool, THashFunc >:

Public Types
typedef TPt< TStringPool >	PStringPool

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	LoadShM (TShMIn &ShMIn, bool SharedPool=true)
	Load hash from shared memory. If shared pool is true load pool from shared memory. More...
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
::TSize	GetMemUsed () 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 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 781 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

Definition at line 784 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 786 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 788 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 787 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 802 of file hash.h.

: PortV(), KeyDatV(), AutoSizeP(true), FFreeKeyId(-1), FreeKeys(0), Pool() { }

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

TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( const PStringPool &  StrPool )

inline

Definition at line 803 of file hash.h.

: PortV(), KeyDatV(), AutoSizeP(true), FFreeKeyId(-1), FreeKeys(0), Pool(StrPool) { }

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 804 of file hash.h.

                                                                                                         :
    PortV(Ports), KeyDatV(Ports, 0), AutoSizeP(_AutoSizeP), FFreeKeyId(-1), FreeKeys(0), Pool(StrPool) { PortV.PutAll(-1); }

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 806 of file hash.h.

                                : PortV(Hash.PortV), KeyDatV(Hash.KeyDatV), AutoSizeP(Hash.AutoSizeP),
    FFreeKeyId(Hash.FFreeKeyId), FreeKeys(Hash.FreeKeys), Pool() {
      if (! Hash.Pool.Empty()) { Pool=PStringPool(new TStringPool(*Hash.Pool)); } }

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

TStrHash< TDat, TStringPool, THashFunc >::TStrHash ( TSIn &  SIn, bool  PoolToo = true  )

inline

Definition at line 809 of file hash.h.

: PortV(SIn), KeyDatV(SIn), AutoSizeP(SIn), FFreeKeyId(SIn), FreeKeys(SIn){ SIn.LoadCs(); if (PoolToo) Pool = PStringPool(SIn); }

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 852 of file hash.h.

{ const int KeyId = AddKey(Key); KeyDatV[KeyId].Dat = Dat; return KeyId; }

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 853 of file hash.h.

{ const int KeyId = AddKey(Key.CStr()); KeyDatV[KeyId].Dat = Dat; return KeyId; }

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 854 of file hash.h.

{ const int KeyId = AddKey(Key.CStr()); KeyDatV[KeyId].Dat = Dat; return KeyId; }

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const char *  Key )

inline

Definition at line 855 of file hash.h.

{ return KeyDatV[AddKey(Key)].Dat; }

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TStr &  Key )

inline

Definition at line 856 of file hash.h.

{ return KeyDatV[AddKey(Key.CStr())].Dat; }

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDat ( const TChA &  Key )

inline

Definition at line 857 of file hash.h.

{ return KeyDatV[AddKey(Key.CStr())].Dat; }

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const char *  Key )

inline

Definition at line 858 of file hash.h.

Referenced by TSnap::LoadConnListStr().

{ const int KeyId = AddKey(Key);  return KeyDatV[KeyId].Dat = KeyId; }

Here is the caller graph for this function:

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const TStr &  Key )

inline

Definition at line 859 of file hash.h.

{ const int KeyId = AddKey(Key.CStr());  return KeyDatV[KeyId].Dat = KeyId; }

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::AddDatId ( const TChA &  Key )

inline

Definition at line 860 of file hash.h.

{ const int KeyId = AddKey(Key.CStr());  return KeyDatV[KeyId].Dat = KeyId; }

template<class TDat , class TStringPool , class THashFunc >

int TStrHash< TDat, TStringPool, THashFunc >::AddKey

(

const char *

Key

)

Definition at line 968 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::AddDat(), TStrHash< TInt, TBigStrPool >::AddDatId(), TTableContext::AddStr(), TTable::AddStrVal(), TTable::ChangeContext(), TTable::ColConcat(), TTable::ColConcatConst(), TCoda::DumpMemberships(), TSnap::LoadEdgeListStr(), TAGMUtil::LoadEdgeListStr(), TTimeNENet::LoadEdgeTm(), and TTable::StoreStrCol().

                                                                  {
  if (Pool.Empty()) Pool = TStringPool::New();
  if ((AutoSizeP && KeyDatV.Len() > PortV.Len()) || PortV.Empty()) Resize();
  const int PortN = abs(THashFunc::GetPrimHashCd(Key) % PortV.Len());
  const int HashCd = abs(THashFunc::GetSecHashCd(Key));
  int PrevKeyId = -1;
  int KeyId = PortV[PortN];
  while (KeyId != -1 && ! (KeyDatV[KeyId].HashCd == HashCd && Pool->Cmp(KeyDatV[KeyId].Key, Key) == 0)) {
    PrevKeyId = KeyId;  KeyId = KeyDatV[KeyId].Next; }
  if (KeyId == -1) {
    const int StrId = Pool->AddStr(Key);
    if (FFreeKeyId == -1) {
      KeyId = KeyDatV.Add(THKeyDat(-1, HashCd, StrId));
    } else {
      KeyId = FFreeKeyId;
      FFreeKeyId = KeyDatV[FFreeKeyId].Next;
      FreeKeys--;
      KeyDatV[KeyId] = THKeyDat(-1, HashCd, StrId);
    }
    if (PrevKeyId == -1) PortV[PortN] = KeyId;
    else KeyDatV[PrevKeyId].Next = KeyId;
  }
  return KeyId;
}

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::AddKey ( const TStr &  Key )

inline

Definition at line 850 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::AddKey().

{ return AddKey(Key.CStr()); }

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::AddKey ( const TChA &  Key )

inline

Definition at line 851 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::AddKey().

{ return AddKey(Key.CStr()); }

Here is the caller graph for this function:

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

bool TStrHash< TDat, TStringPool, THashFunc >::Empty ( ) const

inline

Definition at line 841 of file hash.h.

{return ! Len(); }

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

int TStrHash< TDat, TStringPool, THashFunc >::FFirstKeyId ( ) const

inline

Definition at line 906 of file hash.h.

{return 0-1;}

template<class TDat , class TStringPool , class THashFunc >

bool TStrHash< TDat, TStringPool, THashFunc >::FNextKeyId

(

int &

KeyId

)

const

Definition at line 1005 of file hash.h.

                                                                        {
  do KeyId++; while (KeyId < KeyDatV.Len() && KeyDatV[KeyId].HashCd == -1);
  return KeyId < KeyDatV.Len();
}

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 879 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::operator()().

{ return KeyDatV[GetKeyId(Key)].Dat; }

Here is the caller graph for this function:

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 880 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetDat().

{ return GetDat(Key.CStr()); }

Here is the caller graph for this function:

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const char *  Key )

inline

Definition at line 881 of file hash.h.

{ return KeyDatV[GetKeyId(Key)].Dat; }

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

const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const TStr &  Key )

inline

Definition at line 882 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetDat().

{ return GetDat(Key.CStr()); }

Here is the caller graph for this function:

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

const TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDat ( const TChA &  Key )

inline

Definition at line 883 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetDat().

{ return GetDat(Key.CStr()); }

Here is the caller graph for this function:

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::GetDatId ( const int &  KeyId )

inline

Definition at line 884 of file hash.h.

{ return KeyDatV[KeyId].Dat; }

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 885 of file hash.h.

{ return KeyDatV[KeyId].Dat; }

template<class TDat, class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::GetDatKeyPrV

(

TVec< TPair< TDat, TStr > > &

DatKeyPrV

)

const

Definition at line 1046 of file hash.h.

                                                                                                   {
  DatKeyPrV.Gen(Len(), 0);
  TStr Str; TDat Dat;
  int KeyId = FFirstKeyId();
  while (FNextKeyId(KeyId)){
    GetKeyDat(KeyId, Str, Dat);
    DatKeyPrV.Add(TPair<TDat, TStr>(Dat, Str));
  }
}

template<class TDat, class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::GetDatV

(

TVec< TDat > &

DatV

)

const

Definition at line 1027 of file hash.h.

References TVec< TVal, TSizeTy >::Add(), and TVec< TVal, TSizeTy >::Gen().

                                                                           {
  DatV.Gen(Len(), 0);
  int KeyId = FFirstKeyId();
  while (FNextKeyId(KeyId))
    DatV.Add(GetHashKeyDat(KeyId).Dat);
}

Here is the call graph for this function:

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 797 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetKey(), TStrHash< TInt, TBigStrPool >::GetKeyDat(), TStrHash< TInt, TBigStrPool >::GetKeyOfs(), and TStrHash< TInt, TBigStrPool >::operator[]().

                                                        {
    const THKeyDat& KeyDat = KeyDatV[KeyId];  Assert(KeyDat.HashCd != -1);  return KeyDat; }

Here is the caller graph for this function:

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

THKeyDat& TStrHash< TDat, TStringPool, THashFunc >::GetHashKeyDat ( const int &  KeyId )

inlineprivate

Definition at line 799 of file hash.h.

                                            {
    THKeyDat& KeyDat = KeyDatV[KeyId];  Assert(KeyDat.HashCd != -1);  return KeyDat; }

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 893 of file hash.h.

Referenced by TTable::BuildGraph(), TCesna::DisplayAttrs(), TCoda::DumpMemberships(), TCesnaUtil::DumpNIDAttrHToNIDK(), TTable::GetContextKey(), TTableContext::GetStr(), TTable::GetStr(), TTable::GetStrVal(), and TAGMUtil::LoadEdgeListStr().

{ return Pool->GetCStr(GetHashKeyDat(KeyId).Key); }

Here is the caller graph for this function:

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 886 of file hash.h.

{ const THKeyDat& KeyDat = GetHashKeyDat(KeyId); KeyO = KeyDat.Key; Dat = KeyDat.Dat; }

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 887 of file hash.h.

{ const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat; }

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 888 of file hash.h.

{ const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat;}

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 889 of file hash.h.

{ const THKeyDat& KeyDat = GetHashKeyDat(KeyId); Key = KeyFromOfs(KeyDat.Key); Dat = KeyDat.Dat;}

template<class TDat, class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::GetKeyDatPrV

(

TVec< TPair< TStr, TDat > > &

KeyDatPrV

)

const

Definition at line 1035 of file hash.h.

                                                                                                   {
  KeyDatPrV.Gen(Len(), 0);
  TStr Str; TDat Dat;
  int KeyId = FFirstKeyId();
  while (FNextKeyId(KeyId)){
    GetKeyDat(KeyId, Str, Dat);
    KeyDatPrV.Add(TPair<TStr, TDat>(Str, Dat));
  }
}

template<class TDat , class TStringPool , class THashFunc >

int TStrHash< TDat, TStringPool, THashFunc >::GetKeyId

(

const char *

Key

)

const

Definition at line 994 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetDat(), TStrHash< TInt, TBigStrPool >::IsKey(), TStrHash< TInt, TBigStrPool >::IsKeyGetDat(), TAGMUtil::LoadCmtyVV(), TCesnaUtil::LoadNIDAttrHFromNIDKH(), and TTable::StoreStrCol().

                                                                          {
  if (PortV.Empty()) return -1;
  const int PortN = abs(THashFunc::GetPrimHashCd(Key) % PortV.Len());
  const int Hc = abs(THashFunc::GetSecHashCd(Key));
  int KeyId = PortV[PortN];
  while (KeyId != -1 && ! (KeyDatV[KeyId].HashCd == Hc && Pool->Cmp(KeyDatV[KeyId].Key, Key) == 0))
    KeyId = KeyDatV[KeyId].Next;
  return KeyId;
}

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::GetKeyId ( const TStr &  Key ) const

inline

Definition at line 892 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetKeyId().

{ return GetKeyId(Key.CStr()); }

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::GetKeyOfs ( const int &  KeyId ) const

inline

Definition at line 894 of file hash.h.

{ return GetHashKeyDat(KeyId).Key; } // pool string id

template<class TDat , class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::GetKeyV

(

TVec< TStr > &

KeyV

)

const

Definition at line 1011 of file hash.h.

References TVec< TVal, TSizeTy >::Add(), and TVec< TVal, TSizeTy >::Gen().

                                                                           {
  KeyV.Gen(Len(), 0);
  int KeyId = FFirstKeyId();
  while (FNextKeyId(KeyId))
    KeyV.Add(GetKey(KeyId));
}

Here is the call graph for this function:

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

::TSize TStrHash< TDat, TStringPool, THashFunc >::GetMemUsed ( ) const

inline

Definition at line 866 of file hash.h.

Referenced by TTable::GetContextMemUsedKB().

                           {
      int64 MemUsed = sizeof(bool)+2*sizeof(int);
      MemUsed += int64(PortV.Reserved()) * int64(sizeof(TInt));
      for (int KeyDatN = 0; KeyDatN < KeyDatV.Len(); KeyDatN++) {
          MemUsed += int64(2 * sizeof(TInt));
          MemUsed += int64(KeyDatV[KeyDatN].Key.GetMemUsed());
          MemUsed += int64(KeyDatV[KeyDatN].Dat.GetMemUsed());
      }
      // printf("TStrHash: Memory used for hash table: %s\n", TUInt64::GetStr(MemUsed).CStr());
      MemUsed += 8 + Pool->GetMemUsed();
      return ::TSize(MemUsed/1000);
  }

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::GetMxKeyIds ( ) const

inline

Definition at line 846 of file hash.h.

{ return KeyDatV.Len(); }

template<class TDat , class TStringPool , class THashFunc >

uint TStrHash< TDat, TStringPool, THashFunc >::GetNextPrime ( const uint &  Val ) const

private

Definition at line 919 of file hash.h.

References THash< TInt, TInt >::HashPrimes, and THash< TInt, TInt >::HashPrimeT.

                                                                               {
  uint *f = (uint *) TIntH::HashPrimeT, *m, *l = (uint *) TIntH::HashPrimeT + (int) TIntH::HashPrimes;
  int h, len = (int)TIntH::HashPrimes;
  while (len > 0) {
    h = len >> 1;  m = f + h;
    if (*m < Val) { f = m;  f++;  len = len - h - 1; }
    else len = h;
  }
  return f == l ? *(l - 1) : *f;
}

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

PStringPool TStrHash< TDat, TStringPool, THashFunc >::GetPool ( ) const

inline

Definition at line 837 of file hash.h.

{ return Pool; }

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

int TStrHash< TDat, TStringPool, THashFunc >::GetPorts ( ) const

inline

Definition at line 844 of file hash.h.

{ return PortV.Len(); }

template<class TDat , class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::GetStrIdV

(

TIntV &

StrIdV

)

const

Definition at line 1019 of file hash.h.

References TVec< TVal, TSizeTy >::Add(), and TVec< TVal, TSizeTy >::Gen().

                                                                          {
  StrIdV.Gen(Len(), 0);
  int KeyId = FFirstKeyId();
  while (FNextKeyId(KeyId))
    StrIdV.Add(GetKeyOfs(KeyId));
}

Here is the call graph for this function:

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsAutoSize ( ) const

inline

Definition at line 845 of file hash.h.

{ return AutoSizeP; }

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const char *  Key ) const

inline

Definition at line 897 of file hash.h.

Referenced by TStrUtil::CountWords(), TAGMUtil::LoadCmtyVV(), and TCesnaUtil::LoadNIDAttrHFromNIDKH().

{ return GetKeyId(Key) != -1; }

Here is the caller graph for this function:

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const TStr &  Key ) const

inline

Definition at line 898 of file hash.h.

{ return GetKeyId(Key.CStr()) != -1; }

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsKey ( const TChA &  Key ) const

inline

Definition at line 899 of file hash.h.

{ return GetKeyId(Key.CStr()) != -1; }

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 900 of file hash.h.

{ KeyId = GetKeyId(Key); return KeyId != -1; }

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 901 of file hash.h.

{ const int KeyId = GetKeyId(Key); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }

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 902 of file hash.h.

{ const int KeyId = GetKeyId(Key.CStr()); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }

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 903 of file hash.h.

{ const int KeyId = GetKeyId(Key.CStr()); if (KeyId != -1) { Dat = KeyDatV[KeyId].Dat; return true; } else return false; }

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyId ( const int &  KeyId ) const

inline

Definition at line 904 of file hash.h.

Referenced by TCesnaUtil::DumpNIDAttrHToNIDK().

{ return 0 <= KeyId && KeyId < KeyDatV.Len() && KeyDatV[KeyId].HashCd != -1; }

Here is the caller graph for this function:

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

bool TStrHash< TDat, TStringPool, THashFunc >::IsKeyIdEqKeyN ( ) const

inline

Definition at line 847 of file hash.h.

{return ! FreeKeys; }

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 895 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetKeyDat().

{ return Pool->GetCStr(KeyO); }

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::Len ( ) const

inline

Definition at line 842 of file hash.h.

Referenced by TCesna::DisplayAttrs(), TCoda::DumpMemberships(), TStrHash< TInt, TBigStrPool >::Empty(), TAGMUtil::LoadEdgeListStr(), TCesnaUtil::LoadNIDAttrHFromNIDKH(), and TTable::PrintContextSize().

{ return KeyDatV.Len() - FreeKeys; }

Here is the caller graph for this function:

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 811 of file hash.h.

Referenced by TTableContext::Load().

                                            {PortV.Load(SIn); KeyDatV.Load(SIn); AutoSizeP.Load(SIn); FFreeKeyId.Load(SIn);
    FreeKeys.Load(SIn); SIn.LoadCs(); if (PoolToo) Pool = PStringPool(SIn);}

Here is the caller graph for this function:

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

void TStrHash< TDat, TStringPool, THashFunc >::LoadShM ( TShMIn &  ShMIn, bool  SharedPool = true  )

inline

Load hash from shared memory. If shared pool is true load pool from shared memory.

Definition at line 815 of file hash.h.

Referenced by TTableContext::LoadShM().

                                                    {
    PortV.LoadShM(ShMIn);
    KeyDatV.Load(ShMIn);
    AutoSizeP.Load(ShMIn);
    FFreeKeyId.Load(ShMIn);
    FreeKeys.Load(ShMIn);
    ShMIn.LoadCs();
    if (SharedPool) {
      TBool isNull;
      isNull.Load(ShMIn);
      if (!isNull) {
        Pool = TStringPool::LoadShM(ShMIn);
      }
    } else {
      Pool = PStringPool(ShMIn);
    }
  }

Here is the caller graph for this function:

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 864 of file hash.h.

{ return GetDat(Key);}

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 954 of file hash.h.

References TStrHash< TDat, TStringPool, THashFunc >::AutoSizeP, TPt< TRec >::Empty(), TStrHash< TDat, TStringPool, THashFunc >::FFreeKeyId, TStrHash< TDat, TStringPool, THashFunc >::FreeKeys, TStrHash< TDat, TStringPool, THashFunc >::KeyDatV, TStrHash< TDat, TStringPool, THashFunc >::Pool, and TStrHash< TDat, TStringPool, THashFunc >::PortV.

                                                                                                                 {
  if (this != &Hash) {
    PortV = Hash.PortV;
    KeyDatV = Hash.KeyDatV;
    AutoSizeP = Hash.AutoSizeP;
    FFreeKeyId = Hash.FFreeKeyId;
    FreeKeys = Hash.FreeKeys;
    if (! Hash.Pool.Empty()) Pool = PStringPool(new TStringPool(*Hash.Pool));
    else Pool = NULL;
  }
  return *this;
}

Here is the call graph for this function:

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 862 of file hash.h.

{return GetHashKeyDat(KeyId).Dat;}

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

TDat& TStrHash< TDat, TStringPool, THashFunc >::operator[] ( const int &  KeyId )

inline

Definition at line 863 of file hash.h.

{return GetHashKeyDat(KeyId).Dat;}

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

void TStrHash< TDat, TStringPool, THashFunc >::Pack ( )

inline

Definition at line 915 of file hash.h.

Referenced by TAGMUtil::LoadEdgeListStr().

{KeyDatV.Pack();}

Here is the caller graph for this function:

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

int TStrHash< TDat, TStringPool, THashFunc >::Reserved ( ) const

inline

Definition at line 843 of file hash.h.

Referenced by TTable::PrintContextSize().

{ return KeyDatV.Reserved(); }

Here is the caller graph for this function:

template<class TDat , class TStringPool , class THashFunc >

void TStrHash< TDat, TStringPool, THashFunc >::Resize ( )

private

Definition at line 931 of file hash.h.

References THashKeyDat< TKey, TDat >::HashCd, THashKeyDat< TKey, TDat >::Key, and THashKeyDat< TKey, TDat >::Next.

                                                    {
  // resize & initialize port vector
  if (PortV.Empty()) { PortV.Gen(17);  PortV.PutAll(-1); }
  else
  if (AutoSizeP && KeyDatV.Len() > 3 * PortV.Len()) {
    const int NxPrime = GetNextPrime(KeyDatV.Len());
    //printf("%s resize PortV: %d -> %d, Len: %d\n", GetTypeNm(*this).CStr(), PortV.Len(), NxPrime, Len());
    PortV.Gen(NxPrime);  PortV.PutAll(-1); }
  else
    return;
  // rehash keys
  const int NPorts = PortV.Len();
  for (int i = 0; i < KeyDatV.Len(); i++) {
    THKeyDat& KeyDat = KeyDatV[i];
    if (KeyDat.HashCd != -1) {
      const int Port = abs(THashFunc::GetPrimHashCd(Pool->GetCStr(KeyDat.Key)) % NPorts);
      KeyDat.Next = PortV[Port];
      PortV[Port] = i;
    }
  }
}

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 833 of file hash.h.

Referenced by TTableContext::Save().

                                                    { PortV.Save(SOut); KeyDatV.Save(SOut);
    AutoSizeP.Save(SOut); FFreeKeyId.Save(SOut); FreeKeys.Save(SOut); SOut.SaveCs(); if (PoolToo) Pool.Save(SOut); }

Here is the caller graph for this function:

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

void TStrHash< TDat, TStringPool, THashFunc >::SetPool ( const PStringPool &  StrPool )

inline

Definition at line 836 of file hash.h.

{ IAssert(Pool.Empty() || Pool->Empty()); Pool = StrPool; }

Member Data Documentation

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

TBool TStrHash< TDat, TStringPool, THashFunc >::AutoSizeP

private

Definition at line 791 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::IsAutoSize(), TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), and TStrHash< TInt, TBigStrPool >::Save().

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

TInt TStrHash< TDat, TStringPool, THashFunc >::FFreeKeyId

private

Definition at line 792 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), and TStrHash< TInt, TBigStrPool >::Save().

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

TInt TStrHash< TDat, TStringPool, THashFunc >::FreeKeys

private

Definition at line 792 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::IsKeyIdEqKeyN(), TStrHash< TInt, TBigStrPool >::Len(), TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), and TStrHash< TInt, TBigStrPool >::Save().

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

THKeyDatV TStrHash< TDat, TStringPool, THashFunc >::KeyDatV

private

Definition at line 790 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::AddDat(), TStrHash< TInt, TBigStrPool >::AddDatId(), TStrHash< TInt, TBigStrPool >::GetDat(), TStrHash< TInt, TBigStrPool >::GetDatId(), TStrHash< TInt, TBigStrPool >::GetHashKeyDat(), TStrHash< TInt, TBigStrPool >::GetMemUsed(), TStrHash< TInt, TBigStrPool >::GetMxKeyIds(), TStrHash< TInt, TBigStrPool >::IsKeyGetDat(), TStrHash< TInt, TBigStrPool >::IsKeyId(), TStrHash< TInt, TBigStrPool >::Len(), TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), TStrHash< TInt, TBigStrPool >::Pack(), TStrHash< TInt, TBigStrPool >::Reserved(), and TStrHash< TInt, TBigStrPool >::Save().

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

PStringPool TStrHash< TDat, TStringPool, THashFunc >::Pool

private

Definition at line 793 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetKey(), TStrHash< TInt, TBigStrPool >::GetMemUsed(), TStrHash< TInt, TBigStrPool >::GetPool(), TStrHash< TInt, TBigStrPool >::KeyFromOfs(), TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), TStrHash< TInt, TBigStrPool >::Save(), TStrHash< TInt, TBigStrPool >::SetPool(), and TStrHash< TInt, TBigStrPool >::TStrHash().

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

TIntV TStrHash< TDat, TStringPool, THashFunc >::PortV

private

Definition at line 789 of file hash.h.

Referenced by TStrHash< TInt, TBigStrPool >::GetMemUsed(), TStrHash< TInt, TBigStrPool >::GetPorts(), TStrHash< TInt, TBigStrPool >::Load(), TStrHash< TInt, TBigStrPool >::LoadShM(), TStrHash< TDat, TStringPool, THashFunc >::operator=(), TStrHash< TInt, TBigStrPool >::Save(), and TStrHash< TInt, TBigStrPool >::TStrHash().

---

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

• glib-core/hash.h