SNAP Library 4.1, Developer Reference  2018-07-26 16:30:42
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
ss.cpp
Go to the documentation of this file.
1 //#//////////////////////////////////////////////
2 // Spread-Sheet
3 TStr& TSs::At(const int& X, const int& Y){
4 // Fail;
5  if (Y>=CellStrVV.Len()){CellStrVV.Reserve(Y+1, Y+1);}
6  if (X>=CellStrVV[Y]->Len()){CellStrVV[Y]->V.Reserve(X+1, X+1);}
7  return CellStrVV[Y]->V[X];
8 }
9 
10 void TSs::PutVal(const int& X, const int& Y, const TStr& Str){
11  if (Y>=CellStrVV.Len()){CellStrVV.Reserve(Y+1, Y+1);}
12  if (X>=CellStrVV[Y]->Len()){CellStrVV[Y]->V.Reserve(X+1, X+1);}
13  CellStrVV[Y]->V[X]=Str;
14 }
15 
16 TStr TSs::GetVal(const int& X, const int& Y) const {
17  if ((0<=Y)&&(Y<CellStrVV.Len())){
18  if ((0<=X)&&(X<CellStrVV[Y]->Len())){
19  return CellStrVV[Y]->V[X];
20  } else {
21  return TStr::GetNullStr();
22  }
23  } else {
24  return TStr::GetNullStr();
25  }
26 }
27 
28 int TSs::GetXLen() const {
29  if (CellStrVV.Len()==0){
30  return 0;
31  } else {
32  int MxXLen=CellStrVV[0]->Len();
33  for (int Y=1; Y<CellStrVV.Len(); Y++){
34  MxXLen=TInt::GetMx(MxXLen, CellStrVV[Y]->Len());}
35  return MxXLen;
36  }
37 }
38 
39 int TSs::GetXLen(const int& Y) const {
40  if ((0<=Y)&&(Y<CellStrVV.Len())){
41  return CellStrVV[Y]->Len();
42  } else {
43  return 0;
44  }
45 }
46 
47 int TSs::GetYLen() const {
48  return CellStrVV.Len();
49 }
50 
51 int TSs::SearchX(const int& Y, const TStr& Str) const {
52  return CellStrVV[Y]->V.SearchForw(Str);
53 }
54 
55 int TSs::SearchY(const int& X, const TStr& Str) const {
56  int YLen=GetYLen();
57  for (int Y=0; Y<YLen; Y++){
58  if (Str==GetVal(X, Y)){return Y;}}
59  return -1;
60 }
61 
62 void TSs::DelX(const int& X){
63  int YLen=GetYLen();
64  for (int Y=0; Y<YLen; Y++){
65  CellStrVV[Y]->V.Del(X);
66  }
67 }
68 
69 void TSs::DelY(const int& Y){
70  CellStrVV.Del(Y);
71 }
72 
73 int TSs::GetFldX(const TStr& FldNm, const TStr& NewFldNm, const int& Y) const {
74  if (GetYLen()>Y){
75  int XLen=GetXLen(Y);
76  for (int X=0; X<XLen; X++){
77  if (GetVal(X, Y).GetTrunc()==FldNm){
78  if (!NewFldNm.Empty()){GetVal(X, Y)=NewFldNm;}
79  return X;
80  }
81  }
82  return -1;
83  } else {
84  return -1;
85  }
86 }
87 
88 int TSs::GetFldY(const TStr& FldNm, const TStr& NewFldNm, const int& X) const {
89  for (int Y=0; Y<GetYLen(); Y++){
90  if (GetXLen(Y)>X){
91  if (GetVal(X, Y).GetTrunc()==FldNm){
92  if (!NewFldNm.Empty()){GetVal(X, Y)=NewFldNm;}
93  return Y;
94  }
95  }
96  }
97  return -1;
98 }
99 
101  const TSsFmt& SsFmt, const TStr& FNm,
102  const PNotify& Notify, const bool& IsExcelEoln,
103  const int& MxY, const TIntV& AllowedColNV, const bool& IsQStr){
104  TNotify::OnNotify(Notify, ntInfo, TStr("Loading File ")+FNm+" ...");
105  PSIn SIn=TFIn::New(FNm);
106  PSs Ss=TSs::New();
107  if (!SIn->Eof()){
108  int X=0; int Y=0; int PrevX=-1; int PrevY=-1;
109  char Ch=SIn->GetCh(); TChA ChA;
110  while (!SIn->Eof()){
111  // compose value
112  ChA.Clr();
113  if (IsQStr&&(Ch=='"')){
114  // quoted string ('""' sequence means '"')
115  Ch=SIn->GetCh();
116  forever {
117  while ((!SIn->Eof())&&(Ch!='"')){
118  ChA+=Ch; Ch=SIn->GetCh();}
119  if (Ch=='"'){
120  Ch=SIn->GetCh();
121  if (Ch=='"'){ChA+=Ch; Ch=SIn->GetCh();}
122  else {break;}
123  }
124  }
125  } else {
126  if (SsFmt==ssfTabSep){
127  while ((!SIn->Eof())&&(Ch!='\t')&&(Ch!='\r')&&((Ch!='\n')||IsExcelEoln)){
128  ChA+=Ch; Ch=SIn->GetCh();
129  }
130  } else
131  if (SsFmt==ssfCommaSep){
132  while ((!SIn->Eof())&&(Ch!=',')&&(Ch!='\r')&&((Ch!='\n')||IsExcelEoln)){
133  ChA+=Ch; Ch=SIn->GetCh();
134  }
135  } else
136  if (SsFmt==ssfSemicolonSep){
137  while ((!SIn->Eof())&&(Ch!=';')&&(Ch!='\r')&&((Ch!='\n')||IsExcelEoln)){
138  ChA+=Ch; Ch=SIn->GetCh();
139  }
140  } else
141  if (SsFmt==ssfVBar){
142  while ((!SIn->Eof())&&(Ch!='|')&&(Ch!='\r')&&((Ch!='\n')||IsExcelEoln)){
143  ChA+=Ch; Ch=SIn->GetCh();
144  }
145  } else
146  if (SsFmt==ssfSpaceSep){
147  while ((!SIn->Eof())&&(Ch!=' ')&&(Ch!='\r')&&((Ch!='\n')||IsExcelEoln)){
148  ChA+=Ch; Ch=SIn->GetCh();
149  }
150  } else {
151  Fail;
152  }
153  }
154  // add new line if neccessary
155  if (PrevY!=Y){
156  if ((MxY!=-1)&&(Ss->CellStrVV.Len()==MxY)){break;}
157  Ss->CellStrVV.Add(TStrVP::New()); PrevY=Y;
158  int Recs=Ss->CellStrVV.Len();
159  if (Recs%1000==0){
160  TNotify::OnStatus(Notify, TStr::Fmt(" %d\r", Recs));}
161  }
162  // add value to spreadsheet
163  if (AllowedColNV.Empty()||AllowedColNV.IsIn(X)){
164  Ss->CellStrVV[Y]->V.Add(ChA);
165  }
166  // process delimiters
167  if (SIn->Eof()){
168  break;
169  } else
170  if ((SsFmt==ssfTabSep)&&(Ch=='\t')){
171  X++; Ch=SIn->GetCh();
172  } else
173  if ((SsFmt==ssfCommaSep)&&(Ch==',')){
174  X++; Ch=SIn->GetCh();
175  } else
176  if ((SsFmt==ssfSemicolonSep)&&(Ch==';')){
177  X++; Ch=SIn->GetCh();
178  } else
179  if ((SsFmt==ssfVBar)&&(Ch=='|')){
180  X++; Ch=SIn->GetCh();
181  } else
182  if ((SsFmt==ssfSpaceSep)&&(Ch==' ')){
183  X++; Ch=SIn->GetCh();
184  } else
185  if (Ch=='\r'){
186  if ((PrevX!=-1)&&(X!=PrevX)){
187  TNotify::OnNotify(Notify, ntWarn, "Number of fields is not the same!");}
188  PrevX=X; X=0; Y++; Ch=SIn->GetCh();
189  if ((Ch=='\n')&&(!SIn->Eof())){Ch=SIn->GetCh();}
190  //if (Ss->CellStrVV.Len()%1000==0){Y--; break;}
191  } else
192  if (Ch=='\n'){
193  if ((PrevX!=-1)&&(X!=PrevX)){
194  TNotify::OnNotify(Notify, ntWarn, "Number of fields is not the same!");}
195  PrevX=X; X=0; Y++; Ch=SIn->GetCh();
196  if ((Ch=='\r')&&(!SIn->Eof())){Ch=SIn->GetCh();}
197  //if (Ss->CellStrVV.Len()%1000==0){Y--; break;}
198  } else {
199  Fail;
200  }
201  }
202  }
203  int Recs=Ss->CellStrVV.Len();
204  TNotify::OnNotify(Notify, ntInfo, TStr::Fmt(" %d records read.", Recs));
205  TNotify::OnNotify(Notify, ntInfo, "... Done.");
206  return Ss;
207 }
208 
209 void TSs::SaveTxt(const TStr& FNm, const PNotify&) const {
210  PSOut SOut=TFOut::New(FNm);
211  for (int Y=0; Y<CellStrVV.Len(); Y++){
212  for (int X=0; X<CellStrVV[Y]->Len(); X++){
213  if (X>0){SOut->PutCh('\t');}
214  TStr Str=CellStrVV[Y]->V[X];
215  TChA ChA(Str);
216  for (int ChN=0; ChN<ChA.Len(); ChN++){
217  char Ch=ChA[ChN];
218  if ((Ch=='\t')||(Ch=='\r')||(Ch=='\n')){
219  ChA.PutCh(ChN, ' ');
220  }
221  }
222  SOut->PutStr(ChA);
223  }
224  SOut->PutCh('\r'); SOut->PutCh('\n');
225  }
226 }
227 
229  const TSsFmt& SsFmt, const PSIn& SIn, char& Ch,
230  TStrV& FldValV, const bool& IsExcelEoln, const bool& IsQStr){
231  if (!SIn->Eof()){
232  FldValV.Clr(false); int X=0;
233  if (Ch==TCh::NullCh){Ch=SIn->GetCh();}
234  TChA ChA;
235  while (!SIn->Eof()){
236  // compose value
237  ChA.Clr();
238  if (IsQStr&&(Ch=='"')){
239  // quoted string ('""' sequence means '"')
240  Ch=SIn->GetCh();
241  forever {
242  while ((!SIn->Eof())&&(Ch!='"')){
243  ChA+=Ch; Ch=SIn->GetCh();}
244  if (Ch=='"'){
245  Ch=SIn->GetCh();
246  if (Ch=='"'){ChA+=Ch; Ch=SIn->GetCh();}
247  else {break;}
248  }
249  }
250  } else {
251  if (SsFmt==ssfTabSep){
252  while ((!SIn->Eof())&&(Ch!='\t')&&(Ch!='\r')&&
253  ((Ch!='\n')||IsExcelEoln)){
254  ChA+=Ch; Ch=SIn->GetCh();
255  }
256  if ((!ChA.Empty())&&(ChA.LastCh()=='\"')){
257  ChA.Pop();}
258  } else
259  if (SsFmt==ssfCommaSep){
260  while ((!SIn->Eof())&&(Ch!=',')&&(Ch!='\r')&&
261  ((Ch!='\n')||IsExcelEoln)){
262  ChA+=Ch; Ch=SIn->GetCh();
263  }
264  } else
265  if (SsFmt==ssfSemicolonSep){
266  while ((!SIn->Eof())&&(Ch!=';')&&(Ch!='\r')&&
267  ((Ch!='\n')||IsExcelEoln)){
268  ChA+=Ch; Ch=SIn->GetCh();
269  }
270  } else
271  if (SsFmt==ssfVBar){
272  while ((!SIn->Eof())&&(Ch!='|')&&(Ch!='\r')&&
273  ((Ch!='\n')||IsExcelEoln)){
274  ChA+=Ch; Ch=SIn->GetCh();
275  }
276  } else {
277  Fail;
278  }
279  }
280  // add value to spreadsheet
281  ChA.Trunc();
282  FldValV.Add(ChA);
283  // process delimiters
284  if (SIn->Eof()){
285  break;
286  } else
287  if ((SsFmt==ssfTabSep)&&(Ch=='\t')){
288  X++; Ch=SIn->GetCh();
289  } else
290  if ((SsFmt==ssfCommaSep)&&(Ch==',')){
291  X++; Ch=SIn->GetCh();
292  } else
293  if ((SsFmt==ssfSemicolonSep)&&(Ch==';')){
294  X++; Ch=SIn->GetCh();
295  } else
296  if ((SsFmt==ssfVBar)&&(Ch=='|')){
297  X++; Ch=SIn->GetCh();
298  } else
299  if (Ch=='\r'){
300  Ch=SIn->GetCh();
301  if ((Ch=='\n')&&(!SIn->Eof())){Ch=SIn->GetCh();}
302  break;
303  } else
304  if (Ch=='\n'){
305  X=0; Ch=SIn->GetCh();
306  if ((Ch=='\r')&&(!SIn->Eof())){Ch=SIn->GetCh();}
307  break;
308  } else {
309  Fail;
310  }
311  }
312  }
313 }
314 
316  TStr LcSsFmtNm=SsFmtNm.GetLc();
317  if (LcSsFmtNm=="tab"){return ssfTabSep;}
318  else if (LcSsFmtNm=="comma"){return ssfCommaSep;}
319  else if (LcSsFmtNm=="semicolon"){return ssfSemicolonSep;}
320  else if (LcSsFmtNm=="vbar"){return ssfVBar;}
321  else if (LcSsFmtNm=="space"){return ssfSpaceSep;}
322  else if (LcSsFmtNm=="white"){return ssfWhiteSep;}
323  else {return ssfUndef;}
324 }
325 
327  switch (SsFmt){
328  case ssfTabSep: return "tab";
329  case ssfCommaSep: return "comma";
330  case ssfSemicolonSep: return "semicolon";
331  case ssfVBar: return "vbar";
332  case ssfSpaceSep: return "space";
333  case ssfWhiteSep: return "white";
334  default: return "undef";
335  }
336 }
337 
339  TChA ChA;
340  ChA+='(';
341  ChA+="tab"; ChA+=", ";
342  ChA+="comma"; ChA+=", ";
343  ChA+="semicolon"; ChA+=", ";
344  ChA+="space"; ChA+=", ";
345  ChA+="white"; ChA+=")";
346  return ChA;
347 }
348 
349 //#//////////////////////////////////////////////
350 // Fast-Spread-Sheet-Parser
351 TSsParser::TSsParser(const TStr& FNm, const TSsFmt _SsFmt, const bool& _SkipLeadBlanks, const bool& _SkipCmt, const bool& _SkipEmptyFld) : SsFmt(_SsFmt),
352  SkipLeadBlanks(_SkipLeadBlanks), SkipCmt(_SkipCmt), SkipEmptyFld(_SkipEmptyFld), LineCnt(0), /*Bf(NULL),*/ SplitCh('\t'), LineStr(), FldV(), FInPt(NULL) {
353  if (TZipIn::IsZipExt(FNm.GetFExt())) { FInPt = TZipIn::New(FNm); }
354  else { FInPt = TFIn::New(FNm); }
355  //Bf = new char [BfLen];
356  switch(SsFmt) {
357  case ssfTabSep : SplitCh = '\t'; break;
358  case ssfCommaSep : SplitCh = ','; break;
359  case ssfSemicolonSep : SplitCh = ';'; break;
360  case ssfVBar : SplitCh = '|'; break;
361  case ssfSpaceSep : SplitCh = ' '; break;
362  case ssfWhiteSep: SplitCh = ' '; break;
363  default: FailR("Unknown separator character.");
364  }
365 }
366 
367 TSsParser::TSsParser(const TStr& FNm, const char& Separator, const bool& _SkipLeadBlanks, const bool& _SkipCmt, const bool& _SkipEmptyFld) : SsFmt(ssfSpaceSep),
368  SkipLeadBlanks(_SkipLeadBlanks), SkipCmt(_SkipCmt), SkipEmptyFld(_SkipEmptyFld), LineCnt(0), /*Bf(NULL),*/ SplitCh('\t'), LineStr(), FldV(), FInPt(NULL) {
369  if (TZipIn::IsZipExt(FNm.GetFExt())) { FInPt = TZipIn::New(FNm); }
370  else { FInPt = TFIn::New(FNm); }
371  SplitCh = Separator;
372 }
373 
375  //if (Bf != NULL) { delete [] Bf; }
376 }
377 
378 // Gets and parses the next line.
379 // This version of Next() is older, slower, works with chars.
380 // RS 01/22/13 obsolete, can be removed in the future
381 
382 bool TSsParser::NextSlow() { // split on SplitCh
383  FldV.Clr(false);
384  LineStr.Clr();
385  FldV.Clr();
386  LineCnt++;
387  if (! FInPt->GetNextLn(LineStr)) { return false; }
388  if (SkipCmt && !LineStr.Empty() && LineStr[0]=='#') { return NextSlow(); }
389 
390  char* cur = LineStr.CStr();
391  if (SkipLeadBlanks) { // skip leading blanks
392  while (*cur && TCh::IsWs(*cur)) { cur++; }
393  }
394  char *last = cur;
395  while (*cur) {
396  if (SsFmt == ssfWhiteSep) { while (*cur && ! TCh::IsWs(*cur)) { cur++; } }
397  else { while (*cur && *cur!=SplitCh) { cur++; } }
398  if (*cur == 0) { break; }
399  *cur = 0; cur++;
400  FldV.Add(last); last = cur;
401  if (SkipEmptyFld && strlen(FldV.Last())==0) { FldV.DelLast(); } // skip empty fields
402  }
403 
404  if (*last != 0) { FldV.Add(last); } // add last field
405  if (SkipEmptyFld && FldV.Empty()) { return NextSlow(); } // skip empty lines
406 
407  return true;
408 }
409 
410 // Gets and parses the next line, quick version, works with buffers, not chars.
411 
412 bool TSsParser::Next() { // split on SplitCh
413  FldV.Clr(false);
414  LineStr.Clr();
415  FldV.Clr();
416  LineCnt++;
417  if (! FInPt->GetNextLnBf(LineStr)) { return false; }
418  if (SkipCmt && !LineStr.Empty() && LineStr[0]=='#') { return Next(); }
419 
420  char* cur = LineStr.CStr();
421  if (SkipLeadBlanks) { // skip leading blanks
422  while (*cur && TCh::IsWs(*cur)) { cur++; }
423  }
424  char *last = cur;
425  while (*cur) {
426  if (SsFmt == ssfWhiteSep) { while (*cur && ! TCh::IsWs(*cur)) { cur++; } }
427  else { while (*cur && *cur!=SplitCh) { cur++; } }
428  if (*cur == 0) { break; }
429  *cur = 0; cur++;
430  FldV.Add(last); last = cur;
431  if (SkipEmptyFld && strlen(FldV.Last())==0) { FldV.DelLast(); } // skip empty fields
432  }
433 
434  if (*last != 0) { FldV.Add(last); } // add last field
435  if (SkipEmptyFld && FldV.Empty()) { return Next(); } // skip empty lines
436 
437  return true;
438 }
439 
441  for (int f = 0; f < FldV.Len(); f++) {
442  for (char *c = FldV[f]; *c; c++) {
443  *c = tolower(*c); }
444  }
445 }
446 
447 bool TSsParser::GetInt(const int& FldN, int& Val) const {
448  // parsing format {ws} [+/-] +{ddd}
449  if (FldN >= Len()) { return false; }
450  int _Val = -1;
451  bool Minus=false;
452  const char *c = GetFld(FldN);
453  while (TCh::IsWs(*c)) { c++; }
454  if (*c=='-') { Minus=true; c++; }
455  if (! TCh::IsNum(*c)) { return false; }
456  _Val = TCh::GetNum(*c); c++;
457  while (TCh::IsNum(*c)){
458  _Val = 10 * _Val + TCh::GetNum(*c);
459  c++;
460  }
461  if (Minus) { _Val = -_Val; }
462  if (*c != 0) { return false; }
463  Val = _Val;
464  return true;
465 }
466 
467 bool TSsParser::GetUInt64(const int& FldN, uint64& Val) const {
468  // parsing format {ws} [+]{ddd}
469  if (FldN >= Len()) { return false; }
470  uint64 _Val=0;
471  const char *c = GetFld(FldN);
472  while (TCh::IsWs(*c)){ c++; }
473  if (*c == '+'){ c++; }
474  if (! TCh::IsNum(*c)) { return false; }
475  _Val = TCh::GetNum(*c); c++;
476  while (TCh::IsNum(*c)) {
477  _Val = 10*_Val + TCh::GetNum(*c);
478  c++;
479  }
480  if (*c != 0) { return false; }
481  Val = _Val;
482  return true;
483 }
484 
485 bool TSsParser::GetFlt(const int& FldN, double& Val) const {
486  // parsing format {ws} [+/-] +{d} ([.]{d}) ([E|e] [+/-] +{d})
487  if (FldN >= Len()) { return false; }
488  const char *c = GetFld(FldN);
489  while (TCh::IsWs(*c)) { c++; }
490  if (*c=='+' || *c=='-') { c++; }
491  if (! TCh::IsNum(*c) && *c!='.') { return false; }
492  while (TCh::IsNum(*c)) { c++; }
493  if (*c == '.') {
494  c++;
495  while (TCh::IsNum(*c)) { c++; }
496  }
497  if (*c=='e' || *c == 'E') {
498  c++;
499  if (*c == '+' || *c == '-' ) { c++; }
500  if (! TCh::IsNum(*c)) { return false; }
501  while (TCh::IsNum(*c)) { c++; }
502  }
503  if (*c != 0) { return false; }
504  Val = atof(GetFld(FldN));
505  return true;
506 }
507 
508 const char* TSsParser::DumpStr() const {
509  static TChA ChA(10*1024);
510  ChA.Clr();
511  for (int i = 0; i < FldV.Len(); i++) {
512  ChA += TStr::Fmt(" %d: '%s'\n", i, FldV[i]);
513  }
514  return ChA.CStr();
515 }
516 
int GetYLen() const
Definition: ss.cpp:47
void DelX(const int &X)
Definition: ss.cpp:62
int GetXLen() const
Definition: ss.cpp:28
TSsFmt SsFmt
Separator type.
Definition: ss.h:74
int SearchX(const int &Y, const TStr &Str) const
Definition: ss.cpp:51
bool GetUInt64(const int &FldN, uint64 &Val) const
If the field FldN is a 64-bit unsigned integer its value is returned in Val and the function returns ...
Definition: ss.cpp:467
static PSOut New(const TStr &FNm, const bool &Append=false)
Definition: fl.cpp:442
static PSs LoadTxt(const TSsFmt &SsFmt, const TStr &FNm, const PNotify &Notify=NULL, const bool &IsExcelEoln=true, const int &MxY=-1, const TIntV &AllowedColNV=TIntV(), const bool &IsQStr=true)
Definition: ss.cpp:100
static bool IsNum(const char &Ch)
Definition: dt.h:1064
virtual int PutCh(const char &Ch)=0
bool IsIn(const TVal &Val) const
Checks whether element Val is a member of the vector.
Definition: ds.h:828
#define forever
Definition: bd.h:6
static int GetMx(const int &Int1, const int &Int2)
Definition: dt.h:1182
bool Empty() const
Definition: dt.h:260
#define Fail
Definition: bd.h:238
static const char NullCh
Definition: dt.h:1033
void PutCh(const int &ChN, const char &Ch)
Definition: dt.h:278
void Clr()
Definition: dt.h:258
bool NextSlow()
Loads next line from the input file (older, slow implementation - deprecated).
Definition: ss.cpp:382
TSizeTy Len() const
Returns the number of elements in the vector.
Definition: ds.h:575
uint64 LineCnt
Number of processed lines so far.
Definition: ss.h:78
void ToLc()
Transforms the current line to lower case.
Definition: ss.cpp:440
TSsParser(const TStr &FNm, const TSsFmt _SsFmt=ssfTabSep, const bool &_SkipLeadBlanks=false, const bool &_SkipCmt=true, const bool &_SkipEmptyFld=false)
Constructor.
Definition: ss.cpp:351
static TStr GetSsFmtNmVStr()
Definition: ss.cpp:338
int Len() const
Definition: dt.h:259
Semicolon separated.
Definition: ss.h:8
bool GetInt(const int &FldN, int &Val) const
If the field FldN is an integer its value is returned in Val and the function returns true...
Definition: ss.cpp:447
TStr GetFExt() const
Definition: dt.cpp:1421
Vertical bar separated.
Definition: ss.h:9
TStr GetVal(const int &X, const int &Y) const
Definition: ss.cpp:16
static PSIn New(const TStr &FNm)
Definition: zipfl.cpp:122
const char * GetFld(const int &FldN) const
Returns the contents of the field at index FldN.
Definition: ss.h:129
TSsFmt
Spread-Sheet Separator Format.
Definition: ss.h:5
bool Empty() const
Tests whether the vector is empty.
Definition: ds.h:570
void SaveTxt(const TStr &FNm, const PNotify &Notify=NULL) const
Definition: ss.cpp:209
static PSs New()
Definition: ss.h:23
TVec< char * > FldV
Pointers to fields of the current line.
Definition: ss.h:81
static TSsFmt GetSsFmtFromStr(const TStr &SsFmtNm)
Definition: ss.cpp:315
static PSIn New(const TStr &FNm)
Definition: fl.cpp:290
static bool IsWs(const char &Ch)
Definition: dt.h:1060
TChA LineStr
Current line.
Definition: ss.h:80
void Clr(const bool &DoDel=true, const TSizeTy &NoDelLim=-1)
Clears the contents of the vector.
Definition: ds.h:1022
char * CStr()
Definition: dt.h:255
~TSsParser()
Definition: ss.cpp:374
virtual bool Eof()=0
Definition: ut.h:28
unsigned long long uint64
Definition: bd.h:38
int SearchY(const int &X, const TStr &Str) const
Definition: ss.cpp:55
const char * DumpStr() const
Definition: ss.cpp:508
static int GetNum(const char &Ch)
Definition: dt.h:1066
Whitespace (space or tab) separated.
Definition: ss.h:11
char LastCh() const
Definition: dt.h:281
const TVal & Last() const
Returns a reference to the last element of the vector.
Definition: ds.h:579
Tab separated.
Definition: ss.h:6
TStr GetLc() const
Definition: dt.h:499
int Len() const
Returns the number of fields in the current line.
Definition: ss.h:114
bool GetFlt(const int &FldN, double &Val) const
If the field FldN is a float its value is returned in Val and the function returns true...
Definition: ss.cpp:485
static TStr GetNullStr()
Definition: dt.cpp:1626
#define FailR(Reason)
Definition: bd.h:240
virtual void OnNotify(const TNotifyType &, const TStr &)
Definition: ut.h:38
void Trunc()
Definition: dt.cpp:420
Space separated.
Definition: ss.h:10
PSIn FInPt
Pointer to the input file stream.
Definition: ss.h:82
static bool IsZipExt(const TStr &FNmExt)
Check whether the file extension FNmExt is that of a compressed file (.gz, .7z, .rar, .zip, .cab, .arj. bzip2).
Definition: zipfl.cpp:199
void DelY(const int &Y)
Definition: ss.cpp:69
Definition: dt.h:201
TStr GetTrunc() const
Definition: dt.h:506
TVec< PStrV > CellStrVV
Definition: ss.h:20
Definition: dt.h:412
bool Empty() const
Definition: dt.h:488
static void LoadTxtFldV(const TSsFmt &SsFmt, const PSIn &SIn, char &Ch, TStrV &FldValV, const bool &IsExcelEoln=true, const bool &IsQStr=true)
Definition: ss.cpp:228
virtual void OnStatus(const TStr &)
Definition: ut.h:39
static TStr Fmt(const char *FmtStr,...)
Definition: dt.cpp:1599
Definition: ut.h:28
int PutStr(const char *CStr)
Definition: fl.cpp:117
bool SkipCmt
Skip comments (lines starting with #).
Definition: ss.h:76
bool SkipLeadBlanks
Ignore leading whitespace characters in a line.
Definition: ss.h:75
bool Next()
Loads next line from the input file.
Definition: ss.cpp:412
Definition: bd.h:196
virtual char GetCh()=0
char SplitCh
Separator character (if one of the non-started separators is used)
Definition: ss.h:79
static TStr GetStrFromSsFmt(const TSsFmt &SsFmt)
Definition: ss.cpp:326
static TPt< PVec< TVal > > New()
Definition: ds.h:2184
char Pop()
Definition: dt.h:265
TStr & At(const int &X, const int &Y)
Definition: ss.cpp:3
virtual bool GetNextLnBf(TChA &LnChA)=0
TSizeTy Add()
Adds a new element at the end of the vector, after its current last element.
Definition: ds.h:602
void DelLast()
Removes the last element of the vector.
Definition: ds.h:665
int GetFldY(const TStr &FldNm, const TStr &NewFldNm="", const int &X=0) const
Definition: ss.cpp:88
bool SkipEmptyFld
Skip empty fields (i.e., multiple consecutive separators are considered as one).
Definition: ss.h:77
Definition: ss.h:5
int GetFldX(const TStr &FldNm, const TStr &NewFldNm="", const int &Y=0) const
Definition: ss.cpp:73
Comma separated.
Definition: ss.h:7
bool GetNextLn(TStr &LnStr)
Definition: fl.cpp:43
void PutVal(const int &X, const int &Y, const TStr &Str)
Definition: ss.cpp:10