#include <ds.h>

Public Types
typedef TPt< TVecPool< TVal > >	PVecPool

typedef TVec< TVal >	TValV

Public Member Functions
	TVecPool (const ::TSize &ExpectVals=0, const ::TSize &_GrowBy=1000000, const bool &_FastCopy=false, const TVal &_EmptyVal=TVal())

	TVecPool (const TVecPool &Pool)

	TVecPool (TSIn &SIn)

	~TVecPool ()

void	Save (TSOut &SOut) const

TVecPool &	operator= (const TVecPool &Pool)

::TSize	GetVals () const

::TSize	GetVecs () const

bool	IsVId (const int &VId) const

::TSize	Reserved () const

void	Reserve (const ::TSize &MxVals)

const TVal &	GetEmptyVal () const

void	SetEmptyVal (const TVal &_EmptyVal)

::TSize	GetMemUsed () const

int	AddV (const TValV &ValV)

int	AddEmptyV (const int &ValVLen)

uint	GetVLen (const int &VId) const

TVal *	GetValVPt (const int &VId) const

void	GetV (const int &VId, TValV &ValV) const

void	PutV (const int &VId, const TValV &ValV)

void	CompactPool (const TVal &DelVal)

void	ShuffleAll (TRnd &Rnd=TInt::Rnd)

void	Clr (bool DoDel=true)

void	PutAll (const TVal &Val)

Static Public Member Functions
static PVecPool	New (const ::TSize &ExpectVals=0, const ::TSize &GrowBy=1000000, const bool &FastCopy=false)

static PVecPool	Load (TSIn &SIn)

static PVecPool	Load (const TStr &FNm)

Private Member Functions
void	Resize (const ::TSize &_MxVals)

Private Attributes
TCRef	CRef

TBool	FastCopy

::TSize	GrowBy

::TSize	MxVals

::TSize	Vals

TVal	EmptyVal

TVal *	ValBf

TVec< ::TSize >	IdToOffV

Friends
class	TPt< TVecPool< TVal > >

Detailed Description

template<class TVal>
class TGLib_OLD::TVecPool< TVal >

Definition at line 1873 of file ds.h.

Member Typedef Documentation

template<class TVal >

typedef TPt<TVecPool<TVal> > TGLib_OLD::TVecPool< TVal >::PVecPool

Definition at line 1875 of file ds.h.

template<class TVal >

typedef TVec<TVal> TGLib_OLD::TVecPool< TVal >::TValV

Definition at line 1876 of file ds.h.

Constructor & Destructor Documentation

template<class TVal >

TVecPool< TVal >::TVecPool	(	const ::TSize &	ExpectVals = `0`,
		const ::TSize &	_GrowBy = `1000000`,
		const bool &	_FastCopy = `false`,
		const TVal &	_EmptyVal = `TVal()`
	)

Definition at line 1972 of file ds.h.

                                                                                                                     :
   GrowBy(_GrowBy), MxVals(0), Vals(0), EmptyVal(_EmptyVal), ValBf(NULL) {
   IdToOffV.Add(0);
   Resize(ExpectVals);
 }

template<class TVal >

TVecPool< TVal >::TVecPool ( const TVecPool< TVal > & Pool )

Definition at line 1979 of file ds.h.

                                             :
   FastCopy(Pool.FastCopy), GrowBy(Pool.GrowBy),
   MxVals(Pool.MxVals), Vals(Pool.Vals), EmptyVal(Pool.EmptyVal), IdToOffV(Pool.IdToOffV) {
   try { ValBf = new TVal [MxVals]; }
   catch (std::exception Ex) { FailR(TStr::Fmt("TVecPool::TVecPool: %s, MxVals: %d", Ex.what(), MxVals).CStr()); }
   IAssert(ValBf != NULL);
   if (FastCopy) {
     memcpy(ValBf, Pool.ValBf, MxVals*sizeof(TVal)); }
   else {
     for (TSize ValN = 0; ValN < MxVals; ValN++){ ValBf[ValN] = Pool.ValBf[ValN]; } }
 }

template<class TVal >

TVecPool< TVal >::TVecPool ( TSIn & SIn )

Definition at line 1992 of file ds.h.

                                  :
   FastCopy(SIn) {
   uint64 _GrowBy, _MxVals, _Vals;
   SIn.Load(_GrowBy); SIn.Load(_MxVals);  SIn.Load(_Vals);
   IAssert(_GrowBy<TSizeMx && _MxVals<TSizeMx && _Vals<TSizeMx);
   GrowBy=TSize(_GrowBy);  MxVals=TSize(_Vals);  Vals=TSize(_Vals); //note MxVals==Vals
   EmptyVal = TVal(SIn);
   if (MxVals==0) { ValBf = NULL; } else { ValBf = new TVal [MxVals]; }
   for (TSize ValN = 0; ValN < Vals; ValN++) { ValBf[ValN] = TVal(SIn); }
   { TInt MxVals(SIn), Vals(SIn);
   IdToOffV.Gen(Vals);
   for (int ValN = 0; ValN < Vals; ValN++) {
     uint64 Offset;  SIn.Load(Offset);  IAssert(Offset < TSizeMx);
     IdToOffV[ValN]=TSize(Offset);
   } }
 }

template<class TVal >

TGLib_OLD::TVecPool< TVal >::~TVecPool ( )

inline

Definition at line 1890 of file ds.h.

1890 { if (ValBf != NULL) { delete [] ValBf; } ValBf=NULL; }

TGLib_OLD::TVecPool::ValBf

TVal * ValBf

Definition: ds.h:1882

Member Function Documentation

template<class TVal >

int TVecPool< TVal >::AddEmptyV ( const int & ValVLen )

Definition at line 2054 of file ds.h.

                                                 {
   if (ValVLen==0){return 0;}
   if (MxVals < Vals+ValVLen){Resize(Vals+MAX(TSize(ValVLen), GrowBy)); }
   Vals+=ValVLen; IdToOffV.Add(Vals);
   return IdToOffV.Len()-1;
 }

template<class TVal >

int TVecPool< TVal >::AddV ( const TValV & ValV )

Definition at line 2043 of file ds.h.

                                           {
   const ::TSize ValVLen = ValV.Len();
   if (ValVLen == 0) { return 0; }
   if (MxVals < Vals+ValVLen) { Resize(Vals+MAX(ValVLen, GrowBy)); }
   if (FastCopy) { memcpy(ValBf+Vals, ValV.BegI(), sizeof(TVal)*ValV.Len()); }
   else { for (uint ValN=0; ValN < ValVLen; ValN++) { ValBf[Vals+ValN]=ValV[ValN]; } }
   Vals+=ValVLen;  IdToOffV.Add(Vals);
   return IdToOffV.Len()-1;
 }

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::Clr ( bool DoDel = true )

inline

Definition at line 1933 of file ds.h.

                               {
     IdToOffV.Clr(DoDel);  MxVals=0;  Vals=0;
     if (DoDel && ValBf!=NULL) { delete [] ValBf; ValBf=NULL;}
     if (! DoDel) { PutAll(EmptyVal); }
   }

template<class TVal >

void TVecPool< TVal >::CompactPool ( const TVal & DelVal )

Definition at line 2064 of file ds.h.

                                                    {
   ::TSize TotalDel=0, NDel=0;
   // printf("Compacting %d vectors\n", IdToOffV.Len());
   for (int vid = 1; vid < IdToOffV.Len(); vid++) {
     // if (vid % 10000000 == 0) { printf(" %dm", vid/1000000);  fflush(stdout); }
     const uint Len = GetVLen(vid);
     TVal* ValV = GetValVPt(vid);
     if (TotalDel > 0) { IdToOffV[vid-1] -= TotalDel; } // update end of vector
     if (Len == 0) { continue; }
     NDel = 0;
     for (TVal* v = ValV; v < ValV+Len-NDel; v++) {
       if (*v == DelVal) {
         TVal* Beg = v;
         while (*v == DelVal && v < ValV+Len) { v++; NDel++; }
         memcpy(Beg, v, sizeof(TVal)*int(Len - ::TSize(v - ValV)));
         v -= NDel;
       }
     }
     memcpy(ValV-TotalDel, ValV, sizeof(TVal)*Len);  // move data
     TotalDel += NDel;
   }
   IdToOffV.Last() -= TotalDel;
   for (::TSize i = Vals-TotalDel; i < Vals; i++) { ValBf[i] = EmptyVal; }
   Vals -= TotalDel;
   // printf("  deleted %llu elements from the pool\n", TotalDel);
 }

template<class TVal >

const TVal& TGLib_OLD::TVecPool< TVal >::GetEmptyVal ( ) const

inline

Definition at line 1904 of file ds.h.

1904 { return EmptyVal; }

TGLib_OLD::TVecPool::EmptyVal

TVal EmptyVal

Definition: ds.h:1881

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::GetMemUsed ( ) const

inline

Definition at line 1906 of file ds.h.

1906 {

1907 return sizeof(TCRef)+sizeof(TBool)+3*sizeof(TSize)+sizeof(TVal*)+MxVals*sizeof(TVal);}

TCRef

Definition: bd.h:440

TGLib_OLD::TVecPool::MxVals

::TSize MxVals

Definition: ds.h:1880

TSize

size_t TSize

Definition: bd.h:58

TBool

Definition: dt.h:881

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::GetV	(	const int &	VId,
		TValV &	ValV
	)		const

inline

Definition at line 1917 of file ds.h.

                                                {
     if (GetVLen(VId)==0){ValV.Clr();}
     else { ValV.GenExt(GetValVPt(VId), GetVLen(VId)); } }

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::GetVals ( ) const

inline

Definition at line 1899 of file ds.h.

1899 { return Vals; }

TGLib_OLD::TVecPool::Vals

::TSize Vals

Definition: ds.h:1880

template<class TVal >

TVal* TGLib_OLD::TVecPool< TVal >::GetValVPt ( const int & VId ) const

inline

Definition at line 1914 of file ds.h.

                                         {
     if (GetVLen(VId)==0){return (TVal*)&EmptyVal;}
     else {return ValBf+IdToOffV[VId-1];}}

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::GetVecs ( ) const

inline

Definition at line 1900 of file ds.h.

1900 { return IdToOffV.Len(); }

TVec::Len

TSizeTy Len() const

Returns the number of elements in the vector.

Definition: ds.h:547

TGLib_OLD::TVecPool::IdToOffV

TVec< ::TSize > IdToOffV

Definition: ds.h:1883

template<class TVal >

uint TGLib_OLD::TVecPool< TVal >::GetVLen ( const int & VId ) const

inline

Definition at line 1911 of file ds.h.

                                      {
     if (VId==0){return 0;}
     else {return uint(IdToOffV[VId]-IdToOffV[VId-1]);}}

template<class TVal >

bool TGLib_OLD::TVecPool< TVal >::IsVId ( const int & VId ) const

inline

Definition at line 1901 of file ds.h.

1901 { return (0 <= VId) && (VId < IdToOffV.Len()); }

TVec::Len

TSizeTy Len() const

Returns the number of elements in the vector.

Definition: ds.h:547

TGLib_OLD::TVecPool::IdToOffV

TVec< ::TSize > IdToOffV

Definition: ds.h:1883

template<class TVal >

static PVecPool TGLib_OLD::TVecPool< TVal >::Load ( TSIn & SIn )

inlinestatic

Definition at line 1893 of file ds.h.

1893 { return new TVecPool(SIn); }

TGLib_OLD::TVecPool::TVecPool

TVecPool(const ::TSize &ExpectVals=0, const ::TSize &_GrowBy=1000000, const bool &_FastCopy=false, const TVal &_EmptyVal=TVal())

Definition: ds.h:1972

template<class TVal >

static PVecPool TGLib_OLD::TVecPool< TVal >::Load ( const TStr & FNm )

inlinestatic

Definition at line 1894 of file ds.h.

1894 { TFIn FIn(FNm); return Load(FIn); }

TFIn

Definition: fl.h:275

TGLib_OLD::TVecPool::Load

static PVecPool Load(TSIn &SIn)

Definition: ds.h:1893

template<class TVal >

static PVecPool TGLib_OLD::TVecPool< TVal >::New	(	const ::TSize &	ExpectVals = `0`,
		const ::TSize &	GrowBy = `1000000`,
		const bool &	FastCopy = `false`
	)

inlinestatic

Definition at line 1891 of file ds.h.

1891 {

1892 return new TVecPool(ExpectVals, GrowBy, FastCopy); }

TGLib_OLD::TVecPool::GrowBy

::TSize GrowBy

Definition: ds.h:1880

TGLib_OLD::TVecPool::TVecPool

TVecPool(const ::TSize &ExpectVals=0, const ::TSize &_GrowBy=1000000, const bool &_FastCopy=false, const TVal &_EmptyVal=TVal())

Definition: ds.h:1972

TGLib_OLD::TVecPool::FastCopy

TBool FastCopy

Definition: ds.h:1879

template<class TVal >

TVecPool< TVal > & TVecPool< TVal >::operator= ( const TVecPool< TVal > & Pool )

Definition at line 2023 of file ds.h.

                                                                 {
   if (this!=&Pool) {
     FastCopy = Pool.FastCopy;
     GrowBy = Pool.GrowBy;
     MxVals = Pool.MxVals;
     Vals = Pool.Vals;
     EmptyVal = Pool.EmptyVal;
     IdToOffV=Pool.IdToOffV;
     try { ValBf = new TVal [MxVals]; }
     catch (std::exception Ex) { FailR(TStr::Fmt("TVec::operator= : %s, MxVals: %d", Ex.what(), MxVals).CStr()); }
     IAssert(ValBf != NULL);
     if (FastCopy) {
       memcpy(ValBf, Pool.ValBf, Vals*sizeof(TVal)); }
     else {
       for (uint64 ValN = 0; ValN < Vals; ValN++){ ValBf[ValN] = Pool.ValBf[ValN]; } }
   }
   return *this;
 }

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::PutAll ( const TVal & Val )

inline

Definition at line 1938 of file ds.h.

1938 {

1939 for (TSize ValN = 0; ValN < MxVals; ValN++) { ValBf[ValN]=Val; } }

TGLib_OLD::TVecPool::MxVals

::TSize MxVals

Definition: ds.h:1880

TSize

size_t TSize

Definition: bd.h:58

TGLib_OLD::TVecPool::ValBf

TVal * ValBf

Definition: ds.h:1882

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::PutV	(	const int &	VId,
		const TValV &	ValV
	)

inline

Definition at line 1920 of file ds.h.

                                                {
     IAssert(IsVId(VId) && GetVLen(VId) == ValV.Len());
     if (FastCopy) {
       memcpy(GetValVPt(VId), ValV.BegI(), sizeof(TVal)*ValV.Len()); }
     else { TVal* ValPt = GetValVPt(VId);
       for (uint ValN=0; ValN < uint(ValV.Len()); ValN++, ValPt++) { *ValPt=ValV[ValN]; }
     }
   }

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::Reserve ( const ::TSize & MxVals )

inline

Definition at line 1903 of file ds.h.

1903 { Resize(MxVals); }

TGLib_OLD::TVecPool::MxVals

::TSize MxVals

Definition: ds.h:1880

TGLib_OLD::TVecPool::Resize

void Resize(const ::TSize &_MxVals)

Definition: ds.h:1945

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::Reserved ( ) const

inline

Definition at line 1902 of file ds.h.

1902 { return MxVals; }

TGLib_OLD::TVecPool::MxVals

::TSize MxVals

Definition: ds.h:1880

template<class TVal >

void TVecPool< TVal >::Resize ( const ::TSize & _MxVals )

private

Definition at line 1945 of file ds.h.

                                                {
   if (_MxVals <= MxVals){ return; } else { MxVals = _MxVals; }
   if (ValBf == NULL) {
     try { ValBf = new TVal [MxVals]; }
     catch (std::exception Ex) {
       FailR(TStr::Fmt("TVecPool::Resize 1: %s, MxVals: %d. [Program failed to allocate more memory. Solution: Get a bigger machine and a 64-bit compiler.]", Ex.what(), _MxVals).CStr()); }
     IAssert(ValBf != NULL);
     if (EmptyVal != TVal()) { PutAll(EmptyVal); }
   } else {
     // printf("*** Resize vector pool: %llu -> %llu\n", uint64(Vals), uint64(MxVals));
     TVal* NewValBf = NULL;
     try { NewValBf = new TVal [MxVals]; }
     catch (std::exception Ex) { FailR(TStr::Fmt("TVecPool::Resize 2: %s, MxVals: %d. [Program failed to allocate more memory. Solution: Get a bigger machine and a 64-bit compiler.]", Ex.what(), _MxVals).CStr()); }
     IAssert(NewValBf != NULL);
     if (FastCopy) {
       memcpy(NewValBf, ValBf, Vals*sizeof(TVal)); }
     else {
       for (TSize ValN = 0; ValN < Vals; ValN++){ NewValBf[ValN] = ValBf[ValN]; } }
     if (EmptyVal != TVal()) { // init empty values
       for (TSize ValN = Vals; ValN < MxVals; ValN++) { NewValBf[ValN] = EmptyVal; }
     }
     delete [] ValBf;
     ValBf = NewValBf;
   }
 }

template<class TVal >

void TVecPool< TVal >::Save ( TSOut & SOut ) const

Definition at line 2010 of file ds.h.

                                            {
   SOut.Save(FastCopy);
   uint64 _GrowBy=GrowBy, _MxVals=MxVals, _Vals=Vals;
   SOut.Save(_GrowBy); SOut.Save(_MxVals);  SOut.Save(_Vals);
   SOut.Save(EmptyVal);
   for (TSize ValN = 0; ValN < Vals; ValN++) { ValBf[ValN].Save(SOut); }
   { SOut.Save(IdToOffV.Len());  SOut.Save(IdToOffV.Len());
   for (int ValN = 0; ValN < IdToOffV.Len(); ValN++) {
     const uint64 Offset=IdToOffV[ValN];  SOut.Save(Offset);
   } }
 }

template<class TVal >

void TGLib_OLD::TVecPool< TVal >::SetEmptyVal ( const TVal & _EmptyVal )

inline

Definition at line 1905 of file ds.h.

1905 { EmptyVal = _EmptyVal; }

TGLib_OLD::TVecPool::EmptyVal

TVal EmptyVal

Definition: ds.h:1881

template<class TVal >

void TVecPool< TVal >::ShuffleAll ( TRnd & Rnd = TInt::Rnd )

Definition at line 2093 of file ds.h.

                                          {
   for (::TSize n = Vals-1; n > 0; n--) {
     const ::TSize k = ::TSize(((uint64(Rnd.GetUniDevInt())<<32) | uint64(Rnd.GetUniDevInt())) % (n+1));
     const TVal Tmp = ValBf[n];
     ValBf[n] = ValBf[k];
     ValBf[k] = Tmp;
   }
 }

Friends And Related Function Documentation

template<class TVal >

friend class TPt< TVecPool< TVal > >

friend

Definition at line 1941 of file ds.h.

Member Data Documentation

template<class TVal >

TCRef TGLib_OLD::TVecPool< TVal >::CRef

private

Definition at line 1878 of file ds.h.

template<class TVal >

TVal TGLib_OLD::TVecPool< TVal >::EmptyVal

private

Definition at line 1881 of file ds.h.

template<class TVal >

TBool TGLib_OLD::TVecPool< TVal >::FastCopy

private

Definition at line 1879 of file ds.h.

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::GrowBy

private

Definition at line 1880 of file ds.h.

template<class TVal >

TVec< ::TSize> TGLib_OLD::TVecPool< TVal >::IdToOffV

private

Definition at line 1883 of file ds.h.

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::MxVals

private

Definition at line 1880 of file ds.h.

template<class TVal >

TVal* TGLib_OLD::TVecPool< TVal >::ValBf

private

Definition at line 1882 of file ds.h.

template<class TVal >

::TSize TGLib_OLD::TVecPool< TVal >::Vals

private

Definition at line 1880 of file ds.h.

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

glib-core/ds.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

template<class TVal> class TGLib_OLD::TVecPool< TVal >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<class TVal>
class TGLib_OLD::TVecPool< TVal >