#include <shash.h>

Public Types
typedef TSparseGroup< TVal, GroupSize >	TSGroup

typedef TSparseTableI< TVal, GroupSize >	TIter

Public Member Functions
	TSparseTable (const int &MaxVals=0)

	TSparseTable (const TSparseTable &ST)

	TSparseTable (TSIn &SIn)

void	Load (TSIn &SIn)

void	Save (TSOut &SOut) const

TSparseTable &	operator= (const TSparseTable &ST)

bool	operator== (const TSparseTable &ST) const

bool	operator< (const TSparseTable &ST) const

::TSize	GetMemUsed () const

TIter	BegI () const

TIter	EndI () const

TIter	GetI (const int &ValN) const

int	Len () const

int	Reserved () const

int	Groups () const

bool	Empty () const

uint	GetDiskSz () const

void	Clr (const bool &DoDel=true)

void	Reserve (const int NewVals)

void	Resize (const int &NewVals)

void	Swap (TSparseTable &ST)

bool	IsEmpty (const int &ValN) const

const TVal &	Get (const int &ValN) const

TVal &	Set (const int &ValN, const TVal &Val)

TVal &	Set (const int &ValN)

void	Del (const int &ValN)

TSGroup &	GetGroup (const int &GroupN)

const TSGroup &	GetGroup (const int &GroupN) const

Private Member Functions
int	PosInGroup (const int &ValN) const

int	GroupNum (const int &ValN) const

const TSGroup &	GetGrp1 (const int &ValN) const

TSGroup &	GetGrp1 (const int &ValN)

Static Private Member Functions
static int	GetGroups (const int &Vals)

Private Attributes
TInt	MxVals

TInt	Vals

TVec< TSGroup >	GroupV

Detailed Description

template<class TVal, uint16 GroupSize = 48>
class TSparseTable< TVal, GroupSize >

Definition at line 310 of file shash.h.

Member Typedef Documentation

template<class TVal, uint16 GroupSize = 48>

typedef TSparseTableI<TVal, GroupSize> TSparseTable< TVal, GroupSize >::TIter

Definition at line 313 of file shash.h.

template<class TVal, uint16 GroupSize = 48>

typedef TSparseGroup<TVal, GroupSize> TSparseTable< TVal, GroupSize >::TSGroup

Definition at line 312 of file shash.h.

Constructor & Destructor Documentation

template<class TVal, uint16 GroupSize = 48>

TSparseTable< TVal, GroupSize >::TSparseTable ( const int & MaxVals = 0 )

inline

Definition at line 324 of file shash.h.

324 : MxVals(MaxVals),

325 Vals(0), GroupV(GetGroups(MaxVals), GetGroups(MaxVals)) { }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::GetGroups

static int GetGroups(const int &Vals)

Definition: shash.h:318

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize = 48>

TSparseTable< TVal, GroupSize >::TSparseTable ( const TSparseTable< TVal, GroupSize > & ST )

inline

Definition at line 326 of file shash.h.

326 : MxVals(ST.MxVals), Vals(ST.Vals), GroupV(ST.GroupV) { }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize = 48>

TSparseTable< TVal, GroupSize >::TSparseTable ( TSIn & SIn )

inline

Definition at line 327 of file shash.h.

327 : MxVals(SIn), Vals(SIn), GroupV(SIn) { }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

Member Function Documentation

template<class TVal, uint16 GroupSize = 48>

TIter TSparseTable< TVal, GroupSize >::BegI ( ) const

inline

Definition at line 336 of file shash.h.

                      {
     if (Len() > 0) { int B = 0;
       while (B < Groups() && GroupV[B].Empty()) { B++; }
       return TIter(GroupV.BegI(), GroupV.BegI()+B, GroupV.EndI()); }
     return TIter(GroupV.BegI(), GroupV.EndI(), GroupV.EndI());
   }

template<class TVal , uint16 GroupSize>

void TSparseTable< TVal, GroupSize >::Clr ( const bool & DoDel = true )

Definition at line 392 of file shash.h.

                                                          {
   if (! DoDel) {
     for (int g = 0; g < GroupV.Len(); g++) GroupV[g].Clr(false);
   } else {
     MxVals = 0;
     GroupV.Clr(true);
   }
   Vals = 0;
 }

template<class TVal , uint16 GroupSize>

void TSparseTable< TVal, GroupSize >::Del ( const int & ValN )

Definition at line 440 of file shash.h.

                                                        {
   Assert(ValN < MxVals);
   TSGroup& Group = GetGrp1(ValN);
   const int OldVals = Group.Len();
   Group.Del(PosInGroup(ValN));
   Vals += Group.Len() - OldVals;
 }

template<class TVal, uint16 GroupSize = 48>

bool TSparseTable< TVal, GroupSize >::Empty ( ) const

inline

Definition at line 352 of file shash.h.

352 { return Vals == 0; }

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize = 48>

TIter TSparseTable< TVal, GroupSize >::EndI ( ) const

inline

Definition at line 342 of file shash.h.

342 { return TIter(GroupV.BegI(), GroupV.EndI(), GroupV.EndI()); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::TIter

TSparseTableI< TVal, GroupSize > TIter

Definition: shash.h:313

template<class TVal, uint16 GroupSize = 48>

const TVal& TSparseTable< TVal, GroupSize >::Get ( const int & ValN ) const

inline

Definition at line 362 of file shash.h.

362 { return GroupV[GroupNum(ValN)].Get(PosInGroup(ValN)); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::GroupNum

int GroupNum(const int &ValN) const

Definition: shash.h:320

TSparseTable::PosInGroup

int PosInGroup(const int &ValN) const

Definition: shash.h:319

template<class TVal, uint16 GroupSize = 48>

uint TSparseTable< TVal, GroupSize >::GetDiskSz ( ) const

inline

Definition at line 353 of file shash.h.

353 {

354 return sizeof(TInt)*4 + ((GroupSize+16)/8)*Groups() + sizeof(TVal)*Vals; }

TSparseTable::Groups

int Groups() const

Definition: shash.h:351

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

TInt

Definition: dt.h:1134

template<class TVal, uint16 GroupSize = 48>

TSGroup& TSparseTable< TVal, GroupSize >::GetGroup ( const int & GroupN )

inline

Definition at line 367 of file shash.h.

367 { return GroupV[GroupN]; }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

template<class TVal, uint16 GroupSize = 48>

const TSGroup& TSparseTable< TVal, GroupSize >::GetGroup ( const int & GroupN ) const

inline

Definition at line 368 of file shash.h.

368 { return GroupV[GroupN]; }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

template<class TVal, uint16 GroupSize = 48>

static int TSparseTable< TVal, GroupSize >::GetGroups ( const int & Vals )

inlinestaticprivate

Definition at line 318 of file shash.h.

318 { return Vals == 0 ? 0 : ((Vals-1) / GroupSize) + 1; }

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize = 48>

const TSGroup& TSparseTable< TVal, GroupSize >::GetGrp1 ( const int & ValN ) const

inlineprivate

Definition at line 321 of file shash.h.

321 { return GroupV[GroupNum(ValN)]; }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::GroupNum

int GroupNum(const int &ValN) const

Definition: shash.h:320

template<class TVal, uint16 GroupSize = 48>

TSGroup& TSparseTable< TVal, GroupSize >::GetGrp1 ( const int & ValN )

inlineprivate

Definition at line 322 of file shash.h.

322 { return GroupV[GroupNum(ValN)]; }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::GroupNum

int GroupNum(const int &ValN) const

Definition: shash.h:320

template<class TVal, uint16 GroupSize = 48>

TIter TSparseTable< TVal, GroupSize >::GetI ( const int & ValN ) const

inline

Definition at line 343 of file shash.h.

                                     { Assert(! IsEmpty(ValN));
     typedef typename TVec<TSGroup>::TIter TVIter;
     const TVIter GI = GroupV.GetI(GroupNum(ValN));
     return TIter(GroupV.BegI(), GI, GroupV.EndI(), GI->PosToOffset(PosInGroup(ValN)));
   }

template<class TVal, uint16 GroupSize = 48>

::TSize TSparseTable< TVal, GroupSize >::GetMemUsed ( ) const

inline

Definition at line 334 of file shash.h.

334 { return 2*sizeof(TInt)+Vals*sizeof(TVal)+GroupV.GetMemUsed(); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

TInt

Definition: dt.h:1134

template<class TVal, uint16 GroupSize = 48>

int TSparseTable< TVal, GroupSize >::GroupNum ( const int & ValN ) const

inlineprivate

Definition at line 320 of file shash.h.

320 { return ValN / GroupSize; }

template<class TVal, uint16 GroupSize = 48>

int TSparseTable< TVal, GroupSize >::Groups ( ) const

inline

Definition at line 351 of file shash.h.

351 { return GroupV.Len(); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

template<class TVal, uint16 GroupSize = 48>

bool TSparseTable< TVal, GroupSize >::IsEmpty ( const int & ValN ) const

inline

Definition at line 361 of file shash.h.

361 { return GroupV[GroupNum(ValN)].IsEmpty(PosInGroup(ValN)); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::GroupNum

int GroupNum(const int &ValN) const

Definition: shash.h:320

TSparseTable::PosInGroup

int PosInGroup(const int &ValN) const

Definition: shash.h:319

template<class TVal, uint16 GroupSize = 48>

int TSparseTable< TVal, GroupSize >::Len ( ) const

inline

Definition at line 349 of file shash.h.

349 { return Vals; }

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize = 48>

void TSparseTable< TVal, GroupSize >::Load ( TSIn & SIn )

inline

Definition at line 328 of file shash.h.

328 { MxVals.Load(SIn); Vals.Load(SIn); GroupV.Load(SIn); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

TInt::Load

void Load(TSIn &SIn)

Definition: dt.h:1149

template<class TVal , uint16 GroupSize>

bool TSparseTable< TVal, GroupSize >::operator< ( const TSparseTable< TVal, GroupSize > & ST ) const

Definition at line 387 of file shash.h.

                                                                             {
   return Vals < ST.Vals || (Vals == ST.Vals && GroupV < ST.GroupV);
 }

template<class TVal , uint16 GroupSize>

TSparseTable< TVal, GroupSize > & TSparseTable< TVal, GroupSize >::operator= ( const TSparseTable< TVal, GroupSize > & ST )

Definition at line 372 of file shash.h.

                                                                                                 {
   if (this != &ST) {
     MxVals = ST.MxVals;
     Vals = ST.Vals;
     GroupV = ST.GroupV;
   }
   return *this;
 }

template<class TVal , uint16 GroupSize>

bool TSparseTable< TVal, GroupSize >::operator== ( const TSparseTable< TVal, GroupSize > & ST ) const

Definition at line 382 of file shash.h.

                                                                              {
   return Vals == ST.Vals && MxVals == ST.MxVals && GroupV == ST.GroupV;
 }

template<class TVal, uint16 GroupSize = 48>

int TSparseTable< TVal, GroupSize >::PosInGroup ( const int & ValN ) const

inlineprivate

Definition at line 319 of file shash.h.

319 { return ValN % GroupSize; }

template<class TVal, uint16 GroupSize = 48>

void TSparseTable< TVal, GroupSize >::Reserve ( const int NewVals )

inline

Definition at line 357 of file shash.h.

357 { Resize(NewVals); }

TSparseTable::Resize

void Resize(const int &NewVals)

Definition: shash.h:403

template<class TVal, uint16 GroupSize = 48>

int TSparseTable< TVal, GroupSize >::Reserved ( ) const

inline

Definition at line 350 of file shash.h.

350 { return MxVals; }

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

template<class TVal , uint16 GroupSize>

void TSparseTable< TVal, GroupSize >::Resize ( const int & NewVals )

Definition at line 403 of file shash.h.

                                                              {
   // only allow to grow
   if (NewVals > MxVals) {
     const int Groups = GetGroups(NewVals);
     GroupV.Reserve(Groups, Groups);
     MxVals = NewVals;
   }
 }

template<class TVal, uint16 GroupSize = 48>

void TSparseTable< TVal, GroupSize >::Save ( TSOut & SOut ) const

inline

Definition at line 329 of file shash.h.

329 { MxVals.Save(SOut); Vals.Save(SOut); GroupV.Save(SOut); }

TSparseTable::GroupV

TVec< TSGroup > GroupV

Definition: shash.h:316

TInt::Save

void Save(TSOut &SOut) const

Definition: dt.h:1150

TSparseTable::MxVals

TInt MxVals

Definition: shash.h:315

TSparseTable::Vals

TInt Vals

Definition: shash.h:315

template<class TVal, uint16 GroupSize>

TVal & TSparseTable< TVal, GroupSize >::Set	(	const int &	ValN,
		const TVal &	Val
	)

Definition at line 420 of file shash.h.

                                                                          {
   Assert(ValN < MxVals);
   TSGroup& Group = GetGrp1(ValN);
   const int OldVals = Group.Len();
   TVal& ValRef = Group.Set(PosInGroup(ValN), Val);
   Vals += Group.Len() - OldVals;
   return ValRef;
 }

template<class TVal, uint16 GroupSize>

TVal & TSparseTable< TVal, GroupSize >::Set ( const int & ValN )

Definition at line 430 of file shash.h.

                                                         {
   Assert(ValN < MxVals);
   TSGroup& Group = GetGrp1(ValN);
   const int OldVals = Group.Len();
   TVal& ValRef = Group.Set(PosInGroup(ValN));
   Vals += Group.Len() - OldVals;
   return ValRef;
 }

template<class TVal , uint16 GroupSize>

void TSparseTable< TVal, GroupSize >::Swap ( TSparseTable< TVal, GroupSize > & ST )

Definition at line 413 of file shash.h.

                                                          {
   ::Swap(MxVals, ST.MxVals);
   ::Swap(Vals, ST.Vals);
   GroupV.Swap(ST.GroupV);
 }

Member Data Documentation

template<class TVal, uint16 GroupSize = 48>

TVec<TSGroup> TSparseTable< TVal, GroupSize >::GroupV

private

Definition at line 316 of file shash.h.

template<class TVal, uint16 GroupSize = 48>

TInt TSparseTable< TVal, GroupSize >::MxVals

private

Definition at line 315 of file shash.h.

template<class TVal, uint16 GroupSize = 48>

TInt TSparseTable< TVal, GroupSize >::Vals

private

Definition at line 315 of file shash.h.

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

glib-core/shash.h

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

template<class TVal, uint16 GroupSize = 48> class TSparseTable< TVal, GroupSize >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class TVal, uint16 GroupSize = 48>
class TSparseTable< TVal, GroupSize >