SNAP Library 6.0, User Reference  2020-12-09 16:24:20
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
dt.h
Go to the documentation of this file.
1 #include "bd.h"
2 
4 // Forward
5 class TILx;
6 class TOLx;
7 ClassHdTP(TXmlTok, PXmlTok);
8 
10 // Random
11 class TRnd{
12 public:
13  static const int RndSeed;
14 private:
15  static const int a, m, q, r;
16  int Seed;
17  int GetNextSeed(){
18  if ((Seed=a*(Seed%q)-r*(Seed/q))>0){return Seed;} else {return Seed+=m;}}
19 public:
20  TRnd(const int& _Seed=1, const int& Steps=0){
21  PutSeed(_Seed); Move(Steps);}
22  explicit TRnd(TSIn& SIn){SIn.Load(Seed);}
23  void Save(TSOut& SOut) const {SOut.Save(Seed);}
24  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
25  void SaveXml(TSOut& SOut, const TStr& Nm) const;
26 
27  TRnd& operator=(const TRnd& Rnd){Seed=Rnd.Seed; return *this;}
28  bool operator==(const TRnd&) const {Fail; return false;}
29 
30  double GetUniDev(){return GetNextSeed()/double(m);}
31  int GetUniDevInt(const int& Range=0);
32  int GetUniDevInt(const int& MnVal, const int& MxVal){
33  IAssert(MnVal<=MxVal); return MnVal+GetUniDevInt(MxVal-MnVal+1);}
34  uint GetUniDevUInt(const uint& Range=0);
35  int64 GetUniDevInt64(const int64& Range=0);
36  uint64 GetUniDevUInt64(const uint64& Range=0);
37  double GetNrmDev();
38  double GetNrmDev(
39  const double& Mean, const double& SDev, const double& Mn, const double& Mx);
40  double GetExpDev();
41  double GetExpDev(const double& Lambda); // mean=1/lambda
42  double GetGammaDev(const int& Order);
43  double GetPoissonDev(const double& Mean);
44  double GetBinomialDev(const double& Prb, const int& Trials);
45  int GetGeoDev(const double& Prb){
46  return 1+(int)floor(log(1.0-GetUniDev())/log(1.0-Prb));}
47  double GetPowerDev(const double& AlphaSlope){ // power-law degree distribution (AlphaSlope>0)
48  IAssert(AlphaSlope>1.0);
49  return pow(1.0-GetUniDev(), -1.0/(AlphaSlope-1.0));}
50  double GetRayleigh(const double& Sigma) { // 1/sqrt(alpha) = sigma
51  IAssert(Sigma>0.0);
52  return Sigma*sqrt(-2*log(1-GetUniDev()));}
53  double GetWeibull(const double& K, const double& Lambda) { // 1/alpha = lambda
54  IAssert(Lambda>0.0 && K>0.0);
55  return Lambda*pow(-log(1-GetUniDev()), 1.0/K);}
56  //void GetSphereDev(const int& Dim, TFltV& ValV);
57 
58  void PutSeed(const int& _Seed);
59  int GetSeed() const {return Seed;}
60  void Randomize(){PutSeed(RndSeed);}
61  void Move(const int& Steps);
62  bool Check();
63 
64  static double GetUniDevStep(const int& Seed, const int& Steps){
65  TRnd Rnd(Seed); Rnd.Move(Steps); return Rnd.GetUniDev();}
66  static double GetNrmDevStep(const int& Seed, const int& Steps){
67  TRnd Rnd(Seed); Rnd.Move(Steps); return Rnd.GetNrmDev();}
68  static double GetExpDevStep(const int& Seed, const int& Steps){
69  TRnd Rnd(Seed); Rnd.Move(Steps); return Rnd.GetExpDev();}
70 
71  static TRnd LoadTxt(TILx& Lx);
72  void SaveTxt(TOLx& Lx) const;
73 };
74 
76 // Memory
77 ClassTP(TMem, PMem)//{
78 private:
79  int MxBfL, BfL;
80  char* Bf;
81  void Resize(const int& _MxBfL);
82  bool DoFitLen(const int& LBfL) const {return BfL+LBfL<=MxBfL;}
83 public:
84  TMem(const int& _MxBfL=0):
85  MxBfL(_MxBfL), BfL(0), Bf(NULL){ IAssert(BfL>=0);
86  if (MxBfL>0){Bf=new char[MxBfL]; IAssert(Bf!=NULL);}}
87  static PMem New(const int& MxBfL=0){return new TMem(MxBfL);}
88  TMem(const void* _Bf, const int& _BfL):
89  MxBfL(_BfL), BfL(_BfL), Bf(NULL){ IAssert(BfL>=0);
90  if (BfL>0){Bf=new char[BfL]; IAssert(Bf!=NULL); memcpy(Bf, _Bf, BfL);}}
91  static PMem New(const void* Bf, const int& BfL){return new TMem(Bf, BfL);}
92  TMem(const TMem& Mem):
93  MxBfL(Mem.MxBfL), BfL(Mem.BfL), Bf(NULL){
94  if (MxBfL>0){Bf=new char[MxBfL]; memcpy(Bf, Mem.Bf, BfL);}}
95  static PMem New(const TMem& Mem){return new TMem(Mem);}
96  static PMem New(const PMem& Mem){return new TMem(*Mem);}
97  TMem(const TStr& Str);
98  static PMem New(const TStr& Str){return new TMem(Str);}
99  ~TMem(){if (Bf!=NULL){delete[] Bf;}}
100  explicit TMem(TSIn& SIn){
101  SIn.Load(MxBfL); SIn.Load(BfL);
102  Bf=new char[MxBfL=BfL]; SIn.LoadBf(Bf, BfL);}
103  void Save(TSOut& SOut) const {
104  SOut.Save(MxBfL); SOut.Save(BfL); SOut.SaveBf(Bf, BfL);}
105  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
106  void SaveXml(TSOut& SOut, const TStr& Nm) const;
107 
108  TMem& operator=(const TMem& Mem){
109  if (this!=&Mem){
110  if (Bf!=NULL){delete[] Bf;}
111  MxBfL=Mem.MxBfL; BfL=Mem.BfL; Bf=NULL;
112  if (MxBfL>0){Bf=new char[MxBfL]; memcpy(Bf, Mem.Bf, BfL);}}
113  return *this;}
114  char* operator()() const {return Bf;}
115  TMem& operator+=(const char& Ch);
116  TMem& operator+=(const TMem& Mem);
117  TMem& operator+=(const TStr& Str);
118  TMem& operator+=(const PSIn& SIn);
119  char& operator[](const int& ChN) const {
120  Assert((0<=ChN)&&(ChN<BfL)); return Bf[ChN];}
121  int GetMemUsed() const {return int(2*sizeof(int)+sizeof(char*)+MxBfL);}
122 
123  void Gen(const int& _BfL){
124  Clr(); Resize(_BfL); BfL=_BfL;}
125  void GenZeros(const int& _BfL){
126  Clr(false); Resize(_BfL); BfL=_BfL;
127  if (BfL > 0) memset(Bf, 0, BfL);}
128  void Reserve(const int& _MxBfL, const bool& DoClr = true){
129  if (DoClr){ Clr(); } Resize(_MxBfL);}
130  void Del(const int& BChN, const int& EChN);
131  void Clr(const bool& DoDel=true){
132  if (DoDel){if (Bf!=NULL){delete[] Bf;} MxBfL=0; BfL=0; Bf=NULL;}
133  else {BfL=0;}}
134  int Len() const {return BfL;}
135  bool Empty() const {return BfL==0;}
136  void Trunc(const int& _BfL){
137  if ((0<=_BfL)&&(_BfL<=BfL)){BfL=_BfL;}}
138  void Push(const char& Ch){operator+=(Ch);}
139  char Pop(){IAssert(BfL>0); BfL--; return Bf[BfL];}
140 
141  bool DoFitStr(const TStr& Str) const;
142  //int AddStr(const TStr& Str);
143  void AddBf(const void* Bf, const int& BfL);
144  char* GetBf() const {return Bf;}
145  TStr GetAsStr(const char& NewNullCh='\0') const;
146  PSIn GetSIn() const {
147  TMOut MOut(BfL); MOut.SaveBf(Bf, BfL); return MOut.GetSIn();}
148 
149  static void LoadMem(const PSIn& SIn, TMem& Mem){
150  Mem.Clr(); Mem.Gen(SIn->Len()); SIn->GetBf(Mem.Bf, SIn->Len());}
151  static void LoadMem(const PSIn& SIn, const PMem& Mem){
152  Mem->Clr(); Mem->Gen(SIn->Len()); SIn->GetBf(Mem->Bf, SIn->Len());}
153  void SaveMem(const PSOut& SOut) const {SOut->SaveBf(Bf, Len());}
154 };
155 
157 // Input-Memory
158 class TMemIn: public TSIn{
159 private:
160  PMem Mem;
161  const char* Bf;
162  int BfC, BfL;
163 public:
164  TMemIn(const TMem& _Mem, const int& _BfC=0);
165  static PSIn New(const TMem& Mem){
166  return PSIn(new TMemIn(Mem));}
167  static PSIn New(const PMem& Mem){
168  TMemIn* MemIn=new TMemIn(*Mem); MemIn->Mem=Mem; return PSIn(MemIn);}
169  ~TMemIn(){}
170 
171  bool Eof(){return BfC==BfL;}
172  int Len() const {return BfL-BfC;}
173  char GetCh(){Assert(BfC<BfL); return Bf[BfC++];}
174  char PeekCh(){Assert(BfC<BfL); return Bf[BfC];}
175  int GetBf(const void* LBf, const TSize& LBfL);
176  void Reset(){Cs=TCs(); BfC=0;}
177  bool GetNextLnBf(TChA& LnChA);
178 };
179 
181 // Output-Memory
182 class TMemOut: public TSOut{
183 private:
184  PMem Mem;
185 private:
186  void FlushBf();
187 public:
188  TMemOut(const PMem& _Mem);
189  static PSOut New(const PMem& Mem){
190  return new TMemOut(Mem);}
191  ~TMemOut(){}
192 
193  int PutCh(const char& Ch){
194  Mem->operator+=(Ch); return Ch;}
195  int PutBf(const void* LBf, const TSize& LBfL);
196  void Flush(){}
197 };
198 
200 // Char-Array
201 class TChA{
202 private:
203  int MxBfL, BfL;
204  char* Bf;
205  void Resize(const int& _MxBfL);
206 public:
207  explicit TChA(const int& _MxBfL=256){
208  Bf=new char[(MxBfL=_MxBfL)+1]; Bf[BfL=0]=0;}
209  TChA(const char* CStr){
210  Bf=new char[(MxBfL=BfL=int(strlen(CStr)))+1]; strcpy(Bf, CStr);}
211  TChA(const char* CStr, const int& StrLen) : MxBfL(StrLen), BfL(StrLen) {
212  Bf=new char[StrLen+1]; strncpy(Bf, CStr, StrLen); Bf[StrLen]=0;}
213  TChA(const TChA& ChA){
214  Bf=new char[(MxBfL=ChA.MxBfL)+1]; BfL=ChA.BfL; strcpy(Bf, ChA.CStr());}
215  TChA(const TStr& Str);
216  TChA(const TMem& Mem){
217  Bf=new char[(MxBfL=BfL=Mem.Len())+1]; Bf[MxBfL]=0;
218  memcpy(CStr(), Mem(), Mem.Len());}
219  ~TChA(){delete[] Bf;}
220  explicit TChA(TSIn& SIn){
221  SIn.Load(MxBfL); SIn.Load(BfL); SIn.Load(Bf, MxBfL, BfL);}
222  void Load(TSIn& SIn){ delete[] Bf;
223  SIn.Load(MxBfL); SIn.Load(BfL); SIn.Load(Bf, MxBfL, BfL);}
224  void Save(TSOut& SOut, const bool& SaveCompact=true) const { //J:
225  SOut.Save(SaveCompact?BfL:MxBfL); SOut.Save(BfL); SOut.Save(Bf, BfL);}
226  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
227  void SaveXml(TSOut& SOut, const TStr& Nm) const;
228 
229  TChA& operator=(const TChA& ChA);
230  TChA& operator=(const TStr& Str);
231  TChA& operator=(const char* CStr);
232  bool operator==(const TChA& ChA) const {return strcmp(CStr(), ChA.CStr())==0;}
233  bool operator==(const char* _CStr) const {return strcmp(CStr(), _CStr)==0;}
234  bool operator==(const char& Ch) const {return (BfL==1)&&(Bf[0]==Ch);}
235  bool operator!=(const TChA& ChA) const {return strcmp(CStr(), ChA.CStr())!=0;}
236  bool operator!=(const char* _CStr) const {return strcmp(CStr(), _CStr)!=0;}
237  bool operator!=(const char& Ch) const {return !((BfL==1)&&(Bf[0]==Ch));}
238  bool operator<(const TChA& ChA) const {return strcmp(CStr(), ChA.CStr())<0;}
239 
240  TChA& operator+=(const TMem& Mem);
241  TChA& operator+=(const TChA& ChA);
242  TChA& operator+=(const TStr& Str);
243  TChA& operator+=(const char* CStr);
244  TChA& operator+=(const char& Ch){
245  if (BfL==MxBfL){Resize(BfL+1);}
246  Bf[BfL]=Ch; BfL++; Bf[BfL]=0; return *this;}
247  char operator[](const int& ChN) const {
248  Assert((0<=ChN)&&(ChN<BfL)); return Bf[ChN];}
249  char& operator[](const int& ChN){
250  Assert((0<=ChN)&&(ChN<BfL)); return Bf[ChN];}
251  int GetMemUsed() const {return int(2*sizeof(int)+sizeof(char*)+sizeof(char)*MxBfL);}
252 
253  char* operator ()(){return Bf;}
254  const char* operator ()() const {return Bf;}
255  char* CStr() {return Bf;}
256  const char* CStr() const {return Bf;}
257 
258  void Clr(){Bf[BfL=0]=0;}
259  int Len() const {return BfL;}
260  bool Empty() const {return BfL==0;}
261  void Ins(const int& BChN, const char* CStr);
262  void Del(const int& ChN);
263  void DelLastCh(){Pop();}
264  void Push(const char& Ch){operator+=(Ch);}
265  char Pop(){IAssert(BfL>0); BfL--; char Ch=Bf[BfL]; Bf[BfL]=0; return Ch;}
266  void Trunc();
267  void Trunc(const int& _BfL){
268  if ((0<=_BfL)&&(_BfL<=BfL)){Bf[BfL=_BfL]=0;}}
269  void Reverse();
270 
271  void AddCh(const char& Ch, const int& MxLen=-1){
272  if ((MxLen==-1)||(BfL<MxLen)){operator+=(Ch);}}
273  void AddChTo(const char& Ch, const int& ToChN){
274  while (Len()<ToChN){AddCh(Ch);}}
275  void AddBf(char *NewBf, const int& BfS){
276  if ((BfL+BfS+1)>MxBfL){Resize(BfL+BfS+1);}
277  strncpy(Bf+BfL,NewBf,BfS); BfL+=BfS; Bf[BfL]=0;}
278  void PutCh(const int& ChN, const char& Ch){
279  Assert((0<=ChN)&&(ChN<BfL)); Bf[ChN]=Ch;}
280  char GetCh(const int& ChN) const {return operator[](ChN);}
281  char LastCh() const { Assert(1<=BfL); return Bf[BfL-1]; }
282  char LastLastCh() const { Assert(2<=BfL); return Bf[BfL-2]; }
283 
284  TChA GetSubStr(const int& BChN, const int& EChN) const;
285 
286  int CountCh(const char& Ch, const int& BChN=0) const;
287  int SearchCh(const char& Ch, const int& BChN=0) const;
288  int SearchChBack(const char& Ch, int BChN=-1) const;
289  int SearchStr(const TChA& Str, const int& BChN=0) const;
290  int SearchStr(const TStr& Str, const int& BChN=0) const;
291  int SearchStr(const char* CStr, const int& BChN=0) const;
292  bool IsStrIn(const TStr& Str) const {return SearchStr(Str)!=-1;}
293  bool IsPrefix(const char* CStr, const int& BChN=0) const;
294  bool IsPrefix(const TStr& Str) const;
295  bool IsPrefix(const TChA& Str) const;
296  bool IsSuffix(const char* CStr) const;
297  bool IsSuffix(const TStr& Str) const;
298  bool IsSuffix(const TChA& Str) const;
299 
300  bool IsChIn(const char& Ch) const {return SearchCh(Ch)!=-1;}
301  void ChangeCh(const char& SrcCh, const char& DstCh);
302  TChA& ToUc();
303  TChA& ToLc();
304  TChA& ToTrunc();
305  void CompressWs();
306  void Swap(const int& ChN1, const int& ChN2);
307  void Swap(TChA& ChA);
308 
309  int GetPrimHashCd() const;
310  int GetSecHashCd() const;
311 
312  static void LoadTxt(const PSIn& SIn, TChA& ChA);
313  void SaveTxt(const PSOut& SOut) const;
314 
315  //friend TChA operator+(const TChA& LStr, const TChA& RStr);
316  //friend TChA operator+(const TChA& LStr, const TStr& RStr);
317  //friend TChA operator+(const TChA& LStr, const char* RCStr);
318 };
319 
321 // Input-Char-Array
322 class TChAIn: public TSIn{
323 private:
324  const char* Bf;
325  int BfC, BfL;
326 private:
327  TChAIn();
328  TChAIn(const TChAIn&);
329  TChAIn& operator=(const TChAIn&);
330 public:
331  TChAIn(const TChA& ChA, const int& _BfC=0);
332  static PSIn New(const TChA& ChA){return PSIn(new TChAIn(ChA));}
333  ~TChAIn(){}
334 
335  bool Eof(){return BfC==BfL;}
336  int Len() const {return BfL-BfC;}
337  char GetCh(){Assert(BfC<BfL); return Bf[BfC++];}
338  char PeekCh(){Assert(BfC<BfL); return Bf[BfC];}
339  int GetBf(const void* LBf, const TSize& LBfL);
340  void Reset(){Cs=TCs(); BfC=0;}
341  bool GetNextLnBf(TChA& LnChA);
342 };
343 
345 // Ref-String
346 class TRStr{
347 public:
348  char* Bf;
349  int Refs;
350 public:
351  TRStr(){Refs=1; Bf=new char[0+1]; Bf[0]=0;}
352  TRStr(const int& Len){
353  IAssert(Len>=0); Refs=0; Bf=new char[Len+1]; Bf[Len]=0;}
354  TRStr(const char* CStr){
355  Refs=0; Bf=new char[strlen(CStr)+1]; strcpy(Bf, CStr);}
356  TRStr(const char* CStr, const int& MxLen){
357  Refs=0; Bf=new char[MxLen+1]; strncpy(Bf, CStr, MxLen); Bf[MxLen]=0;}
358  TRStr(const char* CStr1, const char* CStr2){
359  Refs=0; int CStr1Len=int(strlen(CStr1)); Bf=new char[CStr1Len+int(strlen(CStr2))+1];
360  strcpy(Bf, CStr1); strcpy(Bf+CStr1Len, CStr2);}
361  TRStr(const char& Ch){
362  Refs=0; Bf=new char[1+1]; Bf[0]=Ch; Bf[1]=0;}
363  TRStr(const char& Ch1, const char& Ch2){
364  Refs=0; Bf=new char[2+1]; Bf[0]=Ch1; Bf[1]=Ch2; Bf[2]=0;}
365  ~TRStr(){
366  Assert(((this!=GetNullRStr())&&(Refs==0))||((this==GetNullRStr())&&(Refs==1)));
367  delete[] Bf;}
368  explicit TRStr(TSIn& SIn, const bool& IsSmall){
369  if (IsSmall){Refs=0; SIn.Load(Bf);}
370  else {Refs=0; int BfL; SIn.Load(BfL); SIn.Load(Bf, BfL, BfL);}}
371  void Save(TSOut& SOut, const bool& IsSmall) const {
372  if (IsSmall){SOut.Save(Bf);}
373  else {int BfL=int(strlen(Bf)); SOut.Save(BfL); SOut.Save(Bf, BfL);}}
374 
375  TRStr& operator=(const TRStr&){Fail; return *this;}
376  int GetMemUsed() const {return int(sizeof(int))+int(strlen(Bf));}
377 
378  void MkRef(){Refs++;}
379  void UnRef(){Assert(Refs>0); if (--Refs==0){delete this;}}
380 
381  const char* CStr() const {return Bf;}
382  char* CStr() {return Bf;}
383  bool Empty() const {return Bf[0]==0;}
384  int Len() const {return int(strlen(Bf));}
385 
386  void PutCh(const int& ChN, const char& Ch){
387  Assert((0<=ChN)&&(ChN<Len())); Bf[ChN]=Ch;}
388  char GetCh(const int& ChN) const {
389  Assert((0<=ChN)&&(ChN<Len())); return Bf[ChN];}
390 
391  bool IsUc() const;
392  void ToUc();
393  bool IsLc() const;
394  void ToLc();
395  void ToCap();
396  void ConvUsFromYuAscii();
397  static int CmpI(const char* CStr1, const char* CStr2);
398 
399  int GetPrimHashCd() const;
400  int GetSecHashCd() const;
401 
402  static TRStr* GetNullRStr(){
403  static TRStr NullRStr; Assert(NullRStr.Bf!=NULL); return &NullRStr;}
404 };
405 
407 // String
408 class TStr;
409 template <class TVal, class TSizeTy> class TVec;
410 typedef TVec<TStr, int> TStrV;
411 
412 class TStr{
413 private:
414  TRStr* RStr;
415 private:
416  TStr(const char& Ch, bool){
417  RStr=new TRStr(Ch); RStr->MkRef();}
418  TStr(const char& Ch1, const char& Ch2, bool){
419  RStr=new TRStr(Ch1, Ch2); RStr->MkRef();}
420  static TRStr* GetRStr(const char* CStr);
421  void Optimize();
422 public:
423  TStr(){RStr=TRStr::GetNullRStr(); RStr->MkRef();}
424  TStr(const TStr& Str){RStr=Str.RStr; RStr->MkRef();}
425  TStr(const TChA& ChA){RStr=GetRStr(ChA.CStr()); RStr->MkRef();}
426  TStr(const TSStr& SStr){RStr=GetRStr(SStr.CStr()); RStr->MkRef();}
427  TStr(const char* CStr){RStr=GetRStr(CStr); RStr->MkRef();}
428  explicit TStr(const char& Ch){RStr=GetChStr(Ch).RStr; RStr->MkRef();}
429  TStr(const TMem& Mem){
430  RStr=new TRStr(Mem.Len()); RStr->MkRef();
431  memcpy(CStr(), Mem(), Mem.Len()); Optimize();}
432  explicit TStr(const PSIn& SIn){
433  int SInLen=SIn->Len(); RStr=new TRStr(SInLen); RStr->MkRef();
434  SIn->GetBf(CStr(), SInLen); Optimize();}
435  ~TStr(){RStr->UnRef();}
436  explicit TStr(TSIn& SIn, const bool& IsSmall=false):
437  RStr(new TRStr(SIn, IsSmall)){RStr->MkRef(); Optimize();}
438  void Load(TSIn& SIn, const bool& IsSmall=false){
439  *this=TStr(SIn, IsSmall);}
440  void Save(TSOut& SOut, const bool& IsSmall=false) const {
441  RStr->Save(SOut, IsSmall);}
442  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
443  void SaveXml(TSOut& SOut, const TStr& Nm) const;
444 
445  TStr& operator=(const TStr& Str){
446  if (this!=&Str){RStr->UnRef(); RStr=Str.RStr; RStr->MkRef();} return *this;}
447  TStr& operator=(const TChA& ChA){
448  RStr->UnRef(); RStr=GetRStr(ChA.CStr()); RStr->MkRef(); return *this;}
449  TStr& operator=(const char* CStr){
450  RStr->UnRef(); RStr=GetRStr(CStr); RStr->MkRef(); return *this;}
451  TStr& operator=(const char& Ch){
452  RStr->UnRef(); RStr=GetChStr(Ch).RStr; RStr->MkRef(); return *this;}
453  TStr& operator+=(const TStr& Str){
454  TRStr* NewRStr=new TRStr(RStr->CStr(), Str.RStr->CStr());
455  RStr->UnRef(); RStr=NewRStr; RStr->MkRef();
456  Optimize(); return *this;}
457  TStr& operator+=(const char* CStr){
458  TRStr* NewRStr=new TRStr(RStr->CStr(), CStr);
459  RStr->UnRef(); RStr=NewRStr; RStr->MkRef();
460  Optimize(); return *this;}
461  TStr& operator/(const int& N){
462  // no-op, this definition is required by the aaMean table aggregation
463  return *this;}
464  bool operator==(const TStr& Str) const {
465  return (RStr==Str.RStr)||(strcmp(RStr->CStr(), Str.RStr->CStr())==0);}
466  bool operator==(const char* CStr) const {
467  return strcmp(RStr->CStr(), CStr)==0;}
468 // bool operator!=(const TStr& Str) const {
469 // return strcmp(RStr->CStr(), Str.RStr->CStr())!=0;}
470  bool operator!=(const char* CStr) const {
471  return strcmp(RStr->CStr(), CStr)!=0;}
472  bool operator<(const TStr& Str) const {
473  return strcmp(RStr->CStr(), Str.RStr->CStr())<0;}
474  char operator[](const int& ChN) const {return RStr->GetCh(ChN);}
475  int GetMemUsed() const {return int(sizeof(TRStr*)+RStr->GetMemUsed());}
476 
477  char* operator()(){return RStr->CStr();}
478  const char* operator()() const {return RStr->CStr();}
479  char* CStr() {return RStr->CStr();}
480  const char* CStr() const {return RStr->CStr();}
481 
482  void PutCh(const int& ChN, const char& Ch){
483  TRStr* NewRStr=new TRStr(RStr->CStr());
484  RStr->UnRef(); RStr=NewRStr; RStr->MkRef();
485  RStr->PutCh(ChN, Ch); Optimize();}
486  char GetCh(const int& ChN) const {return RStr->GetCh(ChN);}
487  char LastCh() const {return GetCh(Len()-1);}
488 
489  void Clr(){RStr->UnRef(); RStr=TRStr::GetNullRStr(); RStr->MkRef();}
490  int Len() const {return RStr->Len();}
491  bool Empty() const {return RStr->Empty();}
492 
493  // upper-case
494  bool IsUc() const {return RStr->IsUc();}
495  TStr& ToUc();
496  TStr GetUc() const {return TStr(*this).ToUc();}
497  int CmpI(const TStr& Str) const {return TRStr::CmpI(CStr(), Str.CStr());}
498  bool EqI(const TStr& Str) const {return TRStr::CmpI(CStr(), Str.CStr())==0;}
499  // lower-case
500  bool IsLc() const {return RStr->IsLc();}
501  TStr& ToLc();
502  TStr GetLc() const {return TStr(*this).ToLc();}
503  // capitalize
504  TStr& ToCap();
505  TStr GetCap() const {return TStr(*this).ToCap();}
506 
507  // truncate
508  TStr& ToTrunc();
509  TStr GetTrunc() const {return TStr(*this).ToTrunc();}
510  // Yu-Ascii to Us-Ascii
511  TStr& ConvUsFromYuAscii();
512  TStr GetUsFromYuAscii() const {return TStr(*this).ConvUsFromYuAscii();}
513  // hex
514  TStr& ToHex();
515  TStr GetHex() const {return TStr(*this).ToHex();}
516  TStr& FromHex();
517  TStr GetFromHex() const {return TStr(*this).FromHex();}
518 
519  TStr GetSubStr(const int& BChN, const int& EChN) const;
520  TStr GetSubStr(const int& BChN) const { return GetSubStr(BChN, Len()-1); }
521  void InsStr(const int& BChN, const TStr& Str);
522  void DelChAll(const char& Ch);
523  void DelSubStr(const int& BChN, const int& EChN);
524  bool DelStr(const TStr& Str);
525  TStr LeftOf(const char& SplitCh) const;
526  TStr LeftOfLast(const char& SplitCh) const;
527  TStr RightOf(const char& SplitCh) const;
528  TStr RightOfLast(const char& SplitCh) const;
529  void SplitOnCh(TStr& LStr, const char& SplitCh, TStr& RStr) const;
530  void SplitOnLastCh(TStr& LStr, const char& SplitCh, TStr& RStr) const;
531  void SplitOnAllCh(
532  const char& SplitCh, TStrV& StrV, const bool& SkipEmpty=true) const;
533  void SplitOnAllAnyCh(
534  const TStr& SplitChStr, TStrV& StrV, const bool& SkipEmpty=true) const;
535  void SplitOnWs(TStrV& StrV) const;
536  void SplitOnNonAlNum(TStrV& StrV) const;
537  void SplitOnStr(const TStr& SplitStr, TStrV& StrV) const;
538  void SplitOnStr(TStr& LeftStr, const TStr& MidStr, TStr& RightStr) const;
539 
540  //TStr Left(const int& Chs) const { return Chs>0 ? GetSubStr(0, Chs-1) : GetSubStr(0, Len()-Chs-1);}
541  //TStr Right(const int& Chs) const {return GetSubStr(Len()-Chs, Len()-1);}
542  TStr Mid(const int& BChN, const int& Chs) const { return GetSubStr(BChN, BChN+Chs-1); }
543  TStr Mid(const int& BChN) const {return GetSubStr(BChN, Len()-1); }
544  //TStr Slice(const int& BChN, const int& EChNP1) const {return GetSubStr(BChN, EChNP1-1);}
545  //TStr operator()(const int& BChN, const int& EChNP1) const {return Slice(BChN, EChNP1);}
546  //J: as in python or matlab: position 1 is 1st character, -1 is last character
547  TStr Left(const int& EChN) const { return EChN>0 ? GetSubStr(0, EChN-1) : GetSubStr(0, Len()+EChN-1);}
548  TStr Right(const int& BChN) const {return BChN>=0 ? GetSubStr(BChN, Len()-1) : GetSubStr(Len()+BChN, Len()-1);}
549  TStr Slice(int BChN, int EChNP1) const { if(BChN<0){BChN=Len()+BChN;} if(EChNP1<=0){EChNP1=Len()+EChNP1;} return GetSubStr(BChN, EChNP1-1); }
550  TStr operator()(const int& BChN, const int& EChNP1) const {return Slice(BChN, EChNP1);}
551 
552  int CountCh(const char& Ch, const int& BChN=0) const;
553  int SearchCh(const char& Ch, const int& BChN=0) const;
554  int SearchChBack(const char& Ch, int BChN=-1) const;
555  int SearchStr(const TStr& Str, const int& BChN=0) const;
556  bool IsChIn(const char& Ch) const {return SearchCh(Ch)!=-1;}
557  bool IsStrIn(const TStr& Str) const {return SearchStr(Str)!=-1;}
558  bool IsPrefix(const char *Str) const;
559  bool IsPrefix(const TStr& Str) const {
560  return IsPrefix(Str.CStr());}
561  bool IsSuffix(const char *Str) const;
562  bool IsSuffix(const TStr& Str) const {
563  return IsSuffix(Str.CStr());}
564 
565  int ChangeCh(const char& SrcCh, const char& DstCh, const int& BChN=0);
566  int ChangeChAll(const char& SrcCh, const char& DstCh);
567  int ChangeStr(const TStr& SrcStr, const TStr& DstStr, const int& BChN=0);
568  int ChangeStrAll(const TStr& SrcStr, const TStr& DstStr, const bool& FromStartP=false);
569  TStr Reverse() const {
570  TChA ChA(*this); ChA.Reverse(); return ChA;}
571 
572  int GetPrimHashCd() const {return RStr->GetPrimHashCd();}
573  int GetSecHashCd() const {return RStr->GetSecHashCd();}
574 
575  bool IsBool(bool& Val) const;
576 
577  bool IsInt(
578  const bool& Check, const int& MnVal, const int& MxVal, int& Val) const;
579  bool IsInt(int& Val) const {return IsInt(false, 0, 0, Val);}
580  bool IsInt() const {int Val; return IsInt(false, 0, 0, Val);}
581  int GetInt() const {int Val; IAssertR(IsInt(false, 0, 0, Val), *this); return Val;}
582  int GetInt(const int& DfVal) const {
583  int Val; if (IsInt(false, 0, 0, Val)){return Val;} else {return DfVal;}}
584 
585  bool IsUInt(
586  const bool& Check, const uint& MnVal, const uint& MxVal, uint& Val) const;
587  bool IsUInt(uint& Val) const {return IsUInt(false, 0, 0, Val);}
588  bool IsUInt() const {uint Val; return IsUInt(false, 0, 0, Val);}
589  uint GetUInt() const {uint Val; IAssert(IsUInt(false, 0, 0, Val)); return Val;}
590  uint GetUInt(const uint& DfVal) const {
591  uint Val; if (IsUInt(false, 0, 0, Val)){return Val;} else {return DfVal;}}
592 
593  bool IsInt64(
594  const bool& Check, const int64& MnVal, const int64& MxVal, int64& Val) const;
595  bool IsInt64(int64& Val) const {return IsInt64(false, 0, 0, Val);}
596  bool IsInt64() const {int64 Val; return IsInt64(false, 0, 0, Val);}
597  int64 GetInt64() const {
598  int64 Val; IAssert(IsInt64(false, 0, 0, Val)); return Val;}
599  int64 GetInt64(const int64& DfVal) const {
600  int64 Val; if (IsInt64(false, 0, 0, Val)){return Val;} else {return DfVal;}}
601 
602  bool IsUInt64(
603  const bool& Check, const uint64& MnVal, const uint64& MxVal, uint64& Val) const;
604  bool IsUInt64(uint64& Val) const {return IsUInt64(false, 0, 0, Val);}
605  bool IsUInt64() const {uint64 Val; return IsUInt64(false, 0, 0, Val);}
606  uint64 GetUInt64() const {
607  uint64 Val; IAssert(IsUInt64(false, 0, 0, Val)); return Val;}
608  uint64 GetUInt64(const uint64& DfVal) const {
609  uint64 Val; if (IsUInt64(false, 0, 0, Val)){return Val;} else {return DfVal;}}
610 
611  bool IsHexInt(const bool& Check, const int& MnVal, const int& MxVal, int& Val) const;
612  bool IsHexInt(int& Val) const {return IsHexInt(false, 0, 0, Val);}
613  bool IsHexInt() const {int Val; return IsHexInt(false, 0, 0, Val);}
614  int GetHexInt() const {
615  int Val; IAssert(IsHexInt(false, 0, 0, Val)); return Val;}
616  int GetHexInt(const int& DfVal) const {
617  int Val; if (IsHexInt(false, 0, 0, Val)){return Val;} else {return DfVal;}}
618 
619  bool IsHexInt64(const bool& Check, const int64& MnVal, const int64& MxVal, int64& Val) const;
620  bool IsHexInt64(int64& Val) const {return IsHexInt64(false, 0, 0, Val);}
621  bool IsHexInt64() const {int64 Val; return IsHexInt64(false, 0, 0, Val);}
622  int64 GetHexInt64() const {
623  int64 Val; IAssert(IsHexInt64(false, 0, 0, Val)); return Val;}
624  int64 GetHexInt64(const int64& DfVal) const {
625  int64 Val; if (IsHexInt64(false, 0, 0, Val)){return Val;} else {return DfVal;}}
626 
627  bool IsFlt(const bool& Check, const double& MnVal, const double& MxVal,
628  double& Val, const char& DecDelimCh='.') const;
629  bool IsFlt(double& Val) const {return IsFlt(false, 0, 0, Val);}
630  bool IsFlt() const {double Val; return IsFlt(false, 0, 0, Val);}
631  double GetFlt() const {
632  double Val; IAssert(IsFlt(false, 0, 0, Val)); return Val;}
633  double GetFlt(const double& DfVal) const {
634  double Val; if (IsFlt(false, 0, 0, Val)){return Val;} else {return DfVal;}}
635 
636  bool IsWord(const bool& WsPrefixP=true, const bool& FirstUcAllowedP=true) const;
637  bool IsWs() const;
638 
639  bool IsWcMatch(
640  const int& StrBChN, const TStr& WcStr, const int& WcStrBChN, TStrV& StarStrV,
641  const char& StarCh='*', const char& QuestCh='?') const;
642  bool IsWcMatch(
643  const TStr& WcStr, TStrV& StarStrV,
644  const char& StarCh='*', const char& QuestCh='?') const;
645  bool IsWcMatch(const TStr& WcStr, const char& StarCh, const char& QuestCh) const;
646  bool IsWcMatch(const TStr& WcStr, const int& StarStrN, TStr& StarStr) const;
647  bool IsWcMatch(const TStr& WcStr) const;
648  TStr GetWcMatch(const TStr& WcStr, const int& StarStrN=0) const;
649 
650  TStr GetFPath() const;
651  TStr GetFBase() const;
652  TStr GetFMid() const;
653  TStr GetFExt() const;
654  static TStr GetNrFPath(const TStr& FPath);
655  static TStr GetNrFMid(const TStr& FMid);
656  static TStr GetNrFExt(const TStr& FExt);
657  static TStr GetNrNumFExt(const int& FExtN);
658  static TStr GetNrFNm(const TStr& FNm);
659  static TStr GetNrAbsFPath(const TStr& FPath, const TStr& BaseFPath=TStr());
660  static bool IsAbsFPath(const TStr& FPath);
661  static TStr PutFExt(const TStr& FNm, const TStr& FExt);
662  static TStr PutFExtIfEmpty(const TStr& FNm, const TStr& FExt);
663  static TStr PutFBase(const TStr& FNm, const TStr& FBase);
664  static TStr PutFBaseIfEmpty(const TStr& FNm, const TStr& FBase);
665  static TStr AddToFMid(const TStr& FNm, const TStr& ExtFMid);
666  static TStr GetNumFNm(const TStr& FNm, const int& Num);
667  static TStr GetFNmStr(const TStr& Str, const bool& AlNumOnlyP=true);
668 
669  static TStr LoadTxt(const PSIn& SIn){
670  return TStr(SIn);}
671  static TStr LoadTxt(const TStr& FNm){
672  PSIn SIn=TFIn::New(FNm); return LoadTxt(SIn);}
673  void SaveTxt(const PSOut& SOut) const {
674  SOut->SaveBf(CStr(), Len());}
675  void SaveTxt(const TStr& FNm) const {
676  PSOut SOut=TFOut::New(FNm); SaveTxt(SOut);}
677 
678  static TStr& GetChStr(const char& Ch);
679  static TStr& GetDChStr(const char& Ch1, const char& Ch2);
680 
681  TStr GetStr() const {return *this;}
682  static TStr GetStr(const TStr& Str, const char* FmtStr);
683  static TStr GetStr(const TStr& Str, const TStr& FmtStr){
684  return GetStr(Str, FmtStr.CStr());}
685  static TStr GetStr(const TStrV& StrV, const TStr& DelimiterStr);
686  static TStr Fmt(const char *FmtStr, ...);
687  static TStr GetSpaceStr(const int& Spaces);
688  char* GetCStr() const {
689  char* Bf=new char[Len()+1]; strcpy(Bf, CStr()); return Bf;}
690 
691  static TStr MkClone(const TStr& Str){return TStr(Str.CStr());}
692  static TStr GetNullStr();
693 
694  friend TStr operator+(const TStr& LStr, const TStr& RStr);
695  friend TStr operator+(const TStr& LStr, const char* RCStr);
696 };
697 
699 // Input-String
700 class TStrIn: public TSIn{
701 private:
702  TStr Str;
703  char* Bf;
704  int BfC, BfL;
705 private:
706  TStrIn();
707  TStrIn(const TStrIn&);
708  TStrIn& operator = (const TStrIn&);
709 public:
710  TStrIn(const TStr& _Str);
711  static PSIn New(const TStr& Str){return PSIn(new TStrIn(Str));}
712  ~TStrIn(){}
713 
714  bool Eof(){return BfC==BfL;}
715  int Len() const {return BfL-BfC;}
716  char GetCh(){Assert(BfC<BfL); return Bf[BfC++];}
717  char PeekCh(){Assert(BfC<BfL); return Bf[BfC];}
718  int GetBf(const void* LBf, const TSize& LBfL);
719  void Reset(){Cs=TCs(); BfC=0;}
720  bool GetNextLnBf(TChA& LnChA);
721 };
722 
724 // Double-String
725 class TDbStr{
726 public:
727  TStr Str1;
728  TStr Str2;
729 public:
730  TDbStr(): Str1(), Str2(){}
731  TDbStr(const TDbStr& DbStr): Str1(DbStr.Str1), Str2(DbStr.Str2){}
732  TDbStr(const TStr& _Str1): Str1(_Str1), Str2(){}
733  TDbStr(const TStr& _Str1, const TStr& _Str2): Str1(_Str1), Str2(_Str2){}
734  explicit TDbStr(TSIn& SIn): Str1(SIn), Str2(SIn){}
735  void Save(TSOut& SOut) const {Str1.Save(SOut); Str2.Save(SOut);}
736 
737  TDbStr& operator=(const TDbStr& DbStr){
738  if (this!=&DbStr){Str1=DbStr.Str1; Str2=DbStr.Str2;} return *this;}
739  bool operator==(const TDbStr& DbStr) const {
740  return (Str1==DbStr.Str1)&&(Str2==DbStr.Str2);}
741  bool operator<(const TDbStr& DbStr) const {
742  return (Str1<DbStr.Str1)||((Str1==DbStr.Str1)&&(Str2<DbStr.Str2));}
743 
744  TStr GetStr(const TStr& MidStr=TStr()) const {
745  if (Filled()){return Str1+MidStr+Str2;} else {return Str1+Str2;}}
746  int GetPrimHashCd() const {
747  return Str1.GetPrimHashCd()+Str2.GetPrimHashCd();}
748  int GetSecHashCd() const {
749  return Str1.GetSecHashCd()+Str2.GetSecHashCd();}
750 
751  bool Empty() const {return (Str1.Empty())&&(Str2.Empty());}
752  bool Filled() const {return (!Str2.Empty())&&(!Str1.Empty());}
753 };
754 
756 // Simple-String-Pool
757 //ClassTP(TSStrPool, PSStrPool)//{
758 //private:
759 // TMem Bf;
760 //public:
761 // TSStrPool(const int& MxLen=0): Bf(MxLen){}
762 // TSStrPool(TSStrPool& StrPool): Bf(StrPool.Bf){}
763 // TSStrPool(TSIn& SIn): Bf(SIn){}
764 // void Save(TSOut& SOut) const {Bf.Save(SOut);}
765 //
766 // TSStrPool& operator=(const TSStrPool& StrPool){
767 // Bf=StrPool.Bf; return *this;}
768 //
769 // int Len() const {return Bf.Len();}
770 // void Clr(){Bf.Clr();}
771 // int AddStr(const TStr& Str){
772 // if (Str.Empty()){return -1;}
773 // else {int StrId=Bf.Len(); Bf+=Str; Bf+=char(0); return StrId;}}
774 // TStr GetStr(const int& StrId) const {
775 // if (StrId==-1){return "";}
776 // else {return TStr(Bf()+StrId);}}
777 //};
778 
780 // String-Pool
781 ClassTP(TStrPool, PStrPool)//{
782 private:
783  uint MxBfL, BfL, GrowBy;
784  char *Bf;
785 private:
786  void Resize(const uint& _MxBfL);
787 public:
788  TStrPool(const uint& MxBfLen = 0, const uint& _GrowBy = 16*1024*1024);
789  TStrPool(TSIn& SIn, bool LoadCompact = true);
790  TStrPool(const TStrPool& Pool) : MxBfL(Pool.MxBfL), BfL(Pool.BfL), GrowBy(Pool.GrowBy) {
791  Bf = (char *) malloc(Pool.MxBfL); IAssertR(Bf, TStr::Fmt("Can not resize buffer to %u bytes. [Program failed to allocate more memory. Solution: Get a bigger machine.]", MxBfL).CStr()); memcpy(Bf, Pool.Bf, Pool.BfL); }
792  ~TStrPool() { if (Bf) free(Bf); else IAssertR(MxBfL == 0, TStr::Fmt("size: %u, expected size: 0", MxBfL).CStr()); Bf = 0; MxBfL = 0; BfL = 0; }
793 
794  static PStrPool New(const uint& _MxBfLen = 0, const uint& _GrowBy = 16*1024*1024) { return PStrPool(new TStrPool(_MxBfLen, _GrowBy)); }
795  static PStrPool New(TSIn& SIn) { return new TStrPool(SIn); }
796  static PStrPool New(const TStr& fileName) { PSIn SIn = TFIn::New(fileName); return new TStrPool(*SIn); }
797  static PStrPool Load(TSIn& SIn, bool LoadCompacted = true) { return PStrPool(new TStrPool(SIn, LoadCompacted)); }
798  void Save(TSOut& SOut) const;
799  void Save(const TStr& FNm){PSOut SOut=TFOut::New(FNm); Save(*SOut);}
800 
801  uint Len() const { return BfL; }
802  uint Size() const { return MxBfL; }
803  bool Empty() const { return ! Len(); }
804  char* operator () () const { return Bf; }
805  TStrPool& operator = (const TStrPool& Pool);
806  ::TSize GetMemUsed(){ return 4 * sizeof(int) + MxBfL;}
807 
808  uint AddStr(const char *Str, const uint& Len);
809  uint AddStr(const char *Str) { return AddStr(Str, uint(strlen(Str)) + 1); }
810  uint AddStr(const TStr& Str) { return AddStr(Str.CStr(), Str.Len() + 1); }
811 
812  TStr GetStr(const uint& Offset) const { Assert(Offset < BfL);
813  if (Offset == 0) return TStr::GetNullStr(); else return TStr(Bf + Offset); }
814  const char *GetCStr(const uint& Offset) const { Assert(Offset < BfL);
815  if (Offset == 0) return TStr::GetNullStr().CStr(); else return Bf + Offset; }
816 
817  // Clr() removes the empty string at the start.
818  // Call AddStr("") after Clr(), if you want to use the pool again.
819  void Clr(bool DoDel = false) { BfL = 0; if (DoDel && Bf) { free(Bf); Bf = 0; MxBfL = 0; } }
820  int Cmp(const uint& Offset, const char *Str) const { Assert(Offset < BfL);
821  if (Offset != 0) return strcmp(Bf + Offset, Str); else return strcmp("", Str); }
822 
823  static int GetPrimHashCd(const char *CStr);
824  static int GetSecHashCd(const char *CStr);
825  int GetPrimHashCd(const uint& Offset) { Assert(Offset < BfL);
826  if (Offset != 0) return GetPrimHashCd(Bf + Offset); else return GetPrimHashCd(""); }
827  int GetSecHashCd(const uint& Offset) { Assert(Offset < BfL);
828  if (Offset != 0) return GetSecHashCd(Bf + Offset); else return GetSecHashCd(""); }
829  static PStrPool LoadShM(TSIn& SIn){ return new TStrPool(SIn); }
830 };
831 
833 // String-Pool-64bit
834 ClassTP(TStrPool64, PStrPool64)//{
835 private:
836  ::TSize MxBfL, BfL, GrowBy;
837  char *Bf;
838 private:
839  void Resize(const ::TSize& _MxBfL);
840 public:
841  TStrPool64(::TSize _MxBfL = 0, ::TSize _GrowBy = 16*1024*1024);
842  TStrPool64(const TStrPool64& StrPool);
843  TStrPool64(TSIn& SIn, bool LoadCompact = true);
844  ~TStrPool64() { Clr(true); }
845  void Save(TSOut& SOut) const;
846 
847  static PStrPool64 New(::TSize MxBfL = 0, ::TSize GrowBy = 16*1024*1024) {
848  return PStrPool64(new TStrPool64(MxBfL, GrowBy)); }
849  static PStrPool64 Load(TSIn& SIn, bool LoadCompact = true) {
850  return PStrPool64(new TStrPool64(SIn, LoadCompact)); }
851 
852  TStrPool64& operator=(const TStrPool64& StrPool);
853 
854  uint64 GetMemUsed() const { return 3*sizeof(::TSize) + uint64(MxBfL); }
855 
856  bool Empty() const { return (BfL == 0); }
857  uint64 Len() const {return BfL;}
858  uint64 Reserved() const { return MxBfL; }
859  void Clr(bool DoDel = false);
860  int Cmp(uint64 Offset, const char *Str) const { Assert(Offset < BfL);
861  if (Offset != 0) return strcmp(Bf + Offset, Str); else return strcmp("", Str); }
862 
863  uint64 AddStr(const TStr& Str);
864  TStr GetStr(const uint64& StrId) const;
865 };
866 
868 // Number Base Template
869 template <class Base> class TNum{
870 public:
871  Base Val;
872  TNum() : Val(0){}
873  TNum(const Base& _Val) : Val(_Val){}
874  operator Base() const { return Val; }
875  explicit TNum(TSIn& SIn){ SIn.Load(Val); }
876  void Load(TSIn& SIn){ SIn.Load(Val); }
877  void Save(TSOut& SOut) const { SOut.Save(Val); }
878 
879  TNum& operator=(const TNum& Other){ Val = Other.Val; return *this; }
880  TNum& operator=(const Base& _Val){ Val = _Val; return *this; }
881  TNum& operator++(){ ++Val; return *this; } // prefix
882  TNum& operator--(){ --Val; return *this; } // prefix
883  TNum operator++(int){ TNum oldVal = Val; Val++; return oldVal; } // postfix
884  TNum operator--(int){ TNum oldVal = Val; Val--; return oldVal; } // postfix
885  Base& operator()() { return Val; }
886 
887  int GetMemUsed() const { return sizeof(TNum); }
888 };
889 
891 // Signed-Integer-64Bit
892 typedef TNum<int64> TInt64;
893 template<>
894 class TNum<int64>{
895 public:
896  int64 Val;
897 public:
898  static const int64 Mn;
899  static const int64 Mx;
900 
901  TNum() : Val(0){}
902  TNum(const TNum& Int) : Val(Int.Val){}
903  TNum(const int64& Int) : Val(Int){}
904  operator int64() const { return Val; }
905  explicit TNum(TSIn& SIn){ SIn.Load(Val); }
906  void Load(TSIn& SIn){ SIn.Load(Val); }
907  void Save(TSOut& SOut) const { SOut.Save(Val); }
908  TNum& operator=(const TNum& Int){ Val = Int.Val; return *this; }
909  TNum& operator+=(const TNum& Int){ Val += Int.Val; return *this; }
910  TNum& operator-=(const TNum& Int){ Val -= Int.Val; return *this; }
911  TNum& operator++(){ ++Val; return *this; } // prefix
912  TNum& operator--(){ --Val; return *this; } // prefix
913  TNum operator++(int){ TNum oldVal = Val; Val++; return oldVal; } // postfix
914  TNum operator--(int){ TNum oldVal = Val; Val--; return oldVal; } // postfix
915  int GetMemUsed() const { return sizeof(TNum); }
916 
917 #ifdef GLib_WIN
918  TStr GetStr() const { return TStr::Fmt("%I64", Val); }
919  static TStr GetStr(const TNum& Int){ return TStr::Fmt("%I64", Int.Val); }
920  static TStr GetHexStr(const TNum& Int){ return TStr::Fmt("%I64X", Int.Val); }
921 #else
922  TStr GetStr() const { return TStr::Fmt("%ll", Val); }
923  static TStr GetStr(const TNum& Int){ return TStr::Fmt("%ll", Int.Val); }
924  static TStr GetHexStr(const TNum& Int){ return TStr::Fmt("%ll", Int.Val); }
925 #endif
926 
927  static TStr GetKiloStr(const int64& Val){
928  if (Val>100 * 1000){ return GetStr(Val / 1000) + "K"; }
929  else if (Val>1000){ return GetStr(Val / 1000) + "." + GetStr((Val % 1000) / 100) + "K"; }
930  else { return GetStr(Val); }
931  }
932  static TStr GetMegaStr(const int64& Val){
933  if (Val>100 * 1000000){ return GetStr(Val / 1000000) + "M"; }
934  else if (Val>1000000){
935  return GetStr(Val / 1000000) + "." + GetStr((Val % 1000000) / 100000) + "M";
936  }
937  else { return GetKiloStr(Val); }
938  }
939  /*static TStr GetGigaStr(const int64& Val){
940  * if (Val>100*1000000000){return GetStr(Val/1000000000)+"G";}
941  * else if (Val>1000000000){
942  * return GetStr(Val/1000000000)+"."+GetStr((Val%1000000000)/100000000)+"G";}
943  * else {return GetMegaStr(Val);}}*/
944 
945  static int64 GetFromBufSafe(const char * Bf) {
946 #ifdef ARM
947  int64 Val;
948  memcpy(&Val, Bf, sizeof(int64)); //we cannot use a cast on ARM (needs 8byte memory aligned doubles)
949  return Val;
950 #else
951  return *((int64*)Bf);
952 #endif
953  }
954 };
955 
957 // Void
958 class TVoid{
959 public:
960  TVoid(){}
961  TVoid(TSIn&){}
962  void Save(TSOut&) const {}
963  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
964  void SaveXml(TSOut& SOut, const TStr& Nm) const;
965 
966  TVoid& operator=(const TVoid&){return *this;}
967  bool operator==(const TVoid&) const {return true;}
968  bool operator<(const TVoid&) const {Fail; return false;}
969  int GetMemUsed() const {return sizeof(TVoid);}
970 };
971 
973 // Boolean
974 class TBool{
975 public:
976  bool Val;
977 public:
978  static const bool Mn;
979  static const bool Mx;
980  static const int Vals;
981  static TRnd Rnd;
982 
983  static const TStr FalseStr;
984  static const TStr TrueStr;
985  static const TStr NStr;
986  static const TStr YStr;
987  static const TStr NoStr;
988  static const TStr YesStr;
989 
990  TBool(): Val(false){}
991  TBool(const bool& _Val): Val(_Val){}
992  operator bool() const {return Val;}
993  explicit TBool(TSIn& SIn){SIn.Load(Val);}
994  void Load(TSIn& SIn){SIn.Load(Val);}
995  void Save(TSOut& SOut) const {SOut.Save(Val);}
996  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
997  void SaveXml(TSOut& SOut, const TStr& Nm) const;
998 
999  TBool& operator=(const TBool& Bool){Val=Bool.Val; return *this;}
1000  bool operator==(const TBool& Bool) const {return Val==Bool.Val;}
1001  bool operator<(const TBool& Bool) const {//return Val<Bool.Val;
1002  return (Val==false)&&(Bool.Val==true);}
1003  bool operator()() const {return Val;}
1004  int GetMemUsed() const {return sizeof(TBool);}
1005 
1006  int GetPrimHashCd() const {return Val;}
1007  int GetSecHashCd() const {return Val;}
1008 
1009  static bool GetRnd(){return Rnd.GetUniDevInt(2)==1;}
1010 
1011  static TStr GetStr(const bool& Val){
1012  if (Val){return TrueStr;} else {return FalseStr;}}
1013  static TStr GetStr(const TBool& Bool){
1014  return GetStr(Bool.Val);}
1015  static TStr GetYNStr(const bool& Val){
1016  if (Val){return YStr;} else {return NStr;}}
1017  static TStr GetYesNoStr(const bool& Val){
1018  if (Val){return YesStr;} else {return NoStr;}}
1019  static TStr Get01Str(const bool& Val){
1020  if (Val){return "1";} else {return "0";}}
1021  static bool IsValStr(const TStr& Str);
1022  static bool GetValFromStr(const TStr& Str);
1023  static bool GetValFromStr(const TStr& Str, const bool& DfVal);
1024 };
1025 
1027 // Char
1028 class TCh{
1029 public:
1030  char Val;
1031 public:
1032  static const char Mn;
1033  static const char Mx;
1034  static const int Vals;
1035 
1036  static const char NullCh;
1037  static const char TabCh;
1038  static const char LfCh;
1039  static const char CrCh;
1040  static const char EofCh;
1041  static const char HashCh;
1042 
1043  TCh(): Val(TCh::NullCh){}
1044  TCh(const char& _Val): Val(_Val){}
1045  operator char() const {return Val;}
1046  explicit TCh(TSIn& SIn){SIn.Load(Val);}
1047  void Load(TSIn& SIn) {SIn.Load(Val);}
1048  void Save(TSOut& SOut) const {SOut.Save(Val);}
1049  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1050  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1051 
1052  TCh& operator=(const TCh& Ch){Val=Ch.Val; return *this;}
1053  bool operator==(const TCh& Ch) const {return Val==Ch.Val;}
1054  bool operator<(const TCh& Ch) const {return Val<Ch.Val;}
1055  char operator()() const {return Val;}
1056  int GetMemUsed() const {return sizeof(TCh);}
1057 
1058  int GetPrimHashCd() const {return Val;}
1059  int GetSecHashCd() const {return Val;}
1060 
1061  static bool IsHashCh(const char& Ch){
1062  return (Ch==HashCh);}
1063  static bool IsWs(const char& Ch){
1064  return (Ch==' ')||(Ch==TabCh)||(Ch==CrCh)||(Ch==LfCh);}
1065  static bool IsAlpha(const char& Ch){
1066  return (('A'<=Ch)&&(Ch<='Z'))||(('a'<=Ch)&&(Ch<='z'));}
1067  static bool IsNum(const char& Ch){return ('0'<=Ch)&&(Ch<='9');}
1068  static bool IsAlNum(const char& Ch){return IsAlpha(Ch)||IsNum(Ch);}
1069  static int GetNum(const char& Ch){Assert(IsNum(Ch)); return Ch-'0';}
1070  static bool IsHex(const char& Ch){return
1071  (('0'<=Ch)&&(Ch<='9'))||(('A'<=Ch)&&(Ch<='F'))||(('a'<=Ch)&&(Ch<='f'));}
1072  static int GetHex(const char& Ch){
1073  if (('0'<=Ch)&&(Ch<='9')){return Ch-'0';}
1074  else if (('A'<=Ch)&&(Ch<='F')){return Ch-'A'+10;}
1075  else if (('a'<=Ch)&&(Ch<='f')){return Ch-'a'+10;}
1076  else Fail; return 0;}
1077  static char GetHexCh(const int& Val){
1078  if ((0<=Val)&&(Val<=9)){return char('0'+char(Val));}
1079  else if ((10<=Val)&&(Val<=15)){return char('A'+char(Val-10));}
1080  else Fail; return 0;}
1081  static char IsUc(const char& Ch){
1082  return ('A'<=Ch)&&(Ch<='Z');}
1083  static char GetUc(const char& Ch){
1084  if (('a'<=Ch)&&(Ch<='z')){return Ch-'a'+'A';} else {return Ch;}}
1085  static char GetUsFromYuAscii(const char& Ch);
1086 
1087  static TStr GetStr(const TCh& Ch){
1088  return TStr(Ch.Val);}
1089 };
1090 
1092 // Unsigned-Char
1093 class TUCh{
1094 public:
1095  uchar Val;
1096 public:
1097  static const uchar Mn;
1098  static const uchar Mx;
1099  static const int Vals;
1100 
1101  TUCh(): Val(TCh::NullCh){}
1102  TUCh(const uchar& _Val): Val(_Val){}
1103  operator uchar() const {return Val;}
1104  explicit TUCh(TSIn& SIn){SIn.Load(Val);}
1105  void Save(TSOut& SOut) const {SOut.Save(Val);}
1106  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1107  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1108 
1109  TUCh& operator=(const TUCh& UCh){Val=UCh.Val; return *this;}
1110  bool operator==(const TUCh& UCh) const {return Val==UCh.Val;}
1111  bool operator<(const TUCh& UCh) const {return Val<UCh.Val;}
1112  uchar operator()() const {return Val;}
1113  int GetMemUsed() const {return sizeof(TUCh);}
1114 
1115  int GetPrimHashCd() const {return Val;}
1116  int GetSecHashCd() const {return Val;}
1117 };
1118 
1120 // Short-Integer
1121 class TSInt{
1122 public:
1123  int16 Val;
1124 public:
1125  TSInt(): Val(0){}
1126  TSInt(const int16& _Val): Val(_Val){}
1127  operator int16() const {return Val;}
1128  explicit TSInt(TSIn& SIn){SIn.Load(Val);}
1129  void Load(TSIn& SIn){SIn.Load(Val);}
1130  void Save(TSOut& SOut) const {SOut.Save(Val);}
1131  int GetPrimHashCd() const {return Val;}
1132  int GetSecHashCd() const {return Val/0x10;}
1133 };
1134 
1136 // Integer
1137 class TInt{
1138 public:
1139  int Val;
1140 public:
1141  static const int Mn;
1142  static const int Mx;
1143  static const int Kilo;
1144  static const int Mega;
1145  static const int Giga;
1146  static TRnd Rnd;
1147 
1148  TInt(): Val(0){}
1149  TInt(const int& _Val): Val(_Val){}
1150  operator int() const {return Val;}
1151  explicit TInt(TSIn& SIn){SIn.Load(Val);}
1152  void Load(TSIn& SIn){SIn.Load(Val);}
1153  void Save(TSOut& SOut) const {SOut.Save(Val);}
1154  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1155  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1156 
1157  TInt& operator=(const TInt& Int){Val=Int.Val; return *this;}
1158  TInt& operator=(const int& Int){Val=Int; return *this;}
1159  bool operator==(const TInt& Int) const {return Val==Int.Val;}
1160  bool operator==(const int& Int) const {return Val==Int;}
1161  bool operator!=(const int& Int) const {return Val!=Int;}
1162  bool operator<(const TInt& Int) const {return Val<Int.Val;}
1163  bool operator<(const int& Int) const {return Val<Int;}
1164  int operator()() const {return Val;}
1165  TInt& operator+=(const int& Int){Val+=Int; return *this;}
1166  TInt& operator-=(const int& Int){Val-=Int; return *this;}
1167  TInt operator++(int){Val++; return *this;}
1168  TInt operator--(int){Val--; return *this;}
1169  int GetMemUsed() const {return sizeof(TInt);}
1170 
1171  int GetPrimHashCd() const {return Val;}
1172  int GetSecHashCd() const {return Val/0x10;}
1173 
1174  static int Abs(const int& Int){return Int<0?-Int:Int;}
1175  static int Sign(const int& Int){return Int<0?-1:(Int>0?1:0);}
1176  static void Swap(int& Int1, int& Int2){
1177  int SwapInt1=Int1; Int1=Int2; Int2=SwapInt1;}
1178  static int GetRnd(const int& Range=0){return Rnd.GetUniDevInt(Range);}
1179 
1180  static bool IsOdd(const int& Int){return ((Int%2)==1);}
1181  static bool IsEven(const int& Int){return ((Int%2)==0);}
1182 
1183  static int GetMn(const int& Int1, const int& Int2){
1184  return Int1<Int2?Int1:Int2;}
1185  static int GetMx(const int& Int1, const int& Int2){
1186  return Int1>Int2?Int1:Int2;}
1187  static int GetMn(const int& Int1, const int& Int2, const int& Int3){
1188  return GetMn(Int1, GetMn(Int2, Int3));}
1189  static int GetMn(const int& Int1, const int& Int2,
1190  const int& Int3, const int& Int4){
1191  return GetMn(GetMn(Int1, Int2), GetMn(Int3, Int4));}
1192  static int GetMx(const int& Int1, const int& Int2, const int& Int3){
1193  return GetMx(Int1, GetMx(Int2, Int3));}
1194  static int GetMx(const int& Int1, const int& Int2,
1195  const int& Int3, const int& Int4){
1196  return GetMx(GetMx(Int1, Int2), GetMx(Int3, Int4));}
1197  static int GetInRng(const int& Val, const int& Mn, const int& Mx){
1198  IAssert(Mn<=Mx); return Val<Mn?Mn:(Val>Mx?Mx:Val);}
1199 
1200  TStr GetStr() const {return TInt::GetStr(Val);}
1201 
1202  static TStr GetStr(const int& Val){ return TStr::Fmt("%d", Val); }
1203  static TStr GetStr(const TInt& Int){ return GetStr(Int.Val);}
1204  static TStr GetStr(const int& Val, const char* FmtStr);
1205  static TStr GetStr(const int& Val, const TStr& FmtStr){ return GetStr(Val, FmtStr.CStr());}
1206 
1207  //J: So that TInt can convert any kind of integer to a string
1208  static TStr GetStr(const uint& Val){ return TStr::Fmt("%u", Val); }
1209  #ifdef GLib_WIN
1210  static TStr GetStr(const int64& Val) {return TStr::Fmt("%I64d", Val);}
1211  static TStr GetStr(const uint64& Val) {return TStr::Fmt("%I64u", Val);}
1212  #else
1213  static TStr GetStr(const int64& Val) {return TStr::Fmt("%lld", Val);}
1214  static TStr GetStr(const uint64& Val) {return TStr::Fmt("%llu", Val);}
1215  #endif
1216 
1217  static TStr GetHexStr(const int& Val){
1218  char Bf[255]; sprintf(Bf, "%X", Val); return TStr(Bf);}
1219  static TStr GetHexStr(const TInt& Int){
1220  return GetHexStr(Int.Val);}
1221 
1222  static TStr GetKiloStr(const int& Val){
1223  if (Val>=100*1000){return GetStr(Val/1000)+"K";}
1224  else if (Val>=1000){return GetStr(Val/1000)+"."+GetStr((Val%1000)/100)+"K";}
1225  else {return GetStr(Val);}}
1226  static TStr GetMegaStr(const int& Val){
1227  if (Val>=100*1000000){return GetStr(Val/1000000)+"M";}
1228  else if (Val>=1000000){
1229  return GetStr(Val/1000000)+"."+GetStr((Val%1000000)/100000)+"M";}
1230  else {return GetKiloStr(Val);}}
1231 
1232  // frugal
1233  static char* SaveFrugalInt(char *pDest, int i);
1234  static char* LoadFrugalInt(char *pSrc, int& i);
1235  static void TestFrugalInt();
1236  static void SaveFrugalIntV(TSOut& SOut, const TVec<TInt, int>& IntV);
1237  static void LoadFrugalIntV(TSIn& SIn, TVec<TInt, int>& IntV, bool ClrP=true);
1238 };
1239 
1241 // Unsigned-Integer
1242 class TUInt{
1243 public:
1244  uint Val;
1245 public:
1246  static const uint Mn;
1247  static const uint Mx;
1248  static TRnd Rnd;
1249 
1250  TUInt(): Val(0){}
1251  TUInt(const uint& _Val): Val(_Val){}
1252  operator uint() const {return Val;}
1253  explicit TUInt(TSIn& SIn){SIn.Load(Val);}
1254  void Load(TSIn& SIn){SIn.Load(Val);}
1255  void Save(TSOut& SOut) const {SOut.Save(Val);}
1256  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1257  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1258 
1259  TUInt& operator=(const TUInt& UInt){Val=UInt.Val; return *this;}
1260  TUInt& operator=(const uint& _Val){Val=_Val; return *this;}
1261  TUInt operator++(int){Val++; return *this;}
1262  TUInt operator--(int){Val--; return *this;}
1263  //bool operator==(const TUInt& UInt) const {return Val==UInt.Val;}
1264  //bool operator==(const uint& UInt) const {return Val==UInt;}
1265  //bool operator!=(const uint& UInt) const {return Val!=UInt;}
1266  //bool operator<(const TUInt& UInt) const {return Val<UInt.Val;}
1267  uint operator()() const {return Val;}
1268  uint& operator()() {return Val;}
1269  TUInt& operator~(){Val=~Val; return *this;}
1270  TUInt& operator&=(const TUInt& UInt){Val&=UInt.Val; return *this;}
1271  TUInt& operator|=(const TUInt& UInt){Val|=UInt.Val; return *this;}
1272  TUInt& operator^=(const TUInt& UInt){Val^=UInt.Val; return *this;}
1273  TUInt& operator>>=(const int& ShiftBits){Val>>=ShiftBits; return *this;}
1274  TUInt& operator<<=(const int& ShiftBits){Val<<=ShiftBits; return *this;}
1275  int GetMemUsed() const {return sizeof(TUInt);}
1276 
1277  int GetPrimHashCd() const {return int(Val);}
1278  int GetSecHashCd() const {return Val/0x10;}
1279 
1280  static uint GetRnd(const uint& Range=0){return Rnd.GetUniDevUInt(Range);}
1281 
1282  TStr GetStr() const {return TUInt::GetStr(Val);}
1283  static TStr GetStr(const uint& Val){
1284  char Bf[255]; sprintf(Bf, "%u", Val); return TStr(Bf);}
1285  static TStr GetStr(const TUInt& UInt){
1286  return GetStr(UInt.Val);}
1287  static TStr GetStr(const uint& Val, const char* FmtStr);
1288  static TStr GetStr(const uint& Val, const TStr& FmtStr){
1289  return GetStr(Val, FmtStr.CStr());}
1290 
1291  static TStr GetKiloStr(const uint& Val){
1292  if (Val>100*1000){return GetStr(Val/1000)+"K";}
1293  else if (Val>1000){return GetStr(Val/1000)+"."+GetStr((Val%1000)/100)+"K";}
1294  else {return GetStr(Val);}}
1295  static TStr GetMegaStr(const uint& Val){
1296  if (Val>100*1000000){return GetStr(Val/1000000)+"M";}
1297  else if (Val>1000000){
1298  return GetStr(Val/1000000)+"."+GetStr((Val%1000000)/100000)+"M";}
1299  else {return GetKiloStr(Val);}}
1300 
1301  static uint JavaUIntToCppUInt(const uint& JavaUInt){
1302  uint B1=(JavaUInt & 0xFF000000) >> 24;
1303  uint B2=(JavaUInt & 0x00FF0000) >> 16;
1304  uint B3=(JavaUInt & 0x0000FF00) >> 8;
1305  uint B4=(JavaUInt & 0x000000FF) >> 0;
1306  uint CppUInt=(B4<<24)+(B3<<16)+(B2<<8)+(B1<<0);
1307  return CppUInt;}
1308 
1309  static bool IsIpStr(const TStr& IpStr, uint& Ip, const char& SplitCh = '.');
1310  static bool IsIpStr(const TStr& IpStr, const char& SplitCh = '.') { uint Ip; return IsIpStr(IpStr, Ip, SplitCh); }
1311  static uint GetUIntFromIpStr(const TStr& IpStr, const char& SplitCh = '.');
1312  static TStr GetStrFromIpUInt(const uint& Ip);
1313  static bool IsIpv6Str(const TStr& IpStr, const char& SplitCh = ':');
1314 };
1315 
1317 // Unsigned-Integer-64Bit
1318 class TUInt64{
1319 public:
1320  uint64 Val;
1321 public:
1322  static const TUInt64 Mn;
1323  static const TUInt64 Mx;
1324 
1325  TUInt64(): Val(0){}
1326  TUInt64(const TUInt64& Int): Val(Int.Val){}
1327  TUInt64(const uint64& Int): Val(Int){}
1328  TUInt64(const uint& MsVal, const uint& LsVal): Val(0){
1329  Val=(((uint64)MsVal) << 32) | ((uint64)LsVal);}
1330  explicit TUInt64(void* Pt): Val(0){
1331  TConv_Pt64Ints32 Conv(Pt); Val=Conv.GetUInt64();}
1332  operator uint64() const {return Val;}
1333  explicit TUInt64(TSIn& SIn){SIn.Load(Val);}
1334  void Load(TSIn& SIn){SIn.Load(Val);}
1335  void Save(TSOut& SOut) const {SOut.Save(Val);}
1336  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1337  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1338 
1339  TUInt64& operator=(const TUInt64& Int){Val=Int.Val; return *this;}
1340  TUInt64& operator+=(const TUInt64& Int){Val+=Int.Val; return *this;}
1341  TUInt64& operator-=(const TUInt64& Int){Val-=Int.Val; return *this;}
1342  TUInt64& operator*=(const TUInt64& Int){Val*=Int.Val; return *this;}
1343  TUInt64 operator++(int){Val++; return *this;}
1344  TUInt64 operator--(int){Val--; return *this;}
1345  int GetMemUsed() const {return sizeof(TUInt64);}
1346 
1347  int GetPrimHashCd() const { return (int)GetMsVal() + (int)GetLsVal(); } //TODO: to check
1348  int GetSecHashCd() const { return ((int)GetMsVal() + (int)GetLsVal()) / 0x10; } //TODO: to check
1349 
1350  uint GetMsVal() const {
1351  return (uint)(Val >> 32);}
1352  uint GetLsVal() const {
1353  return (uint)(Val & 0xffffffff);}
1354 
1355  //TStr GetStr() const {return TStr::Fmt("%Lu", Val);}
1356  //static TStr GetStr(const TUInt64& Int){return TStr::Fmt("%Lu", Int.Val);}
1357  //static TStr GetHexStr(const TUInt64& Int){return TStr::Fmt("%LX", Int.Val);}
1358  #ifdef GLib_WIN
1359  TStr GetStr() const {return TStr::Fmt("%I64u", Val);}
1360  static TStr GetStr(const TUInt64& Int){return TStr::Fmt("%I64u", Int.Val);}
1361  static TStr GetHexStr(const TUInt64& Int){return TStr::Fmt("%I64X", Int.Val);}
1362  #else
1363  TStr GetStr() const {return TStr::Fmt("%llu", Val);}
1364  static TStr GetStr(const TUInt64& Int){return TStr::Fmt("%llu", Int.Val);}
1365  static TStr GetHexStr(const TUInt64& Int){return TStr::Fmt("%llX", Int.Val);}
1366  #endif
1367 
1368  static TStr GetKiloStr(const uint64& Val){
1369  if (Val>100*1000){return GetStr(Val/1000)+"K";}
1370  else if (Val>1000){return GetStr(Val/1000)+"."+GetStr((Val%1000)/100)+"K";}
1371  else {return GetStr(Val);}}
1372  static TStr GetMegaStr(const uint64& Val){
1373  if (Val>100*1000000){return GetStr(Val/1000000)+"M";}
1374  else if (Val>1000000){
1375  return GetStr(Val/1000000)+"."+GetStr((Val%1000000)/100000)+"M";}
1376  else {return GetKiloStr(Val);}}
1377  /*static TStr GetGigaStr(const uint64& Val){
1378  if (Val>100*1000000000){return GetStr(Val/1000000000)+"G";}
1379  else if (Val>1000000000){
1380  return GetStr(Val/1000000000)+"."+GetStr((Val%1000000000)/100000000)+"G";}
1381  else {return GetMegaStr(Val);}}*/
1382 };
1383 
1385 // Float
1386 class TFlt{
1387 public:
1388  double Val;
1389 public:
1390  static const double Mn;
1391  static const double Mx;
1392  static const double NInf;
1393  static const double PInf;
1394  static const double Eps;
1395  static const double EpsHalf;
1396  static TRnd Rnd;
1397 
1398  TFlt(): Val(0){}
1399  TFlt(const double& _Val): Val(_Val){}
1400  operator double() const {return Val;}
1401  explicit TFlt(TSIn& SIn){SIn.Load(Val);}
1402  void Save(TSOut& SOut) const {SOut.Save(Val);}
1403  explicit TFlt(TSIn& SIn, const bool& IsTxt){
1404  if (IsTxt){TStr Str(SIn, true); Val=Str.GetFlt(0);} else {SIn.Load(Val);}}
1405  void Load(TSIn& SIn){SIn.Load(Val);}
1406  void Save(TSOut& SOut, const bool& IsTxt) const {
1407  if (IsTxt){GetStr(Val).Save(SOut, true);} else {SOut.Save(Val);}}
1408  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1409  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1410 
1411  TFlt& operator=(const TFlt& Flt){Val=Flt.Val; return *this;}
1412  TFlt& operator=(const double& Flt){Val=Flt; return *this;}
1413  bool operator==(const TFlt& Flt) const _CMPWARN {return Val==Flt.Val;}
1414  bool operator==(const double& Flt) const _CMPWARN {return Val==Flt;}
1415  bool operator!=(const double& Flt) const _CMPWARN {return Val!=Flt;}
1416  double operator()() const {return Val;}
1417  TFlt& operator+=(const double& Flt){Val+=Flt; return *this;}
1418  TFlt& operator-=(const double& Flt){Val-=Flt; return *this;}
1419  TFlt& operator*=(const double& Flt){Val*=Flt; return *this;}
1420  TFlt& operator/=(const double& Flt){Val/=Flt; return *this;}
1421  TFlt operator++(int){Val++; return *this;}
1422  TFlt operator--(int){Val--; return *this;}
1423  int GetMemUsed() const {return sizeof(TFlt);}
1424 
1425  int GetPrimHashCd() const {
1426  int Expn; return int((frexp(Val, &Expn)-0.5)*double(TInt::Mx));}
1427  int GetSecHashCd() const {
1428  int Expn; frexp(Val, &Expn); return Expn;}
1429 
1430  static double Abs(const double& Flt){return Flt<0?-Flt:Flt;}
1431  static int Sign(const double& Flt){return Flt<0?-1:(Flt>0?1:0);}
1432  static int Round(const double& Flt){return int(floor(Flt+0.5));}
1433  static double GetRnd(){return Rnd.GetUniDev();}
1434  static bool Eq6(const double& LFlt, const double& RFlt){
1435  return fabs(LFlt-RFlt)<0.000001;}
1436 
1437  static double GetMn(const double& Flt1, const double& Flt2){
1438  return Flt1<Flt2?Flt1:Flt2;}
1439  static double GetMn(const double& Flt1, const double& Flt2, const double& Flt3){
1440  return GetMn(GetMn(Flt1, Flt2), Flt3); }
1441  static double GetMn(const double& Flt1, const double& Flt2, const double& Flt3, const double& Flt4){
1442  return GetMn(GetMn(Flt1, Flt2), GetMn(Flt3, Flt4)); }
1443 
1444  static double GetMx(const double& Flt1, const double& Flt2){
1445  return Flt1>Flt2?Flt1:Flt2;}
1446  static double GetMx(const double& Flt1, const double& Flt2, const double Flt3){
1447  return GetMx(GetMx(Flt1, Flt2), Flt3); }
1448  static double GetMx(const double& Flt1, const double& Flt2, const double Flt3, const double& Flt4){
1449  return GetMx(GetMx(Flt1, Flt2), GetMx(Flt3, Flt4)); }
1450 
1451  static double GetInRng(const double& Val, const double& Mn, const double& Mx){
1452  IAssert(Mn<=Mx); return Val<Mn?Mn:(Val>Mx?Mx:Val);}
1453 
1454  static bool IsNum(const double& Val){
1455  return (Mn<=Val)&&(Val<=Mx);}
1456  static bool IsNan(const double& Val){
1457  return (Val!=Val);}
1458 
1459  bool IsNum() const { return IsNum(Val); }
1460  bool IsNan() const { return IsNan(Val); }
1461 
1462  TStr GetStr() const {return TFlt::GetStr(Val);}
1463  static TStr GetStr(const double& Val, const int& Width=-1, const int& Prec=-1);
1464  static TStr GetStr(const TFlt& Flt, const int& Width=-1, const int& Prec=-1){
1465  return GetStr(Flt.Val, Width, Prec);}
1466  static TStr GetStr(const double& Val, const char* FmtStr);
1467  static TStr GetStr(const double& Val, const TStr& FmtStr){
1468  return GetStr(Val, FmtStr.CStr());}
1469  static TStr GetPrcStr(const double& RelVal, const double& FullVal){
1470  return GetStr(100*RelVal/FullVal, "%3.0f%%");}
1471 
1472  static TStr GetKiloStr(const double& Val){
1473  if (fabs(Val)>100*1000){return TStr::Fmt("%.0fK", Val/1000);}
1474  else if (fabs(Val)>1000){return TStr::Fmt("%.1fK", Val/1000);}
1475  else {return TStr::Fmt("%.0f", Val);}}
1476  static TStr GetMegaStr(const double& Val){
1477  if (fabs(Val)>100*1000000){return TStr::Fmt("%.0fM", Val/1000000);}
1478  else if (fabs(Val)>1000000){return TStr::Fmt("%.1fM", Val/1000000);}
1479  else {return GetKiloStr(Val);}}
1480  static TStr GetGigaStr(const double& Val){
1481  if (fabs(Val)>100*1000000000.0){return TStr::Fmt("%.0fG", Val/1000000000.0);}
1482  else if (fabs(Val)>1000000000.0){return TStr::Fmt("%.1fG", Val/1000000000.0);}
1483  else {return GetMegaStr(Val);}}
1484 };
1485 
1487 // Ascii-Float
1488 class TAscFlt: public TFlt{
1489 public:
1490  TAscFlt(): TFlt(){}
1491  TAscFlt(const double& Val): TFlt(Val){}
1492  explicit TAscFlt(TSIn& SIn): TFlt(SIn, true){}
1493  void Save(TSOut& SOut) const {TFlt::Save(SOut, true);}
1494 };
1495 
1497 // Short-Float
1498 class TSFlt{
1499 public:
1500  sdouble Val;
1501 public:
1502  static const sdouble Mn;
1503  static const sdouble Mx;
1504 
1505  TSFlt(): Val(0){}
1506  TSFlt(const sdouble& _Val): Val(sdouble(_Val)){}
1507  //TSFlt(const double& _Val): Val(sdouble(_Val)){}
1508  operator sdouble() const {return Val;}
1509  //operator double() const {return Val;}
1510  explicit TSFlt(TSIn& SIn){SIn.Load(Val);}
1511  void Save(TSOut& SOut) const {SOut.Save(Val);}
1512  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1513  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1514 
1515  TSFlt& operator=(const TSFlt& SFlt){Val=SFlt.Val; return *this;}
1516  bool operator==(const TSFlt& SFlt) const _CMPWARN {return Val==SFlt.Val;}
1517  bool operator==(const double& Flt) const _CMPWARN {return Val==Flt;}
1518  bool operator!=(const double& Flt) const _CMPWARN {return Val!=Flt;}
1519  bool operator<(const TSFlt& SFlt) const {return Val<SFlt.Val;}
1520  sdouble operator()() const {return Val;}
1521  TSFlt& operator+=(const double& SFlt){Val+=sdouble(SFlt); return *this;}
1522  TSFlt& operator-=(const double& SFlt){Val-=sdouble(SFlt); return *this;}
1523  TSFlt& operator*=(const double& SFlt){Val*=sdouble(SFlt); return *this;}
1524  TSFlt& operator/=(const double& SFlt){Val/=sdouble(SFlt); return *this;}
1525  TSFlt operator++(int){Val++; return *this;}
1526  TSFlt operator--(int){Val--; return *this;}
1527  int GetMemUsed() const {return sizeof(TSFlt);}
1528 
1529  int GetPrimHashCd() const {
1530  int Expn; return int((frexp(Val, &Expn)-0.5)*double(TInt::Mx));}
1531  int GetSecHashCd() const {
1532  int Expn; frexp(Val, &Expn); return Expn;}
1533 };
1534 
1536 // Long-Float
1537 class TLFlt{
1538 public:
1539  ldouble Val;
1540 public:
1541  static const ldouble Mn;
1542  static const ldouble Mx;
1543 
1544  TLFlt(): Val(0){}
1545  TLFlt(const ldouble& _Val): Val(_Val){}
1546  operator ldouble() const {return Val;}
1547  explicit TLFlt(TSIn& SIn){SIn.Load(Val);}
1548  void Save(TSOut& SOut) const {SOut.Save(Val);}
1549  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1550  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1551 
1552  TLFlt& operator=(const TLFlt& LFlt){Val=LFlt.Val; return *this;}
1553  bool operator==(const TLFlt& LFlt) const _CMPWARN {return Val==LFlt.Val;}
1554  bool operator==(const ldouble& LFlt) const _CMPWARN {return Val==LFlt;}
1555  bool operator!=(const ldouble& LFlt) const _CMPWARN {return Val!=LFlt;}
1556  bool operator<(const TLFlt& LFlt) const {return Val<LFlt.Val;}
1557  ldouble operator()() const {return Val;}
1558  TLFlt& operator+=(const ldouble& LFlt){Val+=LFlt; return *this;}
1559  TLFlt& operator-=(const ldouble& LFlt){Val-=LFlt; return *this;}
1560  int GetMemUsed() const {return sizeof(TLFlt);}
1561 
1562  int GetPrimHashCd() const {Fail; return 0;}
1563  int GetSecHashCd() const {Fail; return 0;}
1564 
1565  static TStr GetStr(const ldouble& Val, const int& Width=-1, const int& Prec=-1);
1566  static TStr GetStr(const TLFlt& LFlt, const int& Width=-1, const int& Prec=-1){
1567  return GetStr(LFlt.Val, Width, Prec);}
1568  static TStr GetStr(const ldouble& Val, const char* FmtStr);
1569  static TStr GetStr(const ldouble& Val, const TStr& FmtStr){
1570  return GetStr(Val, FmtStr.CStr());}
1571 };
1572 
1574 // Float-Rectangle
1575 class TFltRect{
1576 public:
1577  TFlt MnX, MnY, MxX, MxY;
1578 public:
1579  TFltRect():
1580  MnX(), MnY(), MxX(), MxY(){}
1581  TFltRect(const TFltRect& FltRect):
1582  MnX(FltRect.MnX), MnY(FltRect.MnY), MxX(FltRect.MxX), MxY(FltRect.MxY){}
1583  TFltRect(
1584  const double& _MnX, const double& _MnY,
1585  const double& _MxX, const double& _MxY):
1586  MnX(_MnX), MnY(_MnY), MxX(_MxX), MxY(_MxY){}
1587  TFltRect(TSIn& SIn):
1588  MnX(SIn), MnY(SIn), MxX(SIn), MxY(SIn){}
1589  void Save(TSOut& SOut) const {
1590  MnX.Save(SOut); MnY.Save(SOut); MxX.Save(SOut); MxY.Save(SOut);}
1591  void LoadXml(const PXmlTok& XmlTok, const TStr& Nm);
1592  void SaveXml(TSOut& SOut, const TStr& Nm) const;
1593 
1594  TFltRect& operator=(const TFltRect& FltRect){
1595  MnX=FltRect.MnX; MnY=FltRect.MnY; MxX=FltRect.MxX; MxY=FltRect.MxY;
1596  return *this;}
1597 
1598  // get coordinates
1599  double GetMnX() const {return MnX;}
1600  double GetMnY() const {return MnY;}
1601  double GetMxX() const {return MxX;}
1602  double GetMxY() const {return MxY;}
1603 
1604  // get lengths
1605  double GetXLen() const {return MxX-MnX;}
1606  double GetYLen() const {return MxY-MnY;}
1607 
1608  // get centers
1609  double GetXCenter() const {return MnX+(MxX-MnX)/2;}
1610  double GetYCenter() const {return MnY+(MxY-MnY)/2;}
1611 
1612  // tests
1613  bool IsXYIn(const double& X, const double& Y) const {
1614  return (MnX<=X)&&(X<=MxX)&&(MnY<=Y)&&(Y<=MxY);}
1615  static bool Intersection(const TFltRect& Rect1, const TFltRect& Rect2);
1616 
1617  // string
1618  TStr GetStr() const;
1619 };
1620 
TSFlt::operator/=
TSFlt & operator/=(const double &SFlt)
Definition: dt.h:1524
IAssert
#define IAssert(Cond)
Definition: bd.h:262
TChAIn::operator=
TChAIn & operator=(const TChAIn &)
TInt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1171
TRStr::CmpI
static int CmpI(const char *CStr1, const char *CStr2)
Definition: dt.cpp:699
TFlt::operator==
bool operator==(const double &Flt) const _CMPWARN
Definition: dt.h:1414
TCh::IsHex
static bool IsHex(const char &Ch)
Definition: dt.h:1070
TStr::GetInt
int GetInt() const
Definition: dt.h:581
TSStr
Definition: bd.h:514
TStr::GetCStr
char * GetCStr() const
Definition: dt.h:688
TStr::IsUInt
bool IsUInt() const
Definition: dt.h:588
TDbStr::operator==
bool operator==(const TDbStr &DbStr) const
Definition: dt.h:739
TStr::TStr
TStr(const PSIn &SIn)
Definition: dt.h:432
TRStr::IsLc
bool IsLc() const
Definition: dt.cpp:672
TStr::Load
void Load(TSIn &SIn, const bool &IsSmall=false)
Definition: dt.h:438
TStr::PutFExtIfEmpty
static TStr PutFExtIfEmpty(const TStr &FNm, const TStr &FExt)
Definition: dt.cpp:1503
TUInt::operator++
TUInt operator++(int)
Definition: dt.h:1261
TStr::TStr
TStr(const char &Ch, bool)
Definition: dt.h:416
TFlt::operator*=
TFlt & operator*=(const double &Flt)
Definition: dt.h:1419
TAscFlt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1493
TStr::SearchCh
int SearchCh(const char &Ch, const int &BChN=0) const
Definition: dt.cpp:1043
TInt::GetHexStr
static TStr GetHexStr(const int &Val)
Definition: dt.h:1217
TStr::GetFromHex
TStr GetFromHex() const
Definition: dt.h:517
TStrIn::GetBf
int GetBf(const void *LBf, const TSize &LBfL)
Definition: dt.cpp:1646
TStr::RStr
TRStr * RStr
Definition: dt.h:414
TFlt::NInf
static const double NInf
Definition: dt.h:1392
TLFlt::operator()
ldouble operator()() const
Definition: dt.h:1557
TMemOut::TMemOut
TMemOut(const PMem &_Mem)
Definition: dt.cpp:334
TUInt::TUInt
TUInt()
Definition: dt.h:1250
TSIn::Len
virtual int Len() const =0
TFlt::GetPrcStr
static TStr GetPrcStr(const double &RelVal, const double &FullVal)
Definition: dt.h:1469
TRnd::Randomize
void Randomize()
Definition: dt.h:60
TStr::GetSubStr
TStr GetSubStr(const int &BChN) const
Definition: dt.h:520
TMemIn::GetCh
char GetCh()
Definition: dt.h:173
TLFlt::operator=
TLFlt & operator=(const TLFlt &LFlt)
Definition: dt.h:1552
TUInt64::operator--
TUInt64 operator--(int)
Definition: dt.h:1344
TMem::Gen
void Gen(const int &_BfL)
Definition: dt.h:123
TSStr::CStr
char * CStr()
Definition: bd.h:531
TFlt::GetMx
static double GetMx(const double &Flt1, const double &Flt2, const double Flt3, const double &Flt4)
Definition: dt.h:1448
TMem::New
static PMem New(const PMem &Mem)
Definition: dt.h:96
TUInt::Mn
static const uint Mn
Definition: dt.h:1246
TInt::GetStr
TStr GetStr() const
Definition: dt.h:1200
IAssertR
#define IAssertR(Cond, Reason)
Definition: bd.h:265
TInt::Kilo
static const int Kilo
Definition: dt.h:1143
TStr::GetSpaceStr
static TStr GetSpaceStr(const int &Spaces)
Definition: dt.cpp:1608
TMem::Pop
char Pop()
Definition: dt.h:139
TUCh::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:1910
TRnd::r
static const int r
Definition: dt.h:15
TCh::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1059
TStr::IsInt64
bool IsInt64() const
Definition: dt.h:596
TLFlt::TLFlt
TLFlt(const ldouble &_Val)
Definition: dt.h:1545
TStr::TStr
TStr(const TChA &ChA)
Definition: dt.h:425
TSFlt::TSFlt
TSFlt(TSIn &SIn)
Definition: dt.h:1510
TUInt64::GetLsVal
uint GetLsVal() const
Definition: dt.h:1352
TFOut::New
static PSOut New(const TStr &FNm, const bool &Append=false)
Definition: fl.cpp:442
TUInt::JavaUIntToCppUInt
static uint JavaUIntToCppUInt(const uint &JavaUInt)
Definition: dt.h:1301
TStr::Len
int Len() const
Definition: dt.h:490
TRStr::ToLc
void ToLc()
Definition: dt.cpp:679
TRStr::CStr
const char * CStr() const
Definition: dt.h:381
ClassHdTP
#define ClassHdTP(TNm, PNm)
Definition: bd.h:135
TStr::GetFMid
TStr GetFMid() const
Definition: dt.cpp:1403
TChA::operator==
bool operator==(const char *_CStr) const
Definition: dt.h:233
TNum::operator--
TNum operator--(int)
Definition: dt.h:884
TChAIn::Eof
bool Eof()
Definition: dt.h:335
TNum::GetMemUsed
int GetMemUsed() const
Definition: dt.h:887
TChA::Resize
void Resize(const int &_MxBfL)
Definition: dt.cpp:348
TMemIn::Reset
void Reset()
Definition: dt.h:176
TUInt64::GetHexStr
static TStr GetHexStr(const TUInt64 &Int)
Definition: dt.h:1365
TDbStr::Save
void Save(TSOut &SOut) const
Definition: dt.h:735
TCh::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1058
TStr::Right
TStr Right(const int &BChN) const
Definition: dt.h:548
TNum< int64 >::operator=
TNum & operator=(const TNum &Int)
Definition: dt.h:908
TRStr::TRStr
TRStr()
Definition: dt.h:351
TChA::operator!=
bool operator!=(const char *_CStr) const
Definition: dt.h:236
TUCh::TUCh
TUCh(TSIn &SIn)
Definition: dt.h:1104
TInt::GetMegaStr
static TStr GetMegaStr(const int &Val)
Definition: dt.h:1226
TFltRect::Save
void Save(TSOut &SOut) const
Definition: dt.h:1589
TMem::SaveMem
void SaveMem(const PSOut &SOut) const
Definition: dt.h:153
TChA::LoadTxt
static void LoadTxt(const PSIn &SIn, TChA &ChA)
Definition: dt.cpp:616
TStr::IsHexInt64
bool IsHexInt64(int64 &Val) const
Definition: dt.h:620
TStr::FromHex
TStr & FromHex()
Definition: dt.cpp:798
TRnd::GetUniDevInt64
int64 GetUniDevInt64(const int64 &Range=0)
Definition: dt.cpp:51
TChA::Ins
void Ins(const int &BChN, const char *CStr)
Definition: dt.cpp:407
TFltRect::GetMnY
double GetMnY() const
Definition: dt.h:1600
TInt::GetStr
static TStr GetStr(const uint64 &Val)
Definition: dt.h:1214
TInt::GetInRng
static int GetInRng(const int &Val, const int &Mn, const int &Mx)
Definition: dt.h:1197
TRnd::GetNextSeed
int GetNextSeed()
Definition: dt.h:17
TUInt64::GetKiloStr
static TStr GetKiloStr(const uint64 &Val)
Definition: dt.h:1368
TCh::IsNum
static bool IsNum(const char &Ch)
Definition: dt.h:1067
TStrIn::BfC
int BfC
Definition: dt.h:704
TStr::IsPrefix
bool IsPrefix(const char *Str) const
Definition: dt.cpp:1081
TChAIn::New
static PSIn New(const TChA &ChA)
Definition: dt.h:332
TRnd
Definition: dt.h:11
TStr::operator+=
TStr & operator+=(const char *CStr)
Definition: dt.h:457
TFltRect
Definition: dt.h:1575
TSInt::TSInt
TSInt(TSIn &SIn)
Definition: dt.h:1128
TSFlt::Mn
static const sdouble Mn
Definition: dt.h:1502
TStrPool::Load
static PStrPool Load(TSIn &SIn, bool LoadCompacted=true)
Definition: dt.h:797
TStr::IsFlt
bool IsFlt() const
Definition: dt.h:630
TInt::GetStr
static TStr GetStr(const int &Val, const TStr &FmtStr)
Definition: dt.h:1205
TSFlt::operator-=
TSFlt & operator-=(const double &SFlt)
Definition: dt.h:1522
TBool::NoStr
static const TStr NoStr
Definition: dt.h:987
TStr::TStr
TStr(const char &Ch1, const char &Ch2, bool)
Definition: dt.h:418
TLFlt::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2280
TUInt::GetStrFromIpUInt
static TStr GetStrFromIpUInt(const uint &Ip)
Definition: dt.cpp:2117
TInt::GetMn
static int GetMn(const int &Int1, const int &Int2, const int &Int3, const int &Int4)
Definition: dt.h:1189
TStr::GetFPath
TStr GetFPath() const
Definition: dt.cpp:1389
TFltRect::operator=
TFltRect & operator=(const TFltRect &FltRect)
Definition: dt.h:1594
TMemIn::New
static PSIn New(const TMem &Mem)
Definition: dt.h:165
TChA::Del
void Del(const int &ChN)
Definition: dt.cpp:414
TRStr::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.cpp:709
TStr::IsHexInt64
bool IsHexInt64() const
Definition: dt.h:621
TInt::Val
int Val
Definition: dt.h:1139
TSFlt::Val
sdouble Val
Definition: dt.h:1500
TUInt::Mx
static const uint Mx
Definition: dt.h:1247
TBool::Rnd
static TRnd Rnd
Definition: dt.h:981
TStr::SearchChBack
int SearchChBack(const char &Ch, int BChN=-1) const
Definition: dt.cpp:1053
ldouble
long double ldouble
Definition: bd.h:16
TMem::Bf
char * Bf
Definition: dt.h:80
TRnd::LoadTxt
static TRnd LoadTxt(TILx &Lx)
Definition: dt.cpp:215
TConv_Pt64Ints32::GetUInt64
uint64 GetUInt64() const
Definition: bd.h:558
TFlt::operator/=
TFlt & operator/=(const double &Flt)
Definition: dt.h:1420
TBool::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:1833
TInt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1153
TStr::IsFlt
bool IsFlt(double &Val) const
Definition: dt.h:629
TFlt::GetMx
static double GetMx(const double &Flt1, const double &Flt2)
Definition: dt.h:1444
TStr::operator!=
bool operator!=(const char *CStr) const
Definition: dt.h:470
TDbStr::TDbStr
TDbStr(const TStr &_Str1, const TStr &_Str2)
Definition: dt.h:733
TMemOut::FlushBf
void FlushBf()
TStr::IsLc
bool IsLc() const
Definition: dt.h:500
TMem::Len
int Len() const
Definition: dt.h:134
TUCh::TUCh
TUCh(const uchar &_Val)
Definition: dt.h:1102
uint
unsigned int uint
Definition: bd.h:11
TInt64
TNum< int64 > TInt64
Definition: dt.h:892
TFltRect::IsXYIn
bool IsXYIn(const double &X, const double &Y) const
Definition: dt.h:1613
TMem::operator=
TMem & operator=(const TMem &Mem)
Definition: dt.h:108
TStr::IsHexInt
bool IsHexInt() const
Definition: dt.h:613
TMOut::GetSIn
PSIn GetSIn(const bool &IsCut=true, const int &CutBfL=-1)
Definition: fl.cpp:881
TFlt::GetStr
static TStr GetStr(const double &Val, const TStr &FmtStr)
Definition: dt.h:1467
TUInt64::GetStr
static TStr GetStr(const TUInt64 &Int)
Definition: dt.h:1364
TInt::GetMx
static int GetMx(const int &Int1, const int &Int2)
Definition: dt.h:1185
TUInt64::TUInt64
TUInt64(const TUInt64 &Int)
Definition: dt.h:1326
TNum::operator()
Base & operator()()
Definition: dt.h:885
TRnd::RndSeed
static const int RndSeed
Definition: dt.h:13
TChA::operator==
bool operator==(const TChA &ChA) const
Definition: dt.h:232
TChA::Empty
bool Empty() const
Definition: dt.h:260
TInt::Mx
static const int Mx
Definition: dt.h:1142
TRnd::TRnd
TRnd(TSIn &SIn)
Definition: dt.h:22
Fail
#define Fail
Definition: bd.h:238
TSFlt::operator!=
bool operator!=(const double &Flt) const _CMPWARN
Definition: dt.h:1518
TStr::EqI
bool EqI(const TStr &Str) const
Definition: dt.h:498
TStr::TStr
TStr(const TStr &Str)
Definition: dt.h:424
TLFlt::operator!=
bool operator!=(const ldouble &LFlt) const _CMPWARN
Definition: dt.h:1555
TRStr::ToCap
void ToCap()
Definition: dt.cpp:685
TStrPool::GetCStr
const char * GetCStr(const uint &Offset) const
Definition: dt.h:814
PStrPool64
TPt< TStrPool64 > PStrPool64
Definition: dt.h:834
TChAIn::BfL
int BfL
Definition: dt.h:325
TStr::GetUc
TStr GetUc() const
Definition: dt.h:496
TCh::NullCh
static const char NullCh
Definition: dt.h:1036
TCh::IsHashCh
static bool IsHashCh(const char &Ch)
Definition: dt.h:1061
TInt::SaveFrugalInt
static char * SaveFrugalInt(char *pDest, int i)
Definition: dt.cpp:1954
TSFlt::operator*=
TSFlt & operator*=(const double &SFlt)
Definition: dt.h:1523
TChA::PutCh
void PutCh(const int &ChN, const char &Ch)
Definition: dt.h:278
TCh::GetHexCh
static char GetHexCh(const int &Val)
Definition: dt.h:1077
TFlt::TFlt
TFlt(TSIn &SIn)
Definition: dt.h:1401
TDbStr::Str2
TStr Str2
Definition: dt.h:728
TInt::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:1923
TMem::New
static PMem New(const TMem &Mem)
Definition: dt.h:95
TChA::Clr
void Clr()
Definition: dt.h:258
TBool::Load
void Load(TSIn &SIn)
Definition: dt.h:994
TUCh::Save
void Save(TSOut &SOut) const
Definition: dt.h:1105
TFlt::Val
double Val
Definition: dt.h:1388
TNum< int64 >::GetStr
TStr GetStr() const
Definition: dt.h:922
TChA::AddCh
void AddCh(const char &Ch, const int &MxLen=-1)
Definition: dt.h:271
TRnd::GetUniDevInt
int GetUniDevInt(const int &MnVal, const int &MxVal)
Definition: dt.h:32
TVoid::operator=
TVoid & operator=(const TVoid &)
Definition: dt.h:966
TFlt::EpsHalf
static const double EpsHalf
Definition: dt.h:1395
TUInt64::operator++
TUInt64 operator++(int)
Definition: dt.h:1343
TCh::TCh
TCh(const char &_Val)
Definition: dt.h:1044
TStr::IsPrefix
bool IsPrefix(const TStr &Str) const
Definition: dt.h:559
TLFlt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1562
TFlt::operator=
TFlt & operator=(const double &Flt)
Definition: dt.h:1412
TStrPool::New
static PStrPool New(const uint &_MxBfLen=0, const uint &_GrowBy=16 *1024 *1024)
Definition: dt.h:794
TChA::IsChIn
bool IsChIn(const char &Ch) const
Definition: dt.h:300
TFlt::IsNum
static bool IsNum(const double &Val)
Definition: dt.h:1454
TInt::SaveFrugalIntV
static void SaveFrugalIntV(TSOut &SOut, const TVec< TInt, int > &IntV)
Definition: dt.cpp:2018
TFlt::GetMegaStr
static TStr GetMegaStr(const double &Val)
Definition: dt.h:1476
TInt::operator-=
TInt & operator-=(const int &Int)
Definition: dt.h:1166
TStrPool::Size
uint Size() const
Definition: dt.h:802
TStr::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:572
TRStr::TRStr
TRStr(const char *CStr, const int &MxLen)
Definition: dt.h:356
TBool::GetYesNoStr
static TStr GetYesNoStr(const bool &Val)
Definition: dt.h:1017
TUCh::operator=
TUCh & operator=(const TUCh &UCh)
Definition: dt.h:1109
TRnd::GetUniDevUInt64
uint64 GetUniDevUInt64(const uint64 &Range=0)
Definition: dt.cpp:57
TNum< int64 >::GetMemUsed
int GetMemUsed() const
Definition: dt.h:915
TDbStr::Empty
bool Empty() const
Definition: dt.h:751
TInt::operator--
TInt operator--(int)
Definition: dt.h:1168
TSInt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1130
TBool::Mx
static const bool Mx
Definition: dt.h:979
TSFlt::TSFlt
TSFlt()
Definition: dt.h:1505
TStr::CmpI
int CmpI(const TStr &Str) const
Definition: dt.h:497
TMemOut::New
static PSOut New(const PMem &Mem)
Definition: dt.h:189
TStr::DelChAll
void DelChAll(const char &Ch)
Definition: dt.cpp:840
TChA::operator+=
TChA & operator+=(const char &Ch)
Definition: dt.h:244
TRnd::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:14
TUInt64::TUInt64
TUInt64(const uint64 &Int)
Definition: dt.h:1327
TSIn::GetBf
virtual int GetBf(const void *Bf, const TSize &BfL)=0
TCh::GetHex
static int GetHex(const char &Ch)
Definition: dt.h:1072
TFltRect::GetMxY
double GetMxY() const
Definition: dt.h:1602
TNum::Val
Base Val
Definition: dt.h:871
TRnd::GetRayleigh
double GetRayleigh(const double &Sigma)
Definition: dt.h:50
TStr::TStr
TStr(const TMem &Mem)
Definition: dt.h:429
TMemIn::Bf
const char * Bf
Definition: dt.h:161
TStr::GetNrFMid
static TStr GetNrFMid(const TStr &FMid)
Definition: dt.cpp:1445
TChA::Len
int Len() const
Definition: dt.h:259
TStr::GetSubStr
TStr GetSubStr(const int &BChN, const int &EChN) const
Definition: dt.cpp:811
TStr::DelStr
bool DelStr(const TStr &Str)
Definition: dt.cpp:863
TMemIn::GetBf
int GetBf(const void *LBf, const TSize &LBfL)
Definition: dt.cpp:318
TFlt::operator+=
TFlt & operator+=(const double &Flt)
Definition: dt.h:1417
TDbStr::operator=
TDbStr & operator=(const TDbStr &DbStr)
Definition: dt.h:737
TBool::GetRnd
static bool GetRnd()
Definition: dt.h:1009
TStr::GetNrFNm
static TStr GetNrFNm(const TStr &FNm)
Definition: dt.cpp:1467
TStr::ToHex
TStr & ToHex()
Definition: dt.cpp:785
TBool::Save
void Save(TSOut &SOut) const
Definition: dt.h:995
TUInt::operator|=
TUInt & operator|=(const TUInt &UInt)
Definition: dt.h:1271
TStrPool64::Cmp
int Cmp(uint64 Offset, const char *Str) const
Definition: dt.h:860
TStr::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:573
TCh::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1056
TChA::SearchStr
int SearchStr(const TChA &Str, const int &BChN=0) const
Definition: dt.cpp:485
TUInt::IsIpv6Str
static bool IsIpv6Str(const TStr &IpStr, const char &SplitCh= ':')
Definition: dt.cpp:2122
TSFlt::operator()
sdouble operator()() const
Definition: dt.h:1520
TFlt::GetMn
static double GetMn(const double &Flt1, const double &Flt2, const double &Flt3)
Definition: dt.h:1439
TChA::operator==
bool operator==(const char &Ch) const
Definition: dt.h:234
TSFlt::operator==
bool operator==(const TSFlt &SFlt) const _CMPWARN
Definition: dt.h:1516
TStr::operator=
TStr & operator=(const char &Ch)
Definition: dt.h:451
TInt::operator==
bool operator==(const TInt &Int) const
Definition: dt.h:1159
TStr::GetHexInt64
int64 GetHexInt64() const
Definition: dt.h:622
TStr::GetFExt
TStr GetFExt() const
Definition: dt.cpp:1421
TStr::IsInt64
bool IsInt64(int64 &Val) const
Definition: dt.h:595
TUCh::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1116
TUInt::GetKiloStr
static TStr GetKiloStr(const uint &Val)
Definition: dt.h:1291
PStrPool
TPt< TStrPool > PStrPool
Definition: dt.h:781
TChA::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
TStrIn::Str
TStr Str
Definition: dt.h:702
TUInt64::Load
void Load(TSIn &SIn)
Definition: dt.h:1334
TNum< int64 >::TNum
TNum(TSIn &SIn)
Definition: dt.h:905
TUInt::IsIpStr
static bool IsIpStr(const TStr &IpStr, uint &Ip, const char &SplitCh= '.')
Definition: dt.cpp:2096
TChA::CStr
const char * CStr() const
Definition: dt.h:256
TChA::Bf
char * Bf
Definition: dt.h:204
TStrV
TVec< TStr, int > TStrV
Definition: dt.h:409
TChA::ToUc
TChA & ToUc()
Definition: dt.cpp:560
TStr::Clr
void Clr()
Definition: dt.h:489
TFltRect::MnX
TFlt MnX
Definition: dt.h:1577
TUInt::operator()
uint & operator()()
Definition: dt.h:1268
TRnd::q
static const int q
Definition: dt.h:15
TRStr::UnRef
void UnRef()
Definition: dt.h:379
TUInt::GetStr
static TStr GetStr(const uint &Val, const TStr &FmtStr)
Definition: dt.h:1288
TNum::operator++
TNum & operator++()
Definition: dt.h:881
TRnd::operator==
bool operator==(const TRnd &) const
Definition: dt.h:28
TNum< int64 >::operator--
TNum operator--(int)
Definition: dt.h:914
TUInt::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2077
TInt::Rnd
static TRnd Rnd
Definition: dt.h:1146
TStr::ToCap
TStr & ToCap()
Definition: dt.cpp:764
TInt::operator!=
bool operator!=(const int &Int) const
Definition: dt.h:1161
TLFlt::operator+=
TLFlt & operator+=(const ldouble &LFlt)
Definition: dt.h:1558
TLFlt::operator-=
TLFlt & operator-=(const ldouble &LFlt)
Definition: dt.h:1559
TUInt::GetStr
static TStr GetStr(const uint &Val)
Definition: dt.h:1283
TFlt::Mx
static const double Mx
Definition: dt.h:1391
TStr::ChangeChAll
int ChangeChAll(const char &SrcCh, const char &DstCh)
Definition: dt.cpp:1113
TFltRect::GetXCenter
double GetXCenter() const
Definition: dt.h:1609
TDbStr::TDbStr
TDbStr(const TDbStr &DbStr)
Definition: dt.h:731
TChA::MxBfL
int MxBfL
Definition: dt.h:203
TSFlt::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2263
TStrIn::Reset
void Reset()
Definition: dt.h:719
TStrPool64
Definition: dt.h:834
TStr::IsHexInt
bool IsHexInt(int &Val) const
Definition: dt.h:612
TBool::operator=
TBool & operator=(const TBool &Bool)
Definition: dt.h:999
TMemIn::New
static PSIn New(const PMem &Mem)
Definition: dt.h:167
TAscFlt::TAscFlt
TAscFlt()
Definition: dt.h:1490
TCh::TCh
TCh(TSIn &SIn)
Definition: dt.h:1046
TBool::YStr
static const TStr YStr
Definition: dt.h:986
TLFlt
Definition: dt.h:1537
TDbStr::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:748
TFlt::GetMx
static double GetMx(const double &Flt1, const double &Flt2, const double Flt3)
Definition: dt.h:1446
TBool::GetValFromStr
static bool GetValFromStr(const TStr &Str)
Definition: dt.cpp:1850
TMemOut::Mem
PMem Mem
Definition: dt.h:184
TRnd::GetExpDevStep
static double GetExpDevStep(const int &Seed, const int &Steps)
Definition: dt.h:68
TFlt
Definition: dt.h:1386
TStr::operator+
friend TStr operator+(const TStr &LStr, const TStr &RStr)
Definition: dt.cpp:1631
TRStr::TRStr
TRStr(const char &Ch)
Definition: dt.h:361
TStr::GetUInt64
uint64 GetUInt64() const
Definition: dt.h:606
TLFlt::Mn
static const ldouble Mn
Definition: dt.h:1541
TCh::operator==
bool operator==(const TCh &Ch) const
Definition: dt.h:1053
TChA::IsStrIn
bool IsStrIn(const TStr &Str) const
Definition: dt.h:292
TMemOut::PutCh
int PutCh(const char &Ch)
Definition: dt.h:193
TStr::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:746
TNum::Save
void Save(TSOut &SOut) const
Definition: dt.h:877
TUInt64::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1345
TSIn
Definition: fl.h:58
TInt::operator=
TInt & operator=(const TInt &Int)
Definition: dt.h:1157
TFlt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1425
TInt::Giga
static const int Giga
Definition: dt.h:1145
TUInt64::TUInt64
TUInt64(TSIn &SIn)
Definition: dt.h:1333
TChAIn::GetCh
char GetCh()
Definition: dt.h:337
TMemOut
Definition: dt.h:182
TSFlt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1531
TStr::GetFlt
double GetFlt() const
Definition: dt.h:631
TRnd::GetGammaDev
double GetGammaDev(const int &Order)
Definition: dt.cpp:95
TChA::operator()
char * operator()()
Definition: dt.h:253
TUInt::GetStr
static TStr GetStr(const TUInt &UInt)
Definition: dt.h:1285
TUInt::GetMegaStr
static TStr GetMegaStr(const uint &Val)
Definition: dt.h:1295
TMem
Definition: dt.h:77
TStr::GetWcMatch
TStr GetWcMatch(const TStr &WcStr, const int &StarStrN=0) const
Definition: dt.cpp:1379
TNum
Definition: dt.h:869
TFltRect::TFltRect
TFltRect(const TFltRect &FltRect)
Definition: dt.h:1581
TStr::SplitOnCh
void SplitOnCh(TStr &LStr, const char &SplitCh, TStr &RStr) const
Definition: dt.cpp:901
TInt::TInt
TInt(TSIn &SIn)
Definition: dt.h:1151
TStr::Optimize
void Optimize()
Definition: dt.cpp:729
TFlt::Save
void Save(TSOut &SOut, const bool &IsTxt) const
Definition: dt.h:1406
TBool::FalseStr
static const TStr FalseStr
Definition: dt.h:983
TUCh::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1115
TChA::LastLastCh
char LastLastCh() const
Definition: dt.h:282
TCh::EofCh
static const char EofCh
Definition: dt.h:1040
ClassTP
#define ClassTP(TNm, PNm)
Definition: bd.h:126
TInt::Mega
static const int Mega
Definition: dt.h:1144
TCh::Mx
static const char Mx
Definition: dt.h:1033
TStr::GetInt64
int64 GetInt64() const
Definition: dt.h:597
TFlt::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2232
TInt::Sign
static int Sign(const int &Int)
Definition: dt.h:1175
TChA::DelLastCh
void DelLastCh()
Definition: dt.h:263
TSFlt::operator+=
TSFlt & operator+=(const double &SFlt)
Definition: dt.h:1521
TChA::Reverse
void Reverse()
Definition: dt.cpp:440
TUInt64::GetMegaStr
static TStr GetMegaStr(const uint64 &Val)
Definition: dt.h:1372
TStrPool::Empty
bool Empty() const
Definition: dt.h:803
TRStr::Bf
char * Bf
Definition: dt.h:348
TStr::IsUInt64
bool IsUInt64(uint64 &Val) const
Definition: dt.h:604
TBool::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1007
TStrPool::Clr
void Clr(bool DoDel=false)
Definition: dt.h:819
TUInt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1255
TStr::GetUInt
uint GetUInt() const
Definition: dt.h:589
TStr::IsInt
bool IsInt(int &Val) const
Definition: dt.h:579
TAscFlt::TAscFlt
TAscFlt(const double &Val)
Definition: dt.h:1491
TLFlt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1563
TStr::IsWs
bool IsWs() const
Definition: dt.cpp:1304
TRStr::CStr
char * CStr()
Definition: dt.h:382
TRnd::Save
void Save(TSOut &SOut) const
Definition: dt.h:23
TStrPool
Definition: dt.h:781
TRStr::Empty
bool Empty() const
Definition: dt.h:383
TFIn::New
static PSIn New(const TStr &FNm)
Definition: fl.cpp:290
TDbStr::TDbStr
TDbStr(TSIn &SIn)
Definition: dt.h:734
TChA::Trunc
void Trunc(const int &_BfL)
Definition: dt.h:267
TMem::GetSIn
PSIn GetSIn() const
Definition: dt.h:146
TCh::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:1876
TStrIn::GetCh
char GetCh()
Definition: dt.h:716
TCh::Load
void Load(TSIn &SIn)
Definition: dt.h:1047
TFlt::GetMn
static double GetMn(const double &Flt1, const double &Flt2, const double &Flt3, const double &Flt4)
Definition: dt.h:1441
TVoid::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:1811
TInt::Mn
static const int Mn
Definition: dt.h:1141
TNum::operator=
TNum & operator=(const TNum &Other)
Definition: dt.h:879
TStr::GetUInt64
uint64 GetUInt64(const uint64 &DfVal) const
Definition: dt.h:608
TMem::Push
void Push(const char &Ch)
Definition: dt.h:138
TFlt::GetKiloStr
static TStr GetKiloStr(const double &Val)
Definition: dt.h:1472
TMem::BfL
int BfL
Definition: dt.h:79
TUInt::operator<<=
TUInt & operator<<=(const int &ShiftBits)
Definition: dt.h:1274
TChA::SearchChBack
int SearchChBack(const char &Ch, int BChN=-1) const
Definition: dt.cpp:477
TCh::IsWs
static bool IsWs(const char &Ch)
Definition: dt.h:1063
TStr::AddToFMid
static TStr AddToFMid(const TStr &FNm, const TStr &ExtFMid)
Definition: dt.cpp:1523
_CMPWARN
#define _CMPWARN
Definition: base.h:31
TRnd::GetWeibull
double GetWeibull(const double &K, const double &Lambda)
Definition: dt.h:53
TMemOut::PutBf
int PutBf(const void *LBf, const TSize &LBfL)
Definition: dt.cpp:336
TBool::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1006
TStr::ChangeStrAll
int ChangeStrAll(const TStr &SrcStr, const TStr &DstStr, const bool &FromStartP=false)
Definition: dt.cpp:1141
TDbStr::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:746
TUInt64::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1347
TDbStr::GetStr
TStr GetStr(const TStr &MidStr=TStr()) const
Definition: dt.h:744
TRStr::TRStr
TRStr(const char *CStr)
Definition: dt.h:354
TNum< int64 >::Load
void Load(TSIn &SIn)
Definition: dt.h:906
TStrPool::LoadShM
static PStrPool LoadShM(TSIn &SIn)
Definition: dt.h:829
TSInt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1131
TFlt::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1423
TUInt::TUInt
TUInt(const uint &_Val)
Definition: dt.h:1251
TStr::TStr
TStr(const TSStr &SStr)
Definition: dt.h:426
TRnd::a
static const int a
Definition: dt.h:15
TStr::GetUsFromYuAscii
TStr GetUsFromYuAscii() const
Definition: dt.h:512
TStr::GetDChStr
static TStr & GetDChStr(const char &Ch1, const char &Ch2)
Definition: dt.cpp:1564
TInt::GetMn
static int GetMn(const int &Int1, const int &Int2)
Definition: dt.h:1183
TStrIn
Definition: dt.h:700
TSFlt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1511
TRnd::GetExpDev
double GetExpDev()
Definition: dt.cpp:83
TChA::CStr
char * CStr()
Definition: dt.h:255
TMem::Save
void Save(TSOut &SOut) const
Definition: dt.h:103
TStr::GetNrAbsFPath
static TStr GetNrAbsFPath(const TStr &FPath, const TStr &BaseFPath=TStr())
Definition: dt.cpp:1471
TConv_Pt64Ints32
Definition: bd.h:539
TChA::IsPrefix
bool IsPrefix(const char *CStr, const int &BChN=0) const
Definition: dt.cpp:499
TStr::IsBool
bool IsBool(bool &Val) const
Definition: dt.cpp:1153
TUInt::operator=
TUInt & operator=(const TUInt &UInt)
Definition: dt.h:1259
TMem::TMem
TMem(const void *_Bf, const int &_BfL)
Definition: dt.h:88
TInt::TInt
TInt()
Definition: dt.h:1148
TInt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1172
TStr::Save
void Save(TSOut &SOut, const bool &IsSmall=false) const
Definition: dt.h:440
TFltRect::MnY
TFlt MnY
Definition: dt.h:1577
TMemOut::Flush
void Flush()
Definition: dt.h:196
TCh
Definition: dt.h:1028
TVoid
Definition: dt.h:958
uint64
unsigned long long uint64
Definition: bd.h:38
TStr::IsInt
bool IsInt() const
Definition: dt.h:580
TCh::TabCh
static const char TabCh
Definition: dt.h:1037
TCh::Mn
static const char Mn
Definition: dt.h:1032
TFlt::TFlt
TFlt(const double &_Val)
Definition: dt.h:1399
TNum< int64 >::Save
void Save(TSOut &SOut) const
Definition: dt.h:907
TMem::~TMem
~TMem()
Definition: dt.h:99
TSFlt::operator=
TSFlt & operator=(const TSFlt &SFlt)
Definition: dt.h:1515
TNum< int64 >::operator--
TNum & operator--()
Definition: dt.h:912
TBool::Get01Str
static TStr Get01Str(const bool &Val)
Definition: dt.h:1019
TFlt::operator==
bool operator==(const TFlt &Flt) const _CMPWARN
Definition: dt.h:1413
TSIn::Load
void Load(bool &Bool)
Definition: fl.h:84
TSFlt::TSFlt
TSFlt(const sdouble &_Val)
Definition: dt.h:1506
TStr::GetHexInt64
int64 GetHexInt64(const int64 &DfVal) const
Definition: dt.h:624
TChA::CountCh
int CountCh(const char &Ch, const int &BChN=0) const
Definition: dt.cpp:462
TRnd::GetNrmDevStep
static double GetNrmDevStep(const int &Seed, const int &Steps)
Definition: dt.h:66
TStrPool::GetStr
TStr GetStr(const uint &Offset) const
Definition: dt.h:812
TSInt::Load
void Load(TSIn &SIn)
Definition: dt.h:1129
TChA::SaveTxt
void SaveTxt(const PSOut &SOut) const
Definition: dt.cpp:622
TNum< int64 >::operator++
TNum operator++(int)
Definition: dt.h:913
TStr::SearchStr
int SearchStr(const TStr &Str, const int &BChN=0) const
Definition: dt.cpp:1065
TStr::IsSuffix
bool IsSuffix(const char *Str) const
Definition: dt.cpp:1093
TStr::IsWcMatch
bool IsWcMatch(const int &StrBChN, const TStr &WcStr, const int &WcStrBChN, TStrV &StarStrV, const char &StarCh='*', const char &QuestCh='?') const
Definition: dt.cpp:1311
TChA::TChA
TChA(const int &_MxBfL=256)
Definition: dt.h:207
TStrIn::New
static PSIn New(const TStr &Str)
Definition: dt.h:711
TRStr::MkRef
void MkRef()
Definition: dt.h:378
TNum::TNum
TNum()
Definition: dt.h:872
TUInt::operator~
TUInt & operator~()
Definition: dt.h:1269
TChAIn::Bf
const char * Bf
Definition: dt.h:324
TRStr::GetCh
char GetCh(const int &ChN) const
Definition: dt.h:388
TILx
Definition: lx.h:129
TInt::GetHexStr
static TStr GetHexStr(const TInt &Int)
Definition: dt.h:1219
TFltRect::MxY
TFlt MxY
Definition: dt.h:1577
TMemIn::TMemIn
TMemIn(const TMem &_Mem, const int &_BfC=0)
Definition: dt.cpp:315
TUInt::IsIpStr
static bool IsIpStr(const TStr &IpStr, const char &SplitCh= '.')
Definition: dt.h:1310
TCh::GetNum
static int GetNum(const char &Ch)
Definition: dt.h:1069
TLFlt::GetStr
static TStr GetStr(const TLFlt &LFlt, const int &Width=-1, const int &Prec=-1)
Definition: dt.h:1566
TUInt::GetStr
TStr GetStr() const
Definition: dt.h:1282
TRnd::GetUniDevUInt
uint GetUniDevUInt(const uint &Range=0)
Definition: dt.cpp:45
TUInt64::operator=
TUInt64 & operator=(const TUInt64 &Int)
Definition: dt.h:1339
TDbStr::Str1
TStr Str1
Definition: dt.h:727
TMemIn::PeekCh
char PeekCh()
Definition: dt.h:174
TStrPool::GetSecHashCd
int GetSecHashCd(const uint &Offset)
Definition: dt.h:827
TStr::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:740
TInt::Load
void Load(TSIn &SIn)
Definition: dt.h:1152
TSize
size_t TSize
Definition: bd.h:58
TChA::LastCh
char LastCh() const
Definition: dt.h:281
TStr::Mid
TStr Mid(const int &BChN, const int &Chs) const
Definition: dt.h:542
TRStr::GetNullRStr
static TRStr * GetNullRStr()
Definition: dt.h:402
TStrPool::New
static PStrPool New(TSIn &SIn)
Definition: dt.h:795
TChAIn::~TChAIn
~TChAIn()
Definition: dt.h:333
TInt::TestFrugalInt
static void TestFrugalInt()
Definition: dt.cpp:1998
Assert
#define Assert(Cond)
Definition: bd.h:251
TStr::operator[]
char operator[](const int &ChN) const
Definition: dt.h:474
TChA::operator[]
char & operator[](const int &ChN)
Definition: dt.h:249
TInt::IsOdd
static bool IsOdd(const int &Int)
Definition: dt.h:1180
TOLx
Definition: lx.h:251
TLFlt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1548
TStr::RightOf
TStr RightOf(const char &SplitCh) const
Definition: dt.cpp:887
TChA::Save
void Save(TSOut &SOut, const bool &SaveCompact=true) const
Definition: dt.h:224
TUInt64::Save
void Save(TSOut &SOut) const
Definition: dt.h:1335
TSFlt
Definition: dt.h:1498
TStr::ConvUsFromYuAscii
TStr & ConvUsFromYuAscii()
Definition: dt.cpp:779
TChA::GetSecHashCd
int GetSecHashCd() const
Definition: dt.cpp:611
TLFlt::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1560
TMem::TMem
TMem(const TMem &Mem)
Definition: dt.h:92
TStr::CStr
const char * CStr() const
Definition: dt.h:480
TMemIn::Eof
bool Eof()
Definition: dt.h:171
TStr::LastCh
char LastCh() const
Definition: dt.h:487
TVoid::TVoid
TVoid(TSIn &)
Definition: dt.h:961
TStr::operator==
bool operator==(const char *CStr) const
Definition: dt.h:466
TFlt::operator--
TFlt operator--(int)
Definition: dt.h:1422
TChA::GetSubStr
TChA GetSubStr(const int &BChN, const int &EChN) const
Definition: dt.cpp:448
TCh::HashCh
static const char HashCh
Definition: dt.h:1041
TRStr::TRStr
TRStr(const char *CStr1, const char *CStr2)
Definition: dt.h:358
TUCh::operator()
uchar operator()() const
Definition: dt.h:1112
TFlt::TFlt
TFlt(TSIn &SIn, const bool &IsTxt)
Definition: dt.h:1403
TCh::TCh
TCh()
Definition: dt.h:1043
TUInt::operator&=
TUInt & operator&=(const TUInt &UInt)
Definition: dt.h:1270
TVoid::operator==
bool operator==(const TVoid &) const
Definition: dt.h:967
TUInt::Load
void Load(TSIn &SIn)
Definition: dt.h:1254
TStr::GetChStr
static TStr & GetChStr(const char &Ch)
Definition: dt.cpp:1551
TMemIn::~TMemIn
~TMemIn()
Definition: dt.h:169
TStr::PutFBaseIfEmpty
static TStr PutFBaseIfEmpty(const TStr &FNm, const TStr &FBase)
Definition: dt.cpp:1515
TStr::IsWord
bool IsWord(const bool &WsPrefixP=true, const bool &FirstUcAllowedP=true) const
Definition: dt.cpp:1292
TStr::GetLc
TStr GetLc() const
Definition: dt.h:502
TBool::Val
bool Val
Definition: dt.h:976
TNum< int64 >::operator++
TNum & operator++()
Definition: dt.h:911
TStr::LoadTxt
static TStr LoadTxt(const TStr &FNm)
Definition: dt.h:671
TUCh::Vals
static const int Vals
Definition: dt.h:1099
TInt::operator<
bool operator<(const int &Int) const
Definition: dt.h:1163
TStr::operator=
TStr & operator=(const TStr &Str)
Definition: dt.h:445
TFltRect::GetYLen
double GetYLen() const
Definition: dt.h:1606
TMem::Trunc
void Trunc(const int &_BfL)
Definition: dt.h:136
TInt::TInt
TInt(const int &_Val)
Definition: dt.h:1149
TCh::operator<
bool operator<(const TCh &Ch) const
Definition: dt.h:1054
TFlt::operator!=
bool operator!=(const double &Flt) const _CMPWARN
Definition: dt.h:1415
TUCh::operator<
bool operator<(const TUCh &UCh) const
Definition: dt.h:1111
TStr::GetUInt
uint GetUInt(const uint &DfVal) const
Definition: dt.h:590
TNum< int64 >::operator-=
TNum & operator-=(const TNum &Int)
Definition: dt.h:910
TInt::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:1928
TStrPool::GetPrimHashCd
int GetPrimHashCd(const uint &Offset)
Definition: dt.h:825
TStrPool64::Load
static PStrPool64 Load(TSIn &SIn, bool LoadCompact=true)
Definition: dt.h:849
TStrIn::Len
int Len() const
Definition: dt.h:715
TStr::GetNrFPath
static TStr GetNrFPath(const TStr &FPath)
Definition: dt.cpp:1430
TChA::TChA
TChA(const TMem &Mem)
Definition: dt.h:216
TRStr::GetMemUsed
int GetMemUsed() const
Definition: dt.h:376
TStr::SaveTxt
void SaveTxt(const TStr &FNm) const
Definition: dt.h:675
TStr::GetNrFExt
static TStr GetNrFExt(const TStr &FExt)
Definition: dt.cpp:1455
TVoid::Save
void Save(TSOut &) const
Definition: dt.h:962
TStrPool::GetMemUsed
::TSize GetMemUsed()
Definition: dt.h:806
TStr::GetNullStr
static TStr GetNullStr()
Definition: dt.cpp:1626
TStr::ToLc
TStr & ToLc()
Definition: dt.cpp:758
TSFlt::Mx
static const sdouble Mx
Definition: dt.h:1503
TChA::operator<
bool operator<(const TChA &ChA) const
Definition: dt.h:238
TDbStr::TDbStr
TDbStr()
Definition: dt.h:730
TInt::GetStr
static TStr GetStr(const int &Val)
Definition: dt.h:1202
TSFlt::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1527
TUInt64::operator-=
TUInt64 & operator-=(const TUInt64 &Int)
Definition: dt.h:1341
TChA::Load
void Load(TSIn &SIn)
Definition: dt.h:222
TStr::operator()
char * operator()()
Definition: dt.h:477
TRStr::Len
int Len() const
Definition: dt.h:384
TFlt::IsNum
bool IsNum() const
Definition: dt.h:1459
TStr::GetRStr
static TRStr * GetRStr(const char *CStr)
Definition: dt.cpp:719
TMem::GetMemUsed
int GetMemUsed() const
Definition: dt.h:121
TFlt::GetGigaStr
static TStr GetGigaStr(const double &Val)
Definition: dt.h:1480
TCh::operator=
TCh & operator=(const TCh &Ch)
Definition: dt.h:1052
TLFlt::TLFlt
TLFlt()
Definition: dt.h:1544
uchar
unsigned char uchar
Definition: bd.h:10
TChA::TChA
TChA(TSIn &SIn)
Definition: dt.h:220
TFltRect::GetMxX
double GetMxX() const
Definition: dt.h:1601
TSOut::SaveBf
void SaveBf(const void *Bf, const TSize &BfL)
Definition: fl.h:172
TStr::GetCh
char GetCh(const int &ChN) const
Definition: dt.h:486
TStrPool64::Len
uint64 Len() const
Definition: dt.h:857
TChA::operator+=
TChA & operator+=(const TMem &Mem)
Definition: dt.cpp:387
TUInt64::TUInt64
TUInt64(const uint &MsVal, const uint &LsVal)
Definition: dt.h:1328
TChA::GetCh
char GetCh(const int &ChN) const
Definition: dt.h:280
TChA::BfL
int BfL
Definition: dt.h:203
TLFlt::operator==
bool operator==(const TLFlt &LFlt) const _CMPWARN
Definition: dt.h:1553
TUInt::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1275
TChA::Trunc
void Trunc()
Definition: dt.cpp:420
TVoid::operator<
bool operator<(const TVoid &) const
Definition: dt.h:968
TFlt::TFlt
TFlt()
Definition: dt.h:1398
TSOut
Definition: fl.h:128
TBool::TBool
TBool(TSIn &SIn)
Definition: dt.h:993
TMem::operator[]
char & operator[](const int &ChN) const
Definition: dt.h:119
TMemIn::BfC
int BfC
Definition: dt.h:162
TUCh::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1113
TBool::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:1838
TStr::TStr
TStr(TSIn &SIn, const bool &IsSmall=false)
Definition: dt.h:436
TStr::operator/
TStr & operator/(const int &N)
Definition: dt.h:461
TStr::DelSubStr
void DelSubStr(const int &BChN, const int &EChN)
Definition: dt.cpp:850
TRStr::GetSecHashCd
int GetSecHashCd() const
Definition: dt.cpp:713
TFlt::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2227
TSInt
Definition: dt.h:1121
TCh::LfCh
static const char LfCh
Definition: dt.h:1038
TStr::GetInt64
int64 GetInt64(const int64 &DfVal) const
Definition: dt.h:599
TChA::operator[]
char operator[](const int &ChN) const
Definition: dt.h:247
TLFlt::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2275
TStr::GetStr
TStr GetStr() const
Definition: dt.h:681
TSOut::Save
void Save(const bool &Bool)
Definition: fl.h:173
TUInt::GetRnd
static uint GetRnd(const uint &Range=0)
Definition: dt.h:1280
TDbStr::TDbStr
TDbStr(const TStr &_Str1)
Definition: dt.h:732
TSInt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1132
TNum::operator=
TNum & operator=(const Base &_Val)
Definition: dt.h:880
TRnd::TRnd
TRnd(const int &_Seed=1, const int &Steps=0)
Definition: dt.h:20
TFlt::Abs
static double Abs(const double &Flt)
Definition: dt.h:1430
TRnd::GetUniDevStep
static double GetUniDevStep(const int &Seed, const int &Steps)
Definition: dt.h:64
TFlt::Round
static int Round(const double &Flt)
Definition: dt.h:1432
TFlt::operator++
TFlt operator++(int)
Definition: dt.h:1421
TInt
Definition: dt.h:1137
TMemIn::GetNextLnBf
bool GetNextLnBf(TChA &LnChA)
Definition: dt.cpp:326
TStr::Left
TStr Left(const int &EChN) const
Definition: dt.h:547
TStr::PutFBase
static TStr PutFBase(const TStr &FNm, const TStr &FBase)
Definition: dt.cpp:1511
TSFlt::operator--
TSFlt operator--(int)
Definition: dt.h:1526
TStrIn::PeekCh
char PeekCh()
Definition: dt.h:717
TXmlTok
Definition: xml.h:198
TRnd::GetPoissonDev
double GetPoissonDev(const double &Mean)
Definition: dt.cpp:121
TChA::ToLc
TChA & ToLc()
Definition: dt.cpp:552
TUInt::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2082
TCh::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:1881
TMem::LoadMem
static void LoadMem(const PSIn &SIn, TMem &Mem)
Definition: dt.h:149
TNum< int64 >::operator+=
TNum & operator+=(const TNum &Int)
Definition: dt.h:909
TRnd::Move
void Move(const int &Steps)
Definition: dt.cpp:29
TMOut
Definition: fl.h:495
TStrPool::New
static PStrPool New(const TStr &fileName)
Definition: dt.h:796
TRnd::SaveTxt
void SaveTxt(TOLx &Lx) const
Definition: dt.cpp:219
TUInt::operator=
TUInt & operator=(const uint &_Val)
Definition: dt.h:1260
TBool::YesStr
static const TStr YesStr
Definition: dt.h:988
TChA
Definition: dt.h:201
TUInt::operator--
TUInt operator--(int)
Definition: dt.h:1262
TStr::GetNumFNm
static TStr GetNumFNm(const TStr &FNm, const int &Num)
Definition: dt.cpp:1527
TUCh::Val
uchar Val
Definition: dt.h:1095
TCh::Save
void Save(TSOut &SOut) const
Definition: dt.h:1048
TInt::Abs
static int Abs(const int &Int)
Definition: dt.h:1174
TUInt64::TUInt64
TUInt64()
Definition: dt.h:1325
TBool::Mn
static const bool Mn
Definition: dt.h:978
TStrPool::Save
void Save(const TStr &FNm)
Definition: dt.h:799
TStrPool64::Reserved
uint64 Reserved() const
Definition: dt.h:858
TLFlt::operator<
bool operator<(const TLFlt &LFlt) const
Definition: dt.h:1556
TUInt
Definition: dt.h:1242
TFltRect::TFltRect
TFltRect()
Definition: dt.h:1579
TFlt::IsNan
bool IsNan() const
Definition: dt.h:1460
TBool::NStr
static const TStr NStr
Definition: dt.h:985
TRnd::GetNrmDev
double GetNrmDev()
Definition: dt.cpp:63
TStr::GetTrunc
TStr GetTrunc() const
Definition: dt.h:509
TRnd::Seed
int Seed
Definition: dt.h:16
TInt::GetRnd
static int GetRnd(const int &Range=0)
Definition: dt.h:1178
TDbStr
Definition: dt.h:725
TMemIn
Definition: dt.h:158
TStr::ToUc
TStr & ToUc()
Definition: dt.cpp:752
TRStr::ConvUsFromYuAscii
void ConvUsFromYuAscii()
Definition: dt.cpp:693
TRnd::PutSeed
void PutSeed(const int &_Seed)
Definition: dt.cpp:18
TRStr::PutCh
void PutCh(const int &ChN, const char &Ch)
Definition: dt.h:386
TCh::IsAlNum
static bool IsAlNum(const char &Ch)
Definition: dt.h:1068
TInt::GetMx
static int GetMx(const int &Int1, const int &Int2, const int &Int3, const int &Int4)
Definition: dt.h:1194
TRStr::Save
void Save(TSOut &SOut, const bool &IsSmall) const
Definition: dt.h:371
sdouble
float sdouble
Definition: bd.h:15
TFltRect::MxX
TFlt MxX
Definition: dt.h:1577
TStr::LeftOf
TStr LeftOf(const char &SplitCh) const
Definition: dt.cpp:873
TInt::operator=
TInt & operator=(const int &Int)
Definition: dt.h:1158
TStr::SplitOnNonAlNum
void SplitOnNonAlNum(TStrV &StrV) const
Definition: dt.cpp:990
TChA::SearchCh
int SearchCh(const char &Ch, const int &BChN=0) const
Definition: dt.cpp:470
TFltRect::GetYCenter
double GetYCenter() const
Definition: dt.h:1610
TInt::operator++
TInt operator++(int)
Definition: dt.h:1167
TInt::LoadFrugalInt
static char * LoadFrugalInt(char *pSrc, int &i)
Definition: dt.cpp:1975
TStrPool::AddStr
uint AddStr(const char *Str)
Definition: dt.h:809
TBool::IsValStr
static bool IsValStr(const TStr &Str)
Definition: dt.cpp:1842
TRnd::GetBinomialDev
double GetBinomialDev(const double &Prb, const int &Trials)
Definition: dt.cpp:154
TChA::AddBf
void AddBf(char *NewBf, const int &BfS)
Definition: dt.h:275
TNum::operator--
TNum & operator--()
Definition: dt.h:882
TFlt::GetMn
static double GetMn(const double &Flt1, const double &Flt2)
Definition: dt.h:1437
TUInt64::GetStr
TStr GetStr() const
Definition: dt.h:1363
TChAIn::Reset
void Reset()
Definition: dt.h:340
TStr::ChangeCh
int ChangeCh(const char &SrcCh, const char &DstCh, const int &BChN=0)
Definition: dt.cpp:1107
TUInt::TUInt
TUInt(TSIn &SIn)
Definition: dt.h:1253
TStr::operator+=
TStr & operator+=(const TStr &Str)
Definition: dt.h:453
TFltRect::TFltRect
TFltRect(TSIn &SIn)
Definition: dt.h:1587
TBool::TBool
TBool()
Definition: dt.h:990
TLFlt::Mx
static const ldouble Mx
Definition: dt.h:1542
int64
long long int64
Definition: bd.h:27
TStr::TStr
TStr(const char *CStr)
Definition: dt.h:427
TStr::Mid
TStr Mid(const int &BChN) const
Definition: dt.h:543
TSFlt::operator++
TSFlt operator++(int)
Definition: dt.h:1525
TStrPool::~TStrPool
~TStrPool()
Definition: dt.h:792
TMem::TMem
TMem(TSIn &SIn)
Definition: dt.h:100
TBool::GetYNStr
static TStr GetYNStr(const bool &Val)
Definition: dt.h:1015
TCh::IsAlpha
static bool IsAlpha(const char &Ch)
Definition: dt.h:1065
TNum< int64 >::Val
int64 Val
Definition: dt.h:896
TStr
Definition: dt.h:412
TSInt::TSInt
TSInt()
Definition: dt.h:1125
TChA::operator=
TChA & operator=(const TChA &ChA)
Definition: dt.cpp:366
TNum< int64 >::TNum
TNum(const TNum &Int)
Definition: dt.h:902
TInt::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1169
TRnd::operator=
TRnd & operator=(const TRnd &Rnd)
Definition: dt.h:27
TStr::Empty
bool Empty() const
Definition: dt.h:491
TMem::New
static PMem New(const int &MxBfL=0)
Definition: dt.h:87
TStr::~TStr
~TStr()
Definition: dt.h:435
TUInt64::Val
uint64 Val
Definition: dt.h:1320
TStr::IsChIn
bool IsChIn(const char &Ch) const
Definition: dt.h:556
TNum< int64 >::GetMegaStr
static TStr GetMegaStr(const int64 &Val)
Definition: dt.h:932
TStr::ToTrunc
TStr & ToTrunc()
Definition: dt.cpp:770
TStr::GetCap
TStr GetCap() const
Definition: dt.h:505
TFlt::GetRnd
static double GetRnd()
Definition: dt.h:1433
TStr::LeftOfLast
TStr LeftOfLast(const char &SplitCh) const
Definition: dt.cpp:880
TNum< int64 >::GetStr
static TStr GetStr(const TNum &Int)
Definition: dt.h:923
TInt::operator<
bool operator<(const TInt &Int) const
Definition: dt.h:1162
TStr::Fmt
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
TChAIn::PeekCh
char PeekCh()
Definition: dt.h:338
TStr::MkClone
static TStr MkClone(const TStr &Str)
Definition: dt.h:691
TUInt64::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2151
TFlt::IsNan
static bool IsNan(const double &Val)
Definition: dt.h:1456
TFlt::operator()
double operator()() const
Definition: dt.h:1416
TChA::Swap
void Swap(const int &ChN1, const int &ChN2)
Definition: dt.cpp:595
TStr::GetHexInt
int GetHexInt(const int &DfVal) const
Definition: dt.h:616
TRnd::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:9
TStr::SplitOnAllCh
void SplitOnAllCh(const char &SplitCh, TStrV &StrV, const bool &SkipEmpty=true) const
Definition: dt.cpp:926
TUInt::Rnd
static TRnd Rnd
Definition: dt.h:1248
TChAIn::BfC
int BfC
Definition: dt.h:325
TFltRect::GetStr
TStr GetStr() const
Definition: dt.cpp:2325
TStrIn::Eof
bool Eof()
Definition: dt.h:714
TSIn::LoadBf
void LoadBf(const void *Bf, const TSize &BfL)
Definition: fl.h:81
TChA::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:361
TAscFlt::TAscFlt
TAscFlt(TSIn &SIn)
Definition: dt.h:1492
TRStr::ToUc
void ToUc()
Definition: dt.cpp:667
TStr::operator=
TStr & operator=(const TChA &ChA)
Definition: dt.h:447
TStr::LoadTxt
static TStr LoadTxt(const PSIn &SIn)
Definition: dt.h:669
TMem::MxBfL
int MxBfL
Definition: dt.h:79
TNum< int64 >::GetFromBufSafe
static int64 GetFromBufSafe(const char *Bf)
Definition: dt.h:945
TStr::operator()
const char * operator()() const
Definition: dt.h:478
TStr::GetFlt
double GetFlt(const double &DfVal) const
Definition: dt.h:633
TChA::IsSuffix
bool IsSuffix(const char *CStr) const
Definition: dt.cpp:518
TFlt::Load
void Load(TSIn &SIn)
Definition: dt.h:1405
TStr::IsUInt
bool IsUInt(uint &Val) const
Definition: dt.h:587
TSInt::TSInt
TSInt(const int16 &_Val)
Definition: dt.h:1126
TNum< int64 >::TNum
TNum(const int64 &Int)
Definition: dt.h:903
TStr::operator=
TStr & operator=(const char *CStr)
Definition: dt.h:449
TStr::GetHex
TStr GetHex() const
Definition: dt.h:515
TCh::CrCh
static const char CrCh
Definition: dt.h:1039
TUInt64::operator*=
TUInt64 & operator*=(const TUInt64 &Int)
Definition: dt.h:1342
TCh::GetUsFromYuAscii
static char GetUsFromYuAscii(const char &Ch)
Definition: dt.cpp:1885
TFltRect::Intersection
static bool Intersection(const TFltRect &Rect1, const TFltRect &Rect2)
Definition: dt.cpp:2317
TStrPool::Cmp
int Cmp(const uint &Offset, const char *Str) const
Definition: dt.h:820
TStrPool64::New
static PStrPool64 New(::TSize MxBfL=0,::TSize GrowBy=16 *1024 *1024)
Definition: dt.h:847
TStr::GetNrNumFExt
static TStr GetNrNumFExt(const int &FExtN)
Definition: dt.cpp:1460
TRnd::GetUniDev
double GetUniDev()
Definition: dt.h:30
TStr::GetStr
static TStr GetStr(const TStr &Str, const TStr &FmtStr)
Definition: dt.h:683
TMem::GenZeros
void GenZeros(const int &_BfL)
Definition: dt.h:125
TStr::operator<
bool operator<(const TStr &Str) const
Definition: dt.h:472
TRStr::TRStr
TRStr(TSIn &SIn, const bool &IsSmall)
Definition: dt.h:368
TBool::GetStr
static TStr GetStr(const bool &Val)
Definition: dt.h:1011
TStrPool::Len
uint Len() const
Definition: dt.h:801
TStrIn::operator=
TStrIn & operator=(const TStrIn &)
TChAIn
Definition: dt.h:322
TRStr::operator=
TRStr & operator=(const TRStr &)
Definition: dt.h:375
TMem::Reserve
void Reserve(const int &_MxBfL, const bool &DoClr=true)
Definition: dt.h:128
TChA::Push
void Push(const char &Ch)
Definition: dt.h:264
TMem::New
static PMem New(const void *Bf, const int &BfL)
Definition: dt.h:91
TVoid::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:1815
TChA::AddChTo
void AddChTo(const char &Ch, const int &ToChN)
Definition: dt.h:273
TChA::TChA
TChA(const TChA &ChA)
Definition: dt.h:213
TVoid::GetMemUsed
int GetMemUsed() const
Definition: dt.h:969
TFlt::Sign
static int Sign(const double &Flt)
Definition: dt.h:1431
TNum::operator++
TNum operator++(int)
Definition: dt.h:883
TUInt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1278
TBool::operator<
bool operator<(const TBool &Bool) const
Definition: dt.h:1001
TPt
Definition: bd.h:196
TFlt::PInf
static const double PInf
Definition: dt.h:1393
TInt::GetStr
static TStr GetStr(const int64 &Val)
Definition: dt.h:1213
TCh::GetStr
static TStr GetStr(const TCh &Ch)
Definition: dt.h:1087
TFlt::GetInRng
static double GetInRng(const double &Val, const double &Mn, const double &Mx)
Definition: dt.h:1451
TNum< int64 >::GetKiloStr
static TStr GetKiloStr(const int64 &Val)
Definition: dt.h:927
TUInt::Val
uint Val
Definition: dt.h:1244
TFltRect::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2311
TInt::LoadFrugalIntV
static void LoadFrugalIntV(TSIn &SIn, TVec< TInt, int > &IntV, bool ClrP=true)
Definition: dt.cpp:2043
TInt::operator==
bool operator==(const int &Int) const
Definition: dt.h:1160
TNum::TNum
TNum(const Base &_Val)
Definition: dt.h:873
TBool::operator==
bool operator==(const TBool &Bool) const
Definition: dt.h:1000
TFlt::GetStr
TStr GetStr() const
Definition: dt.h:1462
TUInt::operator^=
TUInt & operator^=(const TUInt &UInt)
Definition: dt.h:1272
TDbStr::Filled
bool Filled() const
Definition: dt.h:752
TChA::CompressWs
void CompressWs()
Definition: dt.cpp:581
TStr::Reverse
TStr Reverse() const
Definition: dt.h:569
PSIn
TPt< TSIn > PSIn
Definition: fl.h:119
TStr::operator==
bool operator==(const TStr &Str) const
Definition: dt.h:464
int16
short int16
Definition: bd.h:20
TLFlt::Val
ldouble Val
Definition: dt.h:1539
TMem::TMem
TMem(const int &_MxBfL=0)
Definition: dt.h:84
TUInt::operator>>=
TUInt & operator>>=(const int &ShiftBits)
Definition: dt.h:1273
TMemIn::Len
int Len() const
Definition: dt.h:172
TSFlt::operator==
bool operator==(const double &Flt) const _CMPWARN
Definition: dt.h:1517
TUCh::Mx
static const uchar Mx
Definition: dt.h:1098
TMem::GetBf
char * GetBf() const
Definition: dt.h:144
TUInt64::Mn
static const TUInt64 Mn
Definition: dt.h:1322
TStrPool64::Empty
bool Empty() const
Definition: dt.h:856
TUCh::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:1905
TRnd::GetUniDevInt
int GetUniDevInt(const int &Range=0)
Definition: dt.cpp:39
TStr::PutFExt
static TStr PutFExt(const TStr &FNm, const TStr &FExt)
Definition: dt.cpp:1499
TCh::Vals
static const int Vals
Definition: dt.h:1034
TInt::operator+=
TInt & operator+=(const int &Int)
Definition: dt.h:1165
TStr::SplitOnStr
void SplitOnStr(const TStr &SplitStr, TStrV &StrV) const
Definition: dt.cpp:1008
TMem::Empty
bool Empty() const
Definition: dt.h:135
TStrIn::GetNextLnBf
bool GetNextLnBf(TChA &LnChA)
Definition: dt.cpp:1654
TRnd::Check
bool Check()
Definition: dt.cpp:33
TStr::PutCh
void PutCh(const int &ChN, const char &Ch)
Definition: dt.h:482
TChAIn::Len
int Len() const
Definition: dt.h:336
TMemOut::~TMemOut
~TMemOut()
Definition: dt.h:191
TLFlt::GetStr
static TStr GetStr(const ldouble &Val, const int &Width=-1, const int &Prec=-1)
Definition: dt.cpp:2284
TStr::SplitOnWs
void SplitOnWs(TStrV &StrV) const
Definition: dt.cpp:972
TRStr::IsUc
bool IsUc() const
Definition: dt.cpp:660
TRnd::GetGeoDev
int GetGeoDev(const double &Prb)
Definition: dt.h:45
TLFlt::operator==
bool operator==(const ldouble &LFlt) const _CMPWARN
Definition: dt.h:1554
TUInt64::operator+=
TUInt64 & operator+=(const TUInt64 &Int)
Definition: dt.h:1340
TCh::IsUc
static char IsUc(const char &Ch)
Definition: dt.h:1081
TChA::ToTrunc
TChA & ToTrunc()
Definition: dt.cpp:568
TChA::operator!=
bool operator!=(const TChA &ChA) const
Definition: dt.h:235
TFlt::operator=
TFlt & operator=(const TFlt &Flt)
Definition: dt.h:1411
TFlt::Eq6
static bool Eq6(const double &LFlt, const double &RFlt)
Definition: dt.h:1434
TBool::Vals
static const int Vals
Definition: dt.h:980
TStrIn::Bf
char * Bf
Definition: dt.h:703
TRnd::m
static const int m
Definition: dt.h:15
TStr::CStr
char * CStr()
Definition: dt.h:479
TChA::Pop
char Pop()
Definition: dt.h:265
TUInt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1277
TMemIn::BfL
int BfL
Definition: dt.h:162
TFltRect::TFltRect
TFltRect(const double &_MnX, const double &_MnY, const double &_MxX, const double &_MxY)
Definition: dt.h:1583
TLFlt::TLFlt
TLFlt(TSIn &SIn)
Definition: dt.h:1547
TStr::GetHexInt
int GetHexInt() const
Definition: dt.h:614
TRStr::Refs
int Refs
Definition: dt.h:349
TChA::~TChA
~TChA()
Definition: dt.h:219
TStr::TStr
TStr()
Definition: dt.h:423
TCh::operator()
char operator()() const
Definition: dt.h:1055
TFltRect::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2303
TChAIn::GetBf
int GetBf(const void *LBf, const TSize &LBfL)
Definition: dt.cpp:644
TUInt64::GetMsVal
uint GetMsVal() const
Definition: dt.h:1350
TStr::SplitOnLastCh
void SplitOnLastCh(TStr &LStr, const char &SplitCh, TStr &RStr) const
Definition: dt.cpp:912
TFltRect::GetMnX
double GetMnX() const
Definition: dt.h:1599
TChA::TChA
TChA(const char *CStr, const int &StrLen)
Definition: dt.h:211
TInt::GetStr
static TStr GetStr(const uint &Val)
Definition: dt.h:1208
TMemIn::Mem
PMem Mem
Definition: dt.h:160
TLFlt::GetStr
static TStr GetStr(const ldouble &Val, const TStr &FmtStr)
Definition: dt.h:1569
TBool
Definition: dt.h:974
TMem::operator()
char * operator()() const
Definition: dt.h:114
TCh::GetUc
static char GetUc(const char &Ch)
Definition: dt.h:1083
TRStr::TRStr
TRStr(const char &Ch1, const char &Ch2)
Definition: dt.h:363
TStr::Slice
TStr Slice(int BChN, int EChNP1) const
Definition: dt.h:549
TStr::IsStrIn
bool IsStrIn(const TStr &Str) const
Definition: dt.h:557
TVoid::TVoid
TVoid()
Definition: dt.h:960
TCs
Definition: fl.h:11
TStr::GetFBase
TStr GetFBase() const
Definition: dt.cpp:1396
TUInt::GetUIntFromIpStr
static uint GetUIntFromIpStr(const TStr &IpStr, const char &SplitCh= '.')
Definition: dt.cpp:2107
TInt::Swap
static void Swap(int &Int1, int &Int2)
Definition: dt.h:1176
TNum< int64 >::GetHexStr
static TStr GetHexStr(const TNum &Int)
Definition: dt.h:924
TBool::GetStr
static TStr GetStr(const TBool &Bool)
Definition: dt.h:1013
TStrPool64::GetMemUsed
uint64 GetMemUsed() const
Definition: dt.h:854
TChA::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.cpp:607
TStr::IsSuffix
bool IsSuffix(const TStr &Str) const
Definition: dt.h:562
TStr::operator()
TStr operator()(const int &BChN, const int &EChNP1) const
Definition: dt.h:550
TStr::SplitOnAllAnyCh
void SplitOnAllAnyCh(const TStr &SplitChStr, TStrV &StrV, const bool &SkipEmpty=true) const
Definition: dt.cpp:944
TBool::TBool
TBool(const bool &_Val)
Definition: dt.h:991
TStrPool::AddStr
uint AddStr(const TStr &Str)
Definition: dt.h:810
TUInt64::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1348
TStr::InsStr
void InsStr(const int &BChN, const TStr &Str)
Definition: dt.cpp:825
TFlt::GetStr
static TStr GetStr(const TFlt &Flt, const int &Width=-1, const int &Prec=-1)
Definition: dt.h:1464
TSInt::Val
int16 Val
Definition: dt.h:1123
TStrIn::BfL
int BfL
Definition: dt.h:704
TStr::CountCh
int CountCh(const char &Ch, const int &BChN=0) const
Definition: dt.cpp:1033
TBool::TrueStr
static const TStr TrueStr
Definition: dt.h:984
TUInt64::TUInt64
TUInt64(void *Pt)
Definition: dt.h:1330
TSFlt::LoadXml
void LoadXml(const PXmlTok &XmlTok, const TStr &Nm)
Definition: dt.cpp:2258
TNum::TNum
TNum(TSIn &SIn)
Definition: dt.h:875
TStr::GetMemUsed
int GetMemUsed() const
Definition: dt.h:475
TSFlt::GetPrimHashCd
int GetPrimHashCd() const
Definition: dt.h:1529
TNum< int64 >::Mn
static const int64 Mn
Definition: dt.h:898
TStr::IsUc
bool IsUc() const
Definition: dt.h:494
TInt::GetMn
static int GetMn(const int &Int1, const int &Int2, const int &Int3)
Definition: dt.h:1187
TChA::operator!=
bool operator!=(const char &Ch) const
Definition: dt.h:237
TUInt::operator()
uint operator()() const
Definition: dt.h:1267
TChAIn::GetNextLnBf
bool GetNextLnBf(TChA &LnChA)
Definition: dt.cpp:652
TInt::GetStr
static TStr GetStr(const TInt &Int)
Definition: dt.h:1203
TAscFlt
Definition: dt.h:1488
TChA::TChA
TChA(const char *CStr)
Definition: dt.h:209
TSFlt::operator<
bool operator<(const TSFlt &SFlt) const
Definition: dt.h:1519
TUCh::operator==
bool operator==(const TUCh &UCh) const
Definition: dt.h:1110
TStr::RightOfLast
TStr RightOfLast(const char &SplitCh) const
Definition: dt.cpp:894
TSBase::Cs
TCs Cs
Definition: fl.h:44
TUInt64::Mx
static const TUInt64 Mx
Definition: dt.h:1323
TRnd::GetSeed
int GetSeed() const
Definition: dt.h:59
TFlt::GetSecHashCd
int GetSecHashCd() const
Definition: dt.h:1427
TUCh::Mn
static const uchar Mn
Definition: dt.h:1097
TBool::GetMemUsed
int GetMemUsed() const
Definition: dt.h:1004
TFlt::Save
void Save(TSOut &SOut) const
Definition: dt.h:1402
TNum< int64 >::TNum
TNum()
Definition: dt.h:901
TDbStr::operator<
bool operator<(const TDbStr &DbStr) const
Definition: dt.h:741
TStr::IsAbsFPath
static bool IsAbsFPath(const TStr &FPath)
Definition: dt.cpp:1491
TStr::TStr
TStr(const char &Ch)
Definition: dt.h:428
TNum< int64 >::Mx
static const int64 Mx
Definition: dt.h:899
TFlt::operator-=
TFlt & operator-=(const double &Flt)
Definition: dt.h:1418
TUCh::TUCh
TUCh()
Definition: dt.h:1101
TInt::IsEven
static bool IsEven(const int &Int)
Definition: dt.h:1181
TRnd::GetPowerDev
double GetPowerDev(const double &AlphaSlope)
Definition: dt.h:47
TUInt64
Definition: dt.h:1318
TBool::operator()
bool operator()() const
Definition: dt.h:1003
TFlt::Eps
static const double Eps
Definition: dt.h:1394
TStr::IsUInt64
bool IsUInt64() const
Definition: dt.h:605
TMem::New
static PMem New(const TStr &Str)
Definition: dt.h:98
TStr::ChangeStr
int ChangeStr(const TStr &SrcStr, const TStr &DstStr, const int &BChN=0)
Definition: dt.cpp:1130
TRStr::TRStr
TRStr(const int &Len)
Definition: dt.h:352
TFlt::Rnd
static TRnd Rnd
Definition: dt.h:1396
TFlt::Mn
static const double Mn
Definition: dt.h:1390
TInt::operator()
int operator()() const
Definition: dt.h:1164
TVec
Vector is a sequence TVal objects representing an array that can change in size.
Definition: ds.h:430
TRStr
Definition: dt.h:346
TStrIn::~TStrIn
~TStrIn()
Definition: dt.h:712
TCh::Val
char Val
Definition: dt.h:1030
TUCh
Definition: dt.h:1093
TFltRect::GetXLen
double GetXLen() const
Definition: dt.h:1605
TMem::LoadMem
static void LoadMem(const PSIn &SIn, const PMem &Mem)
Definition: dt.h:151
TChA::ChangeCh
void ChangeCh(const char &SrcCh, const char &DstCh)
Definition: dt.cpp:537
TUInt64::SaveXml
void SaveXml(TSOut &SOut, const TStr &Nm) const
Definition: dt.cpp:2156
TInt::GetKiloStr
static TStr GetKiloStr(const int &Val)
Definition: dt.h:1222
TNum::Load
void Load(TSIn &SIn)
Definition: dt.h:876
TStr::SaveTxt
void SaveTxt(const PSOut &SOut) const
Definition: dt.h:673
TStr::GetFNmStr
static TStr GetFNmStr(const TStr &Str, const bool &AlNumOnlyP=true)
Definition: dt.cpp:1531
TStr::GetInt
int GetInt(const int &DfVal) const
Definition: dt.h:582
TChA::GetMemUsed
int GetMemUsed() const
Definition: dt.h:251
TMem::Clr
void Clr(const bool &DoDel=true)
Definition: dt.h:131
TRStr::~TRStr
~TRStr()
Definition: dt.h:365
TInt::GetMx
static int GetMx(const int &Int1, const int &Int2, const int &Int3)
Definition: dt.h:1192