,
"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 autoptr = stoken->
list.begin();
242 autosptr =
next(ptr);
243 for(
i= 1;
i< stoken->
num;
i++, ptr = sptr, sptr =
next(ptr)) {
265 boolend_of_file =
false;
268 while(! end_of_file && (finfo.
str[0] ==
'\n')) {
269finfo.
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') {
282finfo.
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 boolend_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 boolunderscore =
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 constvector<string_view> strandSpecs = {
470 " ",
"ss-",
"ds-",
"ms-" 473 stringcompare(
str);
475 for(
unsigned i= 0;
i< strandSpecs.size(); ++
i) {
476 if(compare.starts_with(strandSpecs[
i])) {
503 static constvector<string_view> topologies = {
504 " ",
"linear ",
"circular ",
"tandem " 507 stringcompare(
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 staticstring_view::const_iterator
678string_view::const_iterator current_it)
680 returnfind_if(current_it, tempString.end(),
isSpace);
684 staticstring_view::const_iterator
686string_view::const_iterator current_it)
688 returnfind_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 autocurrentSubstr = locusLine.substr(it - begin(locusLine), 3);
740 if(currentSubstr ==
"ss-"sv ||
741currentSubstr ==
"ds-"sv ||
742currentSubstr ==
"ms-"sv) {
754 if(it != locusLine.end()) {
761 if(it != locusLine.end()) {
768 if(it != locusLine.end()) {
804 boolbadlocus =
false;
805 if(tokens.num > 2) {
810 if(
StringLen(p) > 78 && p[28] ==
' '&& p[63] ==
' '&& p[67] ==
' ') {
829 autoptr = 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 autoit =
next(ptr);
862 if(it == tokens.list.end() || it->empty() ||
895 autoit = tokens.list.begin();
896 for(
i= 1;
i< tokens.num; ++
i)
903 autoit = tokens.list.begin();
904 for(
i= 1;
i< j; ++
i)
946 if(!
str|| *
str==
'\0')
950 if(*
str>=
'0'&& *
str<=
'9')
961 autopos =
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 ||
1089accession.length() > 15 ||
1090accession[6] !=
'S') {
1095 if(any_of(begin(accession),
1096begin(accession) + 4,
1097[](
const charc) {
return!
isalpha(c); })) {
1102 if(!
isdigit(accession[4]) ||
1111 if(any_of(begin(accession) + 7,
1113[](
const charc) {
return!
isdigit(c); })) {
1118 if(all_of(begin(accession) + 7,
1120[](
const charc) {
returnc ==
'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 autolength = accession.length();
1198all_of(begin(accession) + 2, end(accession), [](
const charc) {
return isdigit(c); })) {
1202 if(length > 12 && length < 16 && accession[6] ==
'S') {
1209 if(accession.substr(0, 3) ==
"NZ_"sv) {
1210accession = accession.substr(3);
1212length = accession.length();
1213 if(length < 12 || length > 17) {
1217 if(
isdigit(accession[4])) {
1218 if(all_of(begin(accession), begin(accession) + 4, [](
const charc) {
return isalpha(c); }) &&
1219all_of(begin(accession) + 4, end(accession), [](
const charc) {
return isdigit(c); })) {
1222 if(any_of(begin(accession) + 6, end(accession), [](
const charc) {
returnc !=
'0'; })) {
1224}
else if(accession[4] ==
'0'&& accession[5] ==
'0') {
1235 if(all_of(begin(accession), begin(accession) + 6, [](
const charc) {
return isalpha(c); }) &&
1236all_of(begin(accession) + 6, end(accession), [](
const charc) {
return isdigit(c); })) {
1238 if(any_of(begin(accession) + 8, end(accession), [](
const charc) {
returnc !=
'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')) ||
1273acc[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 autotbp = 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)
1349accformat = priformat;
1354 if(acnum[
len- 1] ==
';') {
1356acnum[
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) {
1372badac = (
len!= 11 || acnum[0] !=
'N'|| acnum[1] !=
'Z'||
1373acnum[2] !=
'_'|| acnum[3] <
'A'|| acnum[3] >
'Z'||
1374acnum[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) ||
1571acc.starts_with(
"LE"sv) || acc.starts_with(
"LH"sv) ||
1572acc.starts_with(
"LI"sv) || acc.starts_with(
"LJ"sv) ||
1590 if(acc.empty() || acc.length() != 4)
1601 return(c >=
'A'&& c <=
'Z');
1633entry->
drop=
true;
1635 if(skip == 1 && ! tokens.list.empty()) {
1636tokens.list.pop_front();
1639 if(skip == 0 && ! tokens.list.empty()) {
1640 autotail = entry->
secaccs.before_begin();
1643entry->
secaccs.splice_after(tail, tokens.list);
1651 if(tokens.num < 2) {
1654entry->
drop=
true;
1671temp += to_string(entry->
vernum);
1690entry->
drop=
true;
1704}
else if(acc[2] ==
'_') {
1729tokens.list.pop_front();
1730tokens.list.pop_front();
1731entry->
secaccs= std::move(tokens.list);
1742 if(
i== 3 ||
i== 8) {
1745}
else if(
i== 5) {
1746 const char* p = entry->
acnum;
1757entry->
drop=
true;
1783pp->
pbp=
nullptr;
1819pp->
qsfd=
nullptr;
1840 bool done= end_of_file;
1874fprintf(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