TBigStrPool Class Reference

#include <hash.h>

Public Member Functions
	TBigStrPool (TSize MxBfLen=0, uint _GrowBy=16 *1024 *1024)
	TBigStrPool (TSIn &SIn, bool LoadCompact=true)
	TBigStrPool (const TBigStrPool &Pool)
	~TBigStrPool ()
void	Save (TSOut &SOut) const
void	Save (const TStr &fileName)
int	GetStrs () const
TSize	Len () const
TSize	Size () const
bool	Empty () const
char *	operator() () const
TBigStrPool &	operator= (const TBigStrPool &Pool)
::TSize	GetMemUsed ()
int	AddStr (const char *Str, uint Len)
int	AddStr (const char *Str)
int	AddStr (const TStr &Str)
TStr	GetStr (const int &StrId) const
const char *	GetCStr (const int &StrId) const
TStr	GetStrFromOffset (const TSize &Offset) const
const char *	GetCStrFromOffset (const TSize &Offset) const
void	Clr (bool DoDel=false)
int	Cmp (const int &StrId, const char *Str) const
int	GetPrimHashCd (const int &StrId)
int	GetSecHashCd (const int &StrId)

Static Public Member Functions
static PBigStrPool	New (TSize _MxBfLen=0, uint _GrowBy=16 *1024 *1024)
static PBigStrPool	New (TSIn &SIn)
static PBigStrPool	New (const TStr &fileName)
static PBigStrPool	Load (TSIn &SIn, bool LoadCompacted=true)
static PBigStrPool	LoadShM (TShMIn &ShMIn, bool LoadCompact=true)
	Load the string pool with the buffer backed by shared memory. More...
static int	GetPrimHashCd (const char *CStr)
static int	GetSecHashCd (const char *CStr)

Private Member Functions
void	Resize (TSize _MxBfL)
void	LoadPoolShM (TShMIn &ShMIn, bool LoadCompact=true)

Private Attributes
TCRef	CRef
TSize	MxBfL
TSize	BfL
uint	GrowBy
char *	Bf
TVec< TSize >	IdOffV
bool	IsShM

Friends
class	TPt< TBigStrPool >

Detailed Description

Definition at line 711 of file hash.h.

Constructor & Destructor Documentation

TBigStrPool::TBigStrPool	(	TSize	MxBfLen = 0,
		uint	_GrowBy = 16*1024*1024
	)

Definition at line 23 of file hash.cpp.

                                                    : MxBfL(MxBfLen), BfL(0), GrowBy(_GrowBy), Bf(0), IsShM(false) {
  //IAssert(MxBfL >= 0); IAssert(GrowBy >= 0);
  if (MxBfL > 0) { Bf = (char *) malloc(MxBfL);  IAssert(Bf); }
  AddStr(""); // add empty string
}

TBigStrPool::TBigStrPool	(	TSIn &	SIn,
		bool	LoadCompact = true
	)

Definition at line 29 of file hash.cpp.

                                                    : MxBfL(0), BfL(0), GrowBy(0), Bf(0), IsShM(false) {
  uint64 Tmp;
  SIn.Load(Tmp); IAssert(Tmp <= uint64(TSizeMx)); MxBfL=TSize(Tmp);
  SIn.Load(Tmp); IAssert(Tmp <= uint64(TSizeMx)); BfL=TSize(Tmp);
  SIn.Load(GrowBy);
  IAssert(MxBfL >= BfL);  IAssert(BfL >= 0);  IAssert(GrowBy >= 0);
  if (LoadCompact) MxBfL = BfL;
  if (MxBfL > 0) { Bf = (char *) malloc(MxBfL); IAssert(Bf); }
  if (BfL > 0) { SIn.LoadBf(Bf, BfL); }
  SIn.LoadCs();
  int NStr=0;  SIn.Load(NStr);
  IdOffV.Gen(NStr, 0);
  for (int i = 0; i < NStr; i++) {
    SIn.Load(Tmp);
    IAssert(Tmp <= uint64(TSizeMx));
    IdOffV.Add(TSize(Tmp));
  }
}

TBigStrPool::TBigStrPool ( const TBigStrPool &  Pool )

inline

Definition at line 724 of file hash.h.

                                       : MxBfL(Pool.MxBfL), BfL(Pool.BfL), GrowBy(Pool.GrowBy) {
    Bf = (char *) malloc(Pool.MxBfL); IAssert(Bf); memcpy(Bf, Pool.Bf, Pool.BfL); }

TBigStrPool::~TBigStrPool ( )

inline

Definition at line 726 of file hash.h.

{ if (Bf && !IsShM) free(Bf); else IAssert(MxBfL == 0 || IsShM);  MxBfL = 0; BfL = 0; }

Member Function Documentation

int TBigStrPool::AddStr	(	const char *	Str,
		uint	Len
	)

Definition at line 95 of file hash.cpp.

                                                 {
  IAssertR(Len > 0, "String too short (lenght includes the null character)");  //J: if (! Len) return -1;
  Assert(Str);  Assert(Len > 0);
  if (Len == 1 && IdOffV.Len() > 0) { return 0; } // empty string
  if (BfL + Len > MxBfL) { Resize(BfL + Len); }
  memcpy(Bf + BfL, Str, Len);
  TSize Pos = BfL;  BfL += Len;  
  IdOffV.Add(Pos);
  return IdOffV.Len()-1;
}

int TBigStrPool::AddStr ( const char *  Str )

inline

Definition at line 752 of file hash.h.

{ return AddStr(Str, uint(strlen(Str)) + 1); }

int TBigStrPool::AddStr ( const TStr &  Str )

inline

Definition at line 753 of file hash.h.

{ return AddStr(Str.CStr(), Str.Len() + 1); }

void TBigStrPool::Clr ( bool  DoDel = false )

inline

Definition at line 765 of file hash.h.

                               {
    BfL = 0; if (DoDel && Bf) {if (!IsShM) { free(Bf);} Bf = 0; MxBfL = 0;}}

int TBigStrPool::Cmp ( const int &  StrId, const char *  Str  ) const

inline

Definition at line 767 of file hash.h.

                                                   { Assert(StrId < GetStrs());
    if (StrId != 0) return strcmp(Bf + (TSize)IdOffV[StrId], Str); else return strcmp("", Str); }

bool TBigStrPool::Empty ( ) const

inline

Definition at line 744 of file hash.h.

{ return ! Len(); }

const char* TBigStrPool::GetCStr ( const int &  StrId ) const

inline

Definition at line 757 of file hash.h.

                                              { Assert(StrId < GetStrs());
    if (StrId == 0) return TStr::GetNullStr().CStr(); else return (Bf + (TSize)IdOffV[StrId]); }

const char* TBigStrPool::GetCStrFromOffset ( const TSize &  Offset ) const

inline

Definition at line 762 of file hash.h.

                                                           { Assert(Offset < BfL);
    if (Offset == 0) return TStr::GetNullStr().CStr(); else return Bf + Offset; }

::TSize TBigStrPool::GetMemUsed ( )

inline

Definition at line 747 of file hash.h.

                    {
        return 4 * sizeof(int) + IdOffV.GetMemUsed() + MxBfL;
  }

int TBigStrPool::GetPrimHashCd ( const char *  CStr )

static

Definition at line 106 of file hash.cpp.

                                               {
  return TStrHashF_DJB::GetPrimHashCd(CStr);
}

int TBigStrPool::GetPrimHashCd ( const int &  StrId )

inline

Definition at line 772 of file hash.h.

                                      { Assert(StrId < GetStrs());
    if (StrId != 0) return GetPrimHashCd(Bf + (TSize)IdOffV[StrId]); else return GetPrimHashCd(""); }

int TBigStrPool::GetSecHashCd ( const char *  CStr )

static

Definition at line 110 of file hash.cpp.

                                              {
  return TStrHashF_DJB::GetSecHashCd(CStr);
}

int TBigStrPool::GetSecHashCd ( const int &  StrId )

inline

Definition at line 774 of file hash.h.

                                     { Assert(StrId < GetStrs());
    if (StrId != 0) return GetSecHashCd(Bf + (TSize)IdOffV[StrId]); else return GetSecHashCd(""); }

TStr TBigStrPool::GetStr ( const int &  StrId ) const

inline

Definition at line 755 of file hash.h.

                                      { Assert(StrId < GetStrs());
    if (StrId == 0) return TStr::GetNullStr(); else return TStr(Bf + (TSize)IdOffV[StrId]); }

TStr TBigStrPool::GetStrFromOffset ( const TSize &  Offset ) const

inline

Definition at line 760 of file hash.h.

                                                   { Assert(Offset < BfL);
    if (Offset == 0) return TStr::GetNullStr(); else return TStr(Bf + Offset); }

int TBigStrPool::GetStrs ( ) const

inline

Definition at line 741 of file hash.h.

{ return IdOffV.Len(); }

TSize TBigStrPool::Len ( ) const

inline

Definition at line 742 of file hash.h.

{ return BfL; }

static PBigStrPool TBigStrPool::Load ( TSIn &  SIn, bool  LoadCompacted = true  )

inlinestatic

Definition at line 731 of file hash.h.

{ return PBigStrPool(new TBigStrPool(SIn, LoadCompacted)); }

void TBigStrPool::LoadPoolShM ( TShMIn &  ShMIn, bool  LoadCompact = true  )

private

Definition at line 48 of file hash.cpp.

                                                             {
  uint64 Tmp;
  ShMIn.Load(Tmp); IAssert(Tmp <= uint64(TSizeMx)); MxBfL=TSize(Tmp);
  ShMIn.Load(Tmp); IAssert(Tmp <= uint64(TSizeMx)); BfL=TSize(Tmp);
  ShMIn.Load(GrowBy); IAssert(MxBfL >= BfL);  IAssert(BfL >= 0);  IAssert(GrowBy >= 0);
  IsShM = true;
  if (LoadCompact) {
    MxBfL = BfL;
    Bf = (char*)(ShMIn.AdvanceCursor(BfL));
    IsShM = true;
  } else {
    if (MxBfL > 0) { Bf = (char *) malloc(MxBfL); IAssert(Bf); IsShM = false;}
    if (BfL > 0) { ShMIn.LoadBf(Bf, BfL); }
    IsShM = false;
  }
  ShMIn.LoadCs();
  int NStr=0;
  ShMIn.Load(NStr);
  IdOffV.Gen(NStr, 0);
  for (int i = 0; i < NStr; i++) {
    ShMIn.Load(Tmp);
    IAssert(Tmp <= uint64(TSizeMx));
    IdOffV.Add(TSize(Tmp));
  }
}

static PBigStrPool TBigStrPool::LoadShM ( TShMIn &  ShMIn, bool  LoadCompact = true  )

inlinestatic

Load the string pool with the buffer backed by shared memory.

Definition at line 733 of file hash.h.

                                                                     {
    TBigStrPool* StrPool = new TBigStrPool();
    StrPool->LoadPoolShM(ShMIn, LoadCompact);
    return PBigStrPool(StrPool);
  }

static PBigStrPool TBigStrPool::New ( TSize  _MxBfLen = 0, uint  _GrowBy = 16*1024*1024  )

inlinestatic

Definition at line 728 of file hash.h.

{ return PBigStrPool(new TBigStrPool(_MxBfLen, _GrowBy)); }

static PBigStrPool TBigStrPool::New ( TSIn &  SIn )

inlinestatic

Definition at line 729 of file hash.h.

{ return new TBigStrPool(SIn); }

static PBigStrPool TBigStrPool::New ( const TStr &  fileName )

inlinestatic

Definition at line 730 of file hash.h.

{ PSIn SIn = TFIn::New(fileName); return new TBigStrPool(*SIn); }

char* TBigStrPool::operator() ( ) const

inline

Definition at line 745 of file hash.h.

{ return Bf; }

TBigStrPool & TBigStrPool::operator=

(

const TBigStrPool &

Pool

)

Definition at line 85 of file hash.cpp.

                                                             {
  if (this != &Pool) {
    GrowBy = Pool.GrowBy;  MxBfL = Pool.MxBfL;  BfL = Pool.BfL;
    if (Bf) free(Bf); else IAssert(MxBfL == 0);
    Bf = (char *) malloc(MxBfL);  IAssert(Bf);  memcpy(Bf, Pool.Bf, BfL);
  }
  return *this;
}

void TBigStrPool::Resize ( TSize  _MxBfL )

private

Definition at line 3 of file hash.cpp.

                                     {
  TSize newSize = MxBfL;
  while (newSize < _MxBfL) {
    if (newSize >= GrowBy && GrowBy > 0) newSize += GrowBy;
    else if (newSize > 0) newSize *= 2;
    else newSize = TInt::GetMn(GrowBy, 1024);
  }
  if (newSize > MxBfL) {
    if (IsShM) {
      Bf = (char*) malloc(newSize);
      IsShM = false;
    } else {
      Bf = (char *) realloc(Bf, newSize);
    }
    IAssertR(Bf, TStr::Fmt("old Bf size: %u, new size: %u", MxBfL, newSize).CStr());
    MxBfL = newSize;
  }
  IAssert(MxBfL >= _MxBfL);
}

void TBigStrPool::Save

(

TSOut &

SOut

)

const

Definition at line 75 of file hash.cpp.

                                        {
  SOut.Save(uint64(MxBfL));  SOut.Save(uint64(BfL));  SOut.Save(GrowBy);
  if (BfL > 0) { SOut.SaveBf(Bf, BfL); }
  SOut.SaveCs();
  SOut.Save(IdOffV.Len());
  for (int i = 0; i < IdOffV.Len(); i++) {
    SOut.Save(uint64(IdOffV[i])); 
  }
}

void TBigStrPool::Save ( const TStr &  fileName )

inline

Definition at line 739 of file hash.h.

{ TFOut FOut(fileName); Save(FOut); }

TSize TBigStrPool::Size ( ) const

inline

Definition at line 743 of file hash.h.

{ return MxBfL; }

Friends And Related Function Documentation

friend class TPt< TBigStrPool >

friend

Definition at line 711 of file hash.h.

Member Data Documentation

char* TBigStrPool::Bf

private

Definition at line 715 of file hash.h.

TSize TBigStrPool::BfL

private

Definition at line 713 of file hash.h.

TCRef TBigStrPool::CRef

private

Definition at line 711 of file hash.h.

uint TBigStrPool::GrowBy

private

Definition at line 714 of file hash.h.

TVec<TSize> TBigStrPool::IdOffV

private

Definition at line 716 of file hash.h.

bool TBigStrPool::IsShM

private

Definition at line 717 of file hash.h.

TSize TBigStrPool::MxBfL

private

Definition at line 713 of file hash.h.

---

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

• glib-core/hash.h
• glib-core/hash.cpp