A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/indx__blk_8cpp_source.html below:

NCBI C++ ToolKit: src/objtools/flatfile/indx_blk.cpp Source File

51 #define THIS_FILE "indx_blk.cpp" 59  " "

,

"single"

,

"double"

,

"mixed"

,

nullptr 63  " "

,

"Linear"

,

"Circular"

,

"Tandem"

,

nullptr 75  " "

,

"NA"

,

"DNA"

,

"genomic DNA"

,

"other DNA"

,

"unassigned DNA"

,

"RNA"

,

76  "mRNA"

,

"rRNA"

,

"tRNA"

,

"uRNA"

,

"scRNA"

,

"snRNA"

,

"snoRNA"

,

"pre-RNA"

,

77  "pre-mRNA"

,

"genomic RNA"

,

"other RNA"

,

"unassigned RNA"

,

"cRNA"

,

78  "viral cRNA"

,

nullptr 82  " "

,

"PRI"

,

"ROD"

,

"MAM"

,

"VRT"

,

"INV"

,

"PLN"

,

"BCT"

,

"RNA"

,

83  "VRL"

,

"PHG"

,

"SYN"

,

"UNA"

,

"EST"

,

"PAT"

,

"STS"

,

"ORG"

,

"GSS"

,

84  "HUM"

,

"HTG"

,

"CON"

,

"HTC"

,

"ENV"

,

"TSA"

,

nullptr 88  "AJ"

,

"AL"

,

"AM"

,

"AN"

,

"AX"

,

"BN"

,

"BX"

,

"CQ"

,

"CR"

,

"CS"

,

"CT"

,

"CU"

,

89  "FB"

,

"FM"

,

"FN"

,

"FO"

,

"FP"

,

"FQ"

,

"FR"

,

"GM"

,

"GN"

,

"HA"

,

"HB"

,

"HC"

,

90  "HD"

,

"HE"

,

"HF"

,

"HG"

,

"HH"

,

"HI"

,

"JA"

,

"JB"

,

"JC"

,

"JD"

,

"JE"

,

"LK"

,

91  "LL"

,

"LM"

,

"LN"

,

"LO"

,

"LP"

,

"LQ"

,

"LR"

,

"LS"

,

"LT"

,

"MP"

,

"MQ"

,

"MR"

,

92  "MS"

,

"OA"

,

"OB"

,

"OC"

,

"OD"

,

"OE"

,

"OU"

,

"OV"

,

"OW"

,

"OX"

,

"OY"

,

"OZ"

,

105  "AB"

,

"AG"

,

"AK"

,

"AP"

,

"AT"

,

"AU"

,

"AV"

,

"BA"

,

"BB"

,

"BD"

,

"BJ"

,

"BP"

,

106  "BR"

,

"BS"

,

"BW"

,

"BY"

,

"CI"

,

"CJ"

,

"DA"

,

"DB"

,

"DC"

,

"DD"

,

"DE"

,

"DF"

,

107  "DG"

,

"DH"

,

"DI"

,

"DJ"

,

"DK"

,

"DL"

,

"DM"

,

"FS"

,

"FT"

,

"FU"

,

"FV"

,

"FW"

,

108  "FX"

,

"FY"

,

"FZ"

,

"GA"

,

"GB"

,

"HT"

,

"HU"

,

"HV"

,

"HW"

,

"HX"

,

"HY"

,

"HZ"

,

109  "LA"

,

"LB"

,

"LC"

,

"LD"

,

"LE"

,

"LF"

,

"LG"

,

"LH"

,

"LI"

,

"LJ"

,

"LU"

,

"LV"

,

110  "LX"

,

"LY"

,

"LZ"

,

"MA"

,

"MB"

,

"MC"

,

"MD"

,

"ME"

,

"OF"

,

"OG"

,

"OH"

,

"OI"

,

111  "OJ"

,

"PA"

,

"PB"

,

"PC"

,

"PD"

,

"PE"

,

"PF"

,

"PG"

,

"PH"

,

"PI"

,

"PJ"

,

"PK"

,

112  "PL"

,

"PM"

,

"PN"

,

"PO"

,

"PW"

,

nullptr 116  "AA"

,

"AC"

,

"AD"

,

"AE"

,

"AF"

,

"AH"

,

"AI"

,

"AQ"

,

"AR"

,

"AS"

,

"AW"

,

"AY"

,

117  "AZ"

,

"BC"

,

"BE"

,

"BF"

,

"BG"

,

"BH"

,

"BI"

,

"BK"

,

"BL"

,

"BM"

,

"BQ"

,

"BT"

,

118  "BU"

,

"BV"

,

"BZ"

,

"CA"

,

"CB"

,

"CC"

,

"CD"

,

"CE"

,

"CF"

,

"CG"

,

"CH"

,

"CK"

,

119  "CL"

,

"CM"

,

"CN"

,

"CO"

,

"CP"

,

"CV"

,

"CW"

,

"CX"

,

"CY"

,

"CZ"

,

"DN"

,

"DP"

,

120  "DQ"

,

"DR"

,

"DS"

,

"DT"

,

"DU"

,

"DV"

,

"DW"

,

"DX"

,

"DY"

,

"DZ"

,

"EA"

,

"EB"

,

121  "EC"

,

"ED"

,

"EE"

,

"EF"

,

"EG"

,

"EH"

,

"EI"

,

"EJ"

,

"EK"

,

"EL"

,

"EM"

,

"EN"

,

122  "EP"

,

"EQ"

,

"ER"

,

"ES"

,

"ET"

,

"EU"

,

"EV"

,

"EW"

,

"EX"

,

"EY"

,

"EZ"

,

"FA"

,

123  "FC"

,

"FD"

,

"FE"

,

"FF"

,

"FG"

,

"FH"

,

"FI"

,

"FJ"

,

"FK"

,

"FL"

,

"GC"

,

"GD"

,

124  "GE"

,

"GF"

,

"GG"

,

"GH"

,

"GJ"

,

"GK"

,

"GL"

,

"GO"

,

"GP"

,

"GQ"

,

"GR"

,

"GS"

,

125  "GT"

,

"GU"

,

"GV"

,

"GW"

,

"GX"

,

"GY"

,

"GZ"

,

"HJ"

,

"HK"

,

"HL"

,

"HM"

,

"HN"

,

126  "HO"

,

"HP"

,

"HQ"

,

"HR"

,

"HS"

,

"JF"

,

"JG"

,

"JH"

,

"JI"

,

"JJ"

,

"JK"

,

"JL"

,

127  "JM"

,

"JN"

,

"JO"

,

"JP"

,

"JQ"

,

"JR"

,

"JS"

,

"JT"

,

"JU"

,

"JV"

,

"JW"

,

"JX"

,

128  "JY"

,

"JZ"

,

"KA"

,

"KB"

,

"KC"

,

"KD"

,

"KE"

,

"KF"

,

"KG"

,

"KH"

,

"KI"

,

"KJ"

,

129  "KK"

,

"KL"

,

"KM"

,

"KN"

,

"KO"

,

"KP"

,

"KQ"

,

"KR"

,

"KS"

,

"KT"

,

"KU"

,

"KV"

,

130  "KX"

,

"KY"

,

"KZ"

,

"MF"

,

"MG"

,

"MH"

,

"MI"

,

"MJ"

,

"MK"

,

"ML"

,

"MM"

,

"MN"

,

131  "MO"

,

"MT"

,

"MU"

,

"MV"

,

"MW"

,

"MX"

,

"MY"

,

"MZ"

,

"OK"

,

"OL"

,

"OM"

,

"ON"

,

132  "OO"

,

"OP"

,

"OQ"

,

"OR"

,

"OS"

,

"OT"

,

"PP"

,

"PQ"

,

"PR"

,

"PS"

,

"PT"

,

"PU"

,

133  "PV"

,

"PX"

,

nullptr 137  "NC_"

,

"NG_"

,

"NM_"

,

"NP_"

,

"NR_"

,

"NT_"

,

"NW_"

,

"XM_"

,

"XP_"

,

"XR_"

,

148  "AF"

,

"AY"

,

"DQ"

,

"EF"

,

"EU"

,

"FJ"

,

"GQ"

,

"HQ"

,

"JF"

,

"JN"

,

"JQ"

,

"JX"

,

149  "KC"

,

"KF"

,

"KJ"

,

"KM"

,

"KP"

,

"KR"

,

"KT"

,

"KU"

,

"KX"

,

"KY"

,

"MF"

,

"MG"

,

150  "MH"

,

"MK"

,

"MN"

,

"MT"

,

nullptr 154  "BK"

,

"BL"

,

"GJ"

,

"GK"

,

nullptr 158  "BR"

,

"HT"

,

"HU"

,

nullptr 162  "GJ"

,

"GK"

,

nullptr 166  "HT"

,

"HU"

,

nullptr 170  "CH"

,

"CT"

,

"CU"

,

"DF"

,

"DG"

,

"DS"

,

171  "EM"

,

"EN"

,

"EP"

,

"EQ"

,

"FA"

,

"FM"

,

172  "GG"

,

"GJ"

,

"GK"

,

"GL"

,

"HT"

,

"HU"

,

173  "JH"

,

"KB"

,

"KD"

,

"KE"

,

"KI"

,

"KK"

,

174  "KL"

,

"KN"

,

"KQ"

,

"KV"

,

"KZ"

,

"LD"

,

190  "Ill"

,

"JAN"

,

"FEB"

,

"MAR"

,

"APR"

,

"MAY"

,

"JUN"

,

"JUL"

,

"AUG"

,

"SEP"

,

"OCT"

,

"NOV"

,

"DEC"

,

nullptr 194  "bp"

,

"bp."

,

"bp,"

,

"AA"

,

"AA."

,

"AA,"

,

nullptr 241  auto

ptr = stoken->

list

.begin();

242  auto

sptr =

next

(ptr);

243  for

(

i

= 1;

i

< stoken->

num

;

i

++, ptr = sptr, sptr =

next

(ptr)) {

265  bool

end_of_file =

false

;

268  while

(! end_of_file && (finfo.

str

[0] ==

'\n'

)) {

269

finfo.

pos

= (size_t)ftell(

fp

);

270  if

(! fgets(finfo.

str

,

sizeof

(finfo.

str

) - 1,

fp

))

276  auto n

= strlen(finfo.

str

);

279  if

(finfo.

str

[

n

] !=

'\n'

&& finfo.

str

[

n

] !=

'\r'

) {

282

finfo.

str

[

n

] = 0;

285  return

(end_of_file);

291  const char

* p =

nullptr

;

300  for

(p = fbuf.

current

, q = res,

i

= 0;

i

<

l

;

i

++, p++) {

302  if

(*p ==

'\n'

|| *p ==

'\r'

) {

316  bool

end_of_file =

false

;

319  while

(! end_of_file && (finfo.

str

[0] ==

'\n'

)) {

327  return

(end_of_file);

348  return

(end_of_file);

354  return SkipTitle

(

fp

, finfo, keyword.data(), keyword.size());

361  const char

* p = keyword.data();

362  size_t len

= keyword.size();

381  const char

* p = locus;

385  for

(; *p !=

'\0'

; p++) {

386  if

((*p >=

'0'

&& *p <=

'9'

) || (*p >=

'A'

&& *p <=

'Z'

) ||

389  if

(((*p >=

'a'

&& *p <=

'z'

) || *p ==

'_'

|| *p ==

'-'

|| *p ==

'('

||

390

*p ==

')'

|| *p ==

'/'

) &&

398  return

(*p !=

'\0'

);

423  bool

underscore =

false

;

427  for

(p = locus, x = y = 0; *p !=

'\0'

; p++) {

428  if

((*p >=

'0'

&& *p <=

'9'

) || (*p >=

'A'

&& *p <=

'Z'

)) {

433

}

else if

(*p ==

'_'

)

439  if

(*p !=

'\0'

|| x == 0 || y == 0) {

456  if

(date[2] ==

'-'

&& date[6] ==

'-'

&&

469  static const

vector<string_view> strandSpecs = {

470  " "

,

"ss-"

,

"ds-"

,

"ms-" 473  string

compare(

str

);

475  for

(

unsigned i

= 0;

i

< strandSpecs.size(); ++

i

) {

476  if

(compare.starts_with(strandSpecs[

i

])) {

503  static const

vector<string_view> topologies = {

504  " "

,

"linear "

,

"circular "

,

"tandem " 507  string

compare(

str

);

509  for

(

unsigned i

= 0;

i

< topologies.size(); ++

i

) {

510  if

(compare.starts_with(topologies[

i

])) {

611  if

(

str

.starts_with(

"NODATE"

sv))

614  if

(

str

.size() > 11 &&

str

[11] !=

'\n'

&&

str

[11] !=

' '

&&

639  for

(p++; *p ==

' '

;)

676 static

string_view::const_iterator

678

string_view::const_iterator current_it)

680  return

find_if(current_it, tempString.end(),

isSpace

);

684 static

string_view::const_iterator

686

string_view::const_iterator current_it)

688  return

find_if_not(current_it, tempString.end(),

isSpace

);

702  if

(locusLine.substr(0, 5) !=

"LOCUS"

sv) {

708  if

(it == locusLine.end()) {

713  if

(it == locusLine.end()) {

719  if

(it == locusLine.end()) {

738  if

((space_it - it) == 3) {

739  auto

currentSubstr = locusLine.substr(it - begin(locusLine), 3);

740  if

(currentSubstr ==

"ss-"

sv ||

741

currentSubstr ==

"ds-"

sv ||

742

currentSubstr ==

"ms-"

sv) {

754  if

(it != locusLine.end()) {

761  if

(it != locusLine.end()) {

768  if

(it != locusLine.end()) {

804  bool

badlocus =

false

;

805  if

(tokens.num > 2) {

810  if

(

StringLen

(p) > 78 && p[28] ==

' '

&& p[63] ==

' '

&& p[67] ==

' '

) {

829  auto

ptr = tokens.list.begin();

832  next

(ptr) != tokens.list.end() && *

next

(ptr) ==

"SV"

s) {

833  for

(

i

= 0, p = finfo.

str

; *p !=

'\0'

; p++)

834  if

(*p ==

';'

&& p[1] ==

' '

)

838  if

(! ptr->empty() && ptr->back() ==

';'

)

844  if

(

i

!= 6 || (tokens.num != 10 && tokens.num != 11)) {

861  auto

it =

next

(ptr);

862  if

(it == tokens.list.end() || it->empty() ||

895  auto

it = tokens.list.begin();

896  for

(

i

= 1;

i

< tokens.num; ++

i

)

903  auto

it = tokens.list.begin();

904  for

(

i

= 1;

i

< j; ++

i

)

946  if

(!

str

|| *

str

==

'\0'

)

950  if

(*

str

>=

'0'

&& *

str

<=

'9'

)

961  auto

pos =

str

.find_last_of(

"0123456789"

);

962  if

(pos != string::npos) {

963  str

.resize(pos + 1);

987  return

(c >=

'A'

&& c <=

'Z'

);

992  const Char

* p = acnum;

994  if

(! p || *p ==

'\0'

)

1018  if

(

isdigit

(p[7]) && p[8] ==

'S'

&&

1026  if

(

isdigit

(p[5]) && p[6] ==

'S'

&&

1045  if

(

i

== 0 || ! accpref)

1048  if

(2 <

i

&&

i

< 10)

1051  const char

**

b

= accpref;

1052  for

(; *

b

;

b

++) {

1067  else if

(accformat == 8)

1069  else if

(accformat == 4)

1074  if

(p[0] >=

'0'

&& p[0] <=

'9'

&& p[1] >=

'0'

&& p[1] <=

'9'

) {

1075  for

(p += 2; *p ==

'0'

;)

1088  if

(accession.length() < 13 ||

1089

accession.length() > 15 ||

1090

accession[6] !=

'S'

) {

1095  if

(any_of(begin(accession),

1096

begin(accession) + 4,

1097

[](

const char

c) {

return

!

isalpha

(c); })) {

1102  if

(!

isdigit

(accession[4]) ||

1111  if

(any_of(begin(accession) + 7,

1113

[](

const char

c) {

return

!

isdigit

(c); })) {

1118  if

(all_of(begin(accession) + 7,

1120

[](

const char

c) {

return

c ==

'0'

; })) {

1129  if

(initialType == -1) {

1133  if

(accession[0] ==

'G'

)

1135  switch

(initialType) {

1147  if

(accession[0] ==

'K'

|| accession[0] ==

'T'

) {

1148  switch

(initialType) {

1160  if

(initialType == 1) {

1161  if

(accession[0] ==

'I'

) {

1164  if

(accession[0] ==

'H'

) {

1194  auto

length = accession.length();

1198

all_of(begin(accession) + 2, end(accession), [](

const char

c) {

return isdigit

(c); })) {

1202  if

(length > 12 && length < 16 && accession[6] ==

'S'

) {

1209  if

(accession.substr(0, 3) ==

"NZ_"

sv) {

1210

accession = accession.substr(3);

1212

length = accession.length();

1213  if

(length < 12 || length > 17) {

1217  if

(

isdigit

(accession[4])) {

1218  if

(all_of(begin(accession), begin(accession) + 4, [](

const char

c) {

return isalpha

(c); }) &&

1219

all_of(begin(accession) + 4, end(accession), [](

const char

c) {

return isdigit

(c); })) {

1222  if

(any_of(begin(accession) + 6, end(accession), [](

const char

c) {

return

c !=

'0'

; })) {

1224

}

else if

(accession[4] ==

'0'

&& accession[5] ==

'0'

) {

1235  if

(all_of(begin(accession), begin(accession) + 6, [](

const char

c) {

return isalpha

(c); }) &&

1236

all_of(begin(accession) + 6, end(accession), [](

const char

c) {

return isdigit

(c); })) {

1238  if

(any_of(begin(accession) + 8, end(accession), [](

const char

c) {

return

c !=

'0'

; })) {

1242  if

(accession[6] ==

'0'

&& accession[7] ==

'0'

) {

1256  if

(! acc || acc[0] ==

'\0'

)

1267  return

(*

b

!=

nullptr

);

1270  if

(acc[0] <

'A'

|| acc[0] >

'Z'

|| acc[1] <

'0'

|| acc[1] >

'9'

||

1271

((acc[3] <

'0'

|| acc[3] >

'9'

) && (acc[3] <

'A'

|| acc[3] >

'Z'

)) ||

1272

((acc[4] <

'0'

|| acc[4] >

'9'

) && (acc[4] <

'A'

|| acc[4] >

'Z'

)) ||

1273

acc[5] <

'0'

|| acc[5] >

'9'

)

1276  if

(acc[0] >=

'O'

&& acc[0] <=

'Q'

) {

1277  if

((acc[2] <

'0'

|| acc[2] >

'9'

) && (acc[2] <

'A'

|| acc[2] >

'Z'

))

1279

}

else if

(acc[2] <

'A'

|| acc[2] >

'Z'

)

1285  if

(acc[0] >=

'O'

&& acc[0] <=

'Q'

)

1288  if

(acc[6] <

'A'

|| acc[6] >

'Z'

|| acc[9] <

'0'

|| acc[9] >

'9'

||

1289

((acc[7] <

'A'

|| acc[7] >

'Z'

) && (acc[7] <

'0'

|| acc[7] >

'9'

)) ||

1290

((acc[8] <

'A'

|| acc[8] >

'Z'

) && (acc[8] <

'0'

|| acc[8] >

'9'

)))

1318  const char

* priacc,

1332  auto

tbp = tokens.

list

.begin();

1336  if

((priformat == 3 || priformat == 4 || priformat == 8) &&

1343  for

(; tbp != tokens.

list

.end(); ++tbp) {

1345  if

(acnum[0] ==

'-'

&& acnum[1] ==

'\0'

)

1348  if

(skip == 2 &&

count

== 0)

1349

accformat = priformat;

1354  if

(acnum[

len

- 1] ==

';'

) {

1356

acnum[

len

] =

'\0'

;

1359  if

(accformat == 1) {

1361

}

else if

(accformat == 2) {

1363

}

else if

(accformat == 3) {

1365

}

else if

(accformat == 8) {

1367

}

else if

(accformat == 4) {

1369

}

else if

(accformat == 5) {

1371

}

else if

(accformat == 6) {

1372

badac = (

len

!= 11 || acnum[0] !=

'N'

|| acnum[1] !=

'Z'

||

1373

acnum[2] !=

'_'

|| acnum[3] <

'A'

|| acnum[3] >

'Z'

||

1374

acnum[4] <

'A'

|| acnum[4] >

'Z'

) ||

1376

}

else if

(accformat == 7) {

1378

}

else if

(accformat == 9) {

1380

}

else if

(accformat == 0) {

1381  if

(

len

!= 6 &&

len

!= 10)

1402  if

(skip == 2 &&

count

== 0 && ! iswgs &&

1403

(accformat == 3 || accformat == 4 || accformat == 8)) {

1416  if

(acc.length() == 2) {

1418  if

(((acc ==

"AR"

sv) || (acc ==

"DZ"

sv) ||

1419

(acc ==

"EA"

sv) || (acc ==

"GC"

sv) ||

1420

(acc ==

"GP"

sv) || (acc ==

"GV"

sv) ||

1421

(acc ==

"GX"

sv) || (acc ==

"GY"

sv) ||

1422

(acc ==

"GZ"

sv) || (acc ==

"HJ"

sv) ||

1423

(acc ==

"HK"

sv) || (acc ==

"HL"

sv) ||

1424

(acc ==

"KH"

sv) || (acc ==

"MI"

sv) ||

1425

(acc ==

"MM"

sv) || (acc ==

"MO"

sv) ||

1426

(acc ==

"MV"

sv) || (acc ==

"MX"

sv) ||

1427

(acc ==

"MY"

sv) || (acc ==

"OO"

sv) ||

1428

(acc ==

"OS"

sv) || (acc ==

"OT"

sv) ||

1429

(acc ==

"PR"

sv) || (acc ==

"PT"

sv) ||

1434  if

(((acc ==

"AX"

sv) || (acc ==

"CQ"

sv) ||

1435

(acc ==

"CS"

sv) || (acc ==

"FB"

sv) ||

1436

(acc ==

"HA"

sv) || (acc ==

"HB"

sv) ||

1437

(acc ==

"HC"

sv) || (acc ==

"HD"

sv) ||

1438

(acc ==

"HH"

sv) || (acc ==

"GM"

sv) ||

1439

(acc ==

"GN"

sv) || (acc ==

"JA"

sv) ||

1440

(acc ==

"JB"

sv) || (acc ==

"JC"

sv) ||

1441

(acc ==

"JD"

sv) || (acc ==

"JE"

sv) ||

1442

(acc ==

"HI"

sv) || (acc ==

"LP"

sv) ||

1443

(acc ==

"LQ"

sv) || (acc ==

"MP"

sv) ||

1444

(acc ==

"MQ"

sv) || (acc ==

"MR"

sv) ||

1449  if

(((acc ==

"BD"

sv) || (acc ==

"DD"

sv) ||

1450

(acc ==

"DI"

sv) || (acc ==

"DJ"

sv) ||

1451

(acc ==

"DL"

sv) || (acc ==

"DM"

sv) ||

1452

(acc ==

"FU"

sv) || (acc ==

"FV"

sv) ||

1453

(acc ==

"FW"

sv) || (acc ==

"FZ"

sv) ||

1454

(acc ==

"GB"

sv) || (acc ==

"HV"

sv) ||

1455

(acc ==

"HW"

sv) || (acc ==

"HZ"

sv) ||

1456

(acc ==

"LF"

sv) || (acc ==

"LG"

sv) ||

1457

(acc ==

"LV"

sv) || (acc ==

"LX"

sv) ||

1458

(acc ==

"LY"

sv) || (acc ==

"LZ"

sv) ||

1459

(acc ==

"MA"

sv) || (acc ==

"MB"

sv) ||

1460

(acc ==

"MC"

sv) || (acc ==

"MD"

sv) ||

1461

(acc ==

"ME"

sv) || (acc ==

"OF"

sv) ||

1462

(acc ==

"OG"

sv) || (acc ==

"OI"

sv) ||

1463

(acc ==

"OJ"

sv) || (acc ==

"PA"

sv) ||

1464

(acc ==

"PB"

sv) || (acc ==

"PC"

sv) ||

1465

(acc ==

"PD"

sv) || (acc ==

"PE"

sv) ||

1466

(acc ==

"PF"

sv) || (acc ==

"PG"

sv) ||

1467

(acc ==

"PH"

sv) || (acc ==

"PI"

sv) ||

1468

(acc ==

"PJ"

sv) || (acc ==

"PK"

sv) ||

1469

(acc ==

"PL"

sv) || (acc ==

"PM"

sv) ||

1470

(acc ==

"PN"

sv) || (acc ==

"PO"

sv) ||

1478  if

(acc.length() == 1 && (acc[0] ==

'I'

|| acc[0] ==

'A'

|| acc[0] ==

'E'

)) {

1479  if

(parseInfo.

all

||

1494  size_t i

= acc.length();

1495  if

(

i

!= 2 &&

i

!= 4)

1499  if

(acc[0] ==

'D'

&&

1502  if

((acc[0] ==

'E'

|| acc[0] ==

'Y'

) &&

1520  if

(acc.empty() || acc.length() != 2)

1544  if

(acc ==

"U"

sv &&

1550  if

(acc.length() != 2 && acc.length() != 4)

1554  if

((acc.length() == 2 &&

1555

((acc ==

"EZ"

sv) || (acc ==

"HP"

sv) ||

1556

(acc ==

"JI"

sv) || (acc ==

"JL"

sv) ||

1557

(acc ==

"JO"

sv) || (acc ==

"JP"

sv) ||

1558

(acc ==

"JR"

sv) || (acc ==

"JT"

sv) ||

1559

(acc ==

"JU"

sv) || (acc ==

"JV"

sv) ||

1560

(acc ==

"JW"

sv) || (acc ==

"KA"

sv))) ||

1570  if

(acc.starts_with(

"FX"

sv) || acc.starts_with(

"LA"

sv) ||

1571

acc.starts_with(

"LE"

sv) || acc.starts_with(

"LH"

sv) ||

1572

acc.starts_with(

"LI"

sv) || acc.starts_with(

"LJ"

sv) ||

1590  if

(acc.empty() || acc.length() != 4)

1601  return

(c >=

'A'

&& c <=

'Z'

);

1633

entry->

drop

=

true

;

1635  if

(skip == 1 && ! tokens.list.empty()) {

1636

tokens.list.pop_front();

1639  if

(skip == 0 && ! tokens.list.empty()) {

1640  auto

tail = entry->

secaccs

.before_begin();

1643

entry->

secaccs

.splice_after(tail, tokens.list);

1651  if

(tokens.num < 2) {

1654

entry->

drop

=

true

;

1671

temp += to_string(entry->

vernum

);

1690

entry->

drop

=

true

;

1704

}

else if

(acc[2] ==

'_'

) {

1729

tokens.list.pop_front();

1730

tokens.list.pop_front();

1731

entry->

secaccs

= std::move(tokens.list);

1742  if

(

i

== 3 ||

i

== 8) {

1745

}

else if

(

i

== 5) {

1746  const char

* p = entry->

acnum

;

1757

entry->

drop

=

true

;

1783

pp->

pbp

=

nullptr

;

1819

pp->

qsfd

=

nullptr

;

1840  bool done

= end_of_file;

1874

fprintf(stderr,

"Unknown flatfile format.\n"

);

#define ERR_ENTRY_Skipped

#define ERR_DATE_IllegalDate

int fta_atoi(string_view sv)

bool fta_StartsWith(const char *s1, string_view s2)

bool StringEquN(const char *s1, const char *s2, size_t n)

bool StringEqu(const char *s1, const char *s2)

void StringCpy(char *d, const char *s)

size_t StringLen(const char *s)

void MemCpy(void *p, const void *q, size_t sz)

void FtaInstallPrefix(int prefix, string_view name, string_view location)

#define FtaErrPost(sev, level,...)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static const char * str(char *buf, int n)

static EAccessionInfo IdentifyAccession(const CTempString &accession, TParseFlags flags=fParse_AnyRaw)

Deduces information from a bare accession a la WHICH_db_accession; may report false negatives on prop...

static E_Choice GetAccType(EAccessionInfo info)

int16_t Int2

2-byte (16-bit) signed integer

int32_t Int4

4-byte (32-bit) signed integer

char Char

Alias for char.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

static int StringToNonNegativeInt(const CTempString str, TStringToNumFlags flags=0)

Convert string to non-negative integer value.

static bool IsBlank(const CTempString str, SIZE_TYPE pos=0)

Check if a string is blank (has no text).

static bool StartsWith(const CTempString str, const CTempString start, ECase use_case=eCase)

Check if a string starts with a specified prefix value.

static bool EqualNocase(const CTempString s1, SIZE_TYPE pos, SIZE_TYPE n, const char *s2)

Case-insensitive equality of a substring with another string.

static string & ToLower(string &str)

Convert string to lower case – string& version.

@ eNocase

Case insensitive compare.

@ eCurrent

Use current time. See also CCurrentTime.

E_Choice

Choice variants.

@ e_Other

for historical reasons, 'other' = 'refseq'

@ e_Tpe

Third Party Annot/Seq EMBL.

@ e_Tpd

Third Party Annot/Seq DDBJ.

@ e_not_set

No variant selected.

@ e_Tpg

Third Party Annot/Seq Genbank.

unsigned int

A callback function used to compare two keys in a database.

@ ParFlat_COL_MOLECULE_NEW

@ ParFlat_COL_TOPOLOGY_NEW

static int s_RefineWGSType(string_view accession, int initialType)

static const char * ParFlat_NA_array_DDBJ[]

bool sIsUpperAlpha(char c)

static const char * ddbj_accpref[]

static const char * ddbj_wgs_accpref[]

static bool sNotAllDigits(const char *first, const char *last)

static const char * ncbi_tpa_accpref[]

NCBI_UNUSED bool SkipTitle(FILE *fp, FinfoBlk &finfo, const char *str, size_t len)

static bool IsWGSAccPrefix(const Parser &parseInfo, string_view acc)

static bool s_IsVDBWGSScaffold(string_view accession)

CSeq_id::E_Choice GetProtAccOwner(string_view acc)

static const set< string_view > k_WgsScaffoldPrefix

static const char * GetResidue(TokenStatBlkPtr stoken)

int fta_if_wgs_acc(string_view accession)

static const char * XML_STRAND_array[]

static const char * ParFlat_NA_array[]

const char ** GetAccArray(Parser::ESource source)

static const char * refseq_accpref[]

bool isSupportedAccession(CSeq_id::E_Choice type)

static bool IsTPAAccPrefix(const Parser &parseInfo, string_view acc)

static const char * acc_tsa_allowed[]

static void IsTSAAccPrefix(const Parser &parseInfo, string_view acc, IndexblkPtr ibp)

int CheckTPG(const string &str)

void ResetParserStruct(ParserPtr pp)

Int2 CheckNA(const char *str)

static const char * sprot_accpref[]

static bool IsPatentedAccPrefix(const Parser &parseInfo, string_view acc)

static const char * XML_TPG_array[]

int CheckSTRAND(const string &str)

bool XMLIndex(ParserPtr pp)

static const char * ParFlat_RESIDUE_STR[]

static const char * ParFlat_DIV_array[]

static Int2 FileGetsBuf(char *res, Int4 size, FileBuf &fbuf)

IndexblkPtr InitialEntry(ParserPtr pp, FinfoBlk &finfo)

bool SprotIndex(ParserPtr pp, void(*fun)(IndexblkPtr entry, char *offset, Int4 len))

static string_view::const_iterator sFindNextSpace(string_view tempString, string_view::const_iterator current_it)

static const char * lanl_accpref[]

void DelNonDigitTail(string &str)

static const char * month_name[]

bool GenBankIndex(ParserPtr pp, void(*fun)(IndexblkPtr entry, char *offset, Int4 len))

static void IsTLSAccPrefix(const Parser &parseInfo, string_view acc, IndexblkPtr ibp)

static bool CheckAccession(TokenStatBlk &tokens, Parser::ESource source, Parser::EMode mode, const char *priacc, unsigned skip)

static string_view::const_iterator sFindNextNonSpace(string_view tempString, string_view::const_iterator current_it)

static const char * ddbj_tpa_accpref[]

Int4 IsNewAccessFormat(const Char *acnum)

static bool CkDateFormat(string_view date)

bool EmblIndex(ParserPtr pp, void(*fun)(IndexblkPtr entry, char *offset, Int4 len))

static const map< Parser::ESource, string > sourceNames

static bool CheckLocusSP(const char *locus)

Int2 XMLCheckTPG(string_view str)

Int2 CheckDIV(const char *str)

bool FlatFileIndex(ParserPtr pp, void(*fun)(IndexblkPtr entry, char *offset, Int4 len))

static void sSetLocusLineOffsets(string_view locusLine, LocusCont &offsets)

bool FindNextEntryBuf(bool end_of_file, FileBuf &fbuf, FinfoBlk &finfo, string_view keyword)

bool GetAccession(const Parser *pp, string_view str, IndexblkPtr entry, unsigned skip)

static const char * ValidMolTypes[]

void CloseFiles(ParserPtr pp)

bool IsSPROTAccession(const char *acc)

static bool isSpace(char c)

static bool sIsAccPrefixChar(char c)

CSeq_id::E_Choice GetNucAccOwner(string_view acc)

Int2 XMLCheckSTRAND(string_view str)

CRef< CDate_std > GetUpdateDate(string_view str, Parser::ESource source)

static bool fta_check_embl_moltype(char *str)

void DelNoneDigitTail(char *str)

bool XReadFileBuf(FileBuf &fbuf, FinfoBlk &finfo)

bool CkLocusLinePos(char *offset, Parser::ESource source, LocusContPtr lcp, bool is_mga)

static bool XReadFile(FILE *fp, FinfoBlk &finfo)

static bool IsValidAccessPrefix(const char *acc, const char **accpref)

void MsgSkipTitleFail(const char *flatfile, FinfoBlk &finfo)

static bool CheckLocus(const char *locus, Parser::ESource source)

static const char * embl_accpref[]

static const char * ncbi_accpref[]

bool SkipTitleBuf(FileBuf &fbuf, FinfoBlk &finfo, string_view keyword)

static const char * ncbi_wgs_accpref[]

static bool fta_if_master_wgs_accession(const char *acnum, Int4 accformat)

Int2 CheckNADDBJ(const char *str)

static const char * ParFlat_AA_array_DDBJ[]

#define ERR_FORMAT_BadlyFormattedIDLine

#define ERR_ACCESSION_WGSProjectAccIsPri

#define ERR_ACCESSION_NoAccessNum

#define ERR_FORMAT_LocusLinePosition

#define ERR_LOCUS_BadLocusName

#define ERR_ACCESSION_BadAccessNum

#define ERR_FORMAT_IllegalCAGEMoltype

#define ERR_LOCUS_NoLocusName

#define ERR_FORMAT_InvalidIDlineMolType

if(yy_accept[yy_current_state])

const struct ncbi::grid::netcache::search::fields::SIZE size

const CharType(& source)[N]

static PCRE2_SIZE * offsets

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

CRef< objects::CDate_std > date

vector< IndexblkPtr > entrylist

Int2 StringMatchIcase(const Char **array, string_view text)

CRef< CDate_std > get_full_date(string_view date_view, bool is_ref, Parser::ESource source)

Int2 MatchArraySubString(const Char **array, string_view text)

Int2 fta_StringMatch(const Char **array, string_view text)

TokenStatBlk TokenString(string_view str, Char delimiter)

bool ParseAccessionRange(TokenStatBlk &tsbp, unsigned skip)


RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4