AjBool embMiscMatchPatternDelimC (const AjPStr str, const AjPStr pattern,
const char* delim)
{
char whiteSpace[] = " \t\n\r"; /* skip whitespace */
AjPStrTok tokens;
AjPStr delimstr = NULL;
AjPStr key = NULL;
AjBool val = ajFalse;
delimstr = ajStrNewC(whiteSpace);
ajStrAppendC(&delimstr, delim);
tokens = ajStrTokenNewS(pattern, delimstr);
while (ajStrTokenNextParse( &tokens, &key))
if (ajStrMatchWildCaseS(str, key))
{
val = ajTrue;
break;
}
ajStrTokenDel( &tokens);
ajStrDel(&key);
ajStrDel(&delimstr);
return val;
}
int main(int argc, char *argv[])
{
embInitPV("gseqinfo", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr numA = NULL;
AjPStr numT = NULL;
AjPStr numG = NULL;
AjPStr numC = NULL;
AjPStrTok handle = NULL;
ajint n;
char *in0;
char *result;
AjBool show = 0;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetOutfile("outfile");
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__seqinfo(
&soap,
NULL,
NULL,
in0,
&result
) == SOAP_OK)
{
tmp = ajStrNewC(result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while(ajStrTokenNextParse(handle, &parse))
{
if(ajStrIsInt(parse))
if(!numA)
numA = ajStrNewS(parse);
else if(!numT)
numT = ajStrNewS(parse);
else if(!numG)
numG = ajStrNewS(parse);
else if(!numC)
numC = ajStrNewS(parse);
}
if(show)
ajFmtPrint("Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
else
ajFmtPrintF(outf, "Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
static AjBool extractfeat_MatchFeature(const AjPFeature gf,
const AjPStr source,
const AjPStr type, ajint sense,
AjBool testscore, float minscore,
float maxscore, const AjPStr tag,
const AjPStr value, AjBool *tagsmatch)
{
AjPStrTok tokens = NULL;
AjPStr key = NULL;
AjBool val = ajFalse;
/*
** is this a child of a join() ?
** if it is a child, then we use the previous result of MatchPatternTags
*/
if(!ajFeatIsMultiple(gf) || !ajFeatIsChild(gf))
*tagsmatch = extractfeat_MatchPatternTags(gf, tag, value);
/* ignore remote IDs */
/*
** No - don't reject remote IDs here. We want to include all features
** in this routine so that we can reject a whole join later on if any one
** member of the join is remote.
** if(!ajFeatIsLocal(gf))
** return ajFalse;
*/
/* check source, type, sense, score, tags, values */
/* Special values indication that we match anything:
** for strings, '*'
** for sense, 0
** for score, maxscore <= minscore
*/
ajDebug("extractfeat_MatchFeature\n");
ajDebug("embMiscMatchPatternDelim(ajFeatGetSource(gf), source) %B\n",
embMiscMatchPatternDelimC(ajFeatGetSource(gf), source, ",;|"));
ajDebug("ajFeatTypeMatchS(gf, type) %B\n",
ajFeatTypeMatchWildS(gf, type));
ajDebug("ajFeatGetStrand(gf) '%x' sense %d\n", ajFeatGetStrand(gf), sense);
ajDebug("testscore: %B ajFeatGetScore(gf): %f minscore:%f maxscore:%f\n",
testscore, ajFeatGetScore(gf), minscore, maxscore);
if(!embMiscMatchPatternDelimC(ajFeatGetSource(gf), source, ",;|"))
return ajFalse;
if(ajStrGetLen(type))
{
val = ajFalse;
tokens = ajStrTokenNewC(type, " \t\n\r,;|");
while (ajStrTokenNextParse( &tokens, &key))
{
if (ajFeatTypeMatchWildS(gf, key))
{
val = ajTrue;
break;
}
}
ajStrTokenDel( &tokens);
ajStrDel(&key);
if(!val)
return ajFalse;
}
if(ajFeatGetStrand(gf) == '+' && sense == -1)
return ajFalse;
if(ajFeatGetStrand(gf) == '-' && sense == +1)
return ajFalse;
if(testscore && ajFeatGetScore(gf) < minscore)
return ajFalse;
if(testscore && ajFeatGetScore(gf) > maxscore)
return ajFalse;
if(!*tagsmatch)
return ajFalse;
ajDebug("All tests passed, return ajTrue\n");
/*ajUser("All tests passed, return ajTrue");*/
return ajTrue;
}
int main(int argc, char *argv[])
{
embInitPV("ggcsi", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
struct ns1__gcsiInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint window = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
AjBool pval = 0;
AjPStr version = NULL;
AjBool accid = ajFalse;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr gcsi = NULL;
AjPStr sa = NULL;
AjPStr dist = NULL;
AjPStr z = NULL;
AjPStr p = NULL;
AjPStrTok handle = NULL;
char *in0;
char *result;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
window = ajAcdGetInt("window");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
pval = ajAcdGetBoolean("pval");
version = ajAcdGetSelectSingle("gcsi");
accid = ajAcdGetBoolean("accid");
outf = ajAcdGetOutfile("outfile");
params.window = window;
params.at = 0;
params.purine = 0;
params.keto = 0;
params.p = 0;
ajStrToInt(version, &(params.version));
if(at)
params.at = 1;
if(purine)
params.purine = 1;
if(keto)
params.keto = 1;
if(pval)
params.p = 1;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if (soap_call_ns1__gcsi(
&soap,
NULL,
NULL,
in0,
¶ms,
&result
) == SOAP_OK)
{
tmp = ajStrNew();
parse = ajStrNew();
gcsi = ajStrNew();
sa = ajStrNew();
dist = ajStrNew();
z = ajStrNew();
p = ajStrNew();
ajStrAssignC(&tmp, result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while (ajStrTokenNextParse(&handle, &parse))
{
if (ajStrIsFloat(parse))
{
if(!ajStrGetLen(gcsi))
ajStrAssignS(&gcsi, parse);
else if(!ajStrGetLen(sa))
ajStrAssignS(&sa, parse);
else if(!ajStrGetLen(dist))
ajStrAssignS(&dist, parse);
else if(!ajStrGetLen(z))
ajStrAssignS(&z, parse);
else if(!ajStrGetLen(p))
ajStrAssignS(&p, parse);
}
}
tmp = ajFmtStr("Sequence: %S GCSI: %S SA: %S DIST: %S",
seqid, gcsi, sa, dist);
if(pval)
tmp = ajFmtStr("%S Z: %S P: %S", tmp, z, p);
ajFmtPrintF(outf, "%S\n", tmp);
ajStrDel(&tmp);
ajStrDel(&parse);
ajStrDel(&gcsi);
ajStrDel(&sa);
ajStrDel(&dist);
ajStrDel(&z);
ajStrDel(&p);
}
else
{
soap_print_fault(&soap, stderr);
}
soap_destroy(&soap);
soap_end(&soap);
soap_done(&soap);
AJFREE(in0);
ajStrDel(&inseq);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
static void primersearch_read_primers(AjPList *primerList, AjPFile primerFile,
ajint mmp)
{
AjPStr rdline = NULL;
AjPStrTok handle = NULL;
ajint nprimers = 0;
Primer primdata = NULL;
while (ajReadlineTrim(primerFile, &rdline))
{
primdata = NULL;
if (ajStrGetCharFirst(rdline) == '#')
continue;
if (ajStrSuffixC(rdline, ".."))
continue;
AJNEW(primdata);
primdata->Name = NULL;
primersearch_initialise_pguts(&primdata->forward);
primersearch_initialise_pguts(&primdata->reverse);
primdata->hitlist = ajListNew();
handle = ajStrTokenNewC(rdline, " \t");
ajStrTokenNextParse(&handle, &primdata->Name);
ajStrTokenNextParse(&handle, &primdata->forward->patstr);
ajStrFmtUpper(&primdata->forward->patstr);
ajStrTokenNextParse(&handle, &primdata->reverse->patstr);
ajStrFmtUpper(&primdata->reverse->patstr);
ajStrTokenDel(&handle);
/* copy patterns for Henry Spencer code */
ajStrAssignC(&primdata->forward->origpat,
ajStrGetPtr(primdata->forward->patstr));
ajStrAssignC(&primdata->reverse->origpat,
ajStrGetPtr(primdata->reverse->patstr));
/* set the mismatch level */
primdata->forward->mm = (ajint)
(ajStrGetLen(primdata->forward->patstr)*mmp)/100;
primdata->reverse->mm = (ajint)
(ajStrGetLen(primdata->reverse->patstr)*mmp)/100;
if(primersearch_classify_and_compile(&primdata))
{
ajListPushAppend(*primerList, primdata);
nprimers++;
}
else /* there was something funny about the primer sequences */
{
ajUser("Cannot use %s\n", ajStrGetPtr(primdata->Name));
primersearch_free_pguts(&primdata->forward);
primersearch_free_pguts(&primdata->reverse);
ajStrDel(&primdata->Name);
ajListFree(&primdata->hitlist);
ajListFree(&primdata->hitlist);
AJFREE(primdata);
}
}
ajStrDel(&rdline);
return;
}
int main(int argc, char *argv[])
{
embInitPV("genret", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPStr inseq = NULL;
AjPStr gene = NULL;
AjPStr access = NULL;
AjBool accid = ajTrue;
AjPStr argument = NULL;
AjPFile outfile = NULL;
AjPStr seqid = NULL;
AjPStr restid = NULL;
AjBool valid = ajFalse;
AjBool isseq = ajFalse;
AjBool isgbk = ajFalse;
AjPFilebuff buff = NULL;
AjPFile tmpfile = NULL;
AjPStr tmpname = NULL;
AjPStr regexstr = NULL;
AjPStrTok token = NULL;
AjPRegexp regex = NULL;
AjPStr url = NULL;
AjPStr base = NULL;
AjPStr head = NULL;
AjPStr line = NULL;
seqall = ajAcdGetSeqall("sequence");
access = ajAcdGetString("access");
gene = ajAcdGetString("gene");
argument = ajAcdGetString("argument");
accid = ajAcdGetBoolean("accid");
outfile = ajAcdGetOutfile("outfile");
if(
ajStrMatchC(access, "translation") ||
ajStrMatchC(access, "get_exon") ||
ajStrMatchC(access, "get_exons") ||
ajStrMatchC(access, "get_cdsseq") ||
ajStrMatchC(access, "get_gbkseq") ||
ajStrMatchC(access, "get_geneseq") ||
ajStrMatchC(access, "get_intron") ||
ajStrMatchC(access, "getseq") ||
ajStrMatchC(access, "seq") ||
ajStrMatchC(access, "around_startcodon") ||
ajStrMatchC(access, "around_stopcodon") ||
ajStrMatchC(access, "before_startcodon") ||
ajStrMatchC(access, "before_stopcodon") ||
ajStrMatchC(access, "after_startcodon") ||
ajStrMatchC(access, "after_stopcodon")
)
{
isseq = ajTrue;
}
else if(ajStrMatchC(access, "annotate") ||
ajStrMatchC(access, "output"))
{
isgbk = ajTrue;
}
else
{
ajFmtPrintF(outfile, "gene,%S\n", access);
}
base = ajStrNewC("rest.g-language.org");
ajStrExchangeCC(&argument, " ", "/");
ajStrExchangeCC(&argument, ",", "/");
ajStrExchangeCC(&argument, "\t", "/");
ajStrExchangeCC(&argument, "\r", "/");
ajStrExchangeCC(&argument, "\n", "/");
if(ajStrMatchC(gene, "*"))
{
ajStrInsertK(&gene, 0, '.');
}
if(ajStrPrefixC(gene, "@") || ajStrPrefixC(gene, "list::"))
{
ajStrExchangeCC(&gene, "@", "");
ajStrExchangeCC(&gene, "list::", "");
ajStrAssignS(&tmpname, gene);
tmpfile = ajFileNewInNameS(tmpname);
if(!tmpfile)
{
ajDie("List file (%S) open error\n", tmpname);
}
gene = ajStrNew();
while(ajReadline(tmpfile, &line))
{
ajStrAppendS(&gene, line);
}
ajFileClose(&tmpfile);
ajStrDel(&tmpname);
ajStrDel(&line);
}
tmpname = ajStrNew();
gAssignUniqueName(&tmpname);
while(ajSeqallNext(seqall, &seq))
{
inseq = ajStrNew();
if(!accid)
{
if(gFormatGenbank(seq, &inseq))
{
tmpfile = ajFileNewOutNameS(tmpname);
if(!tmpfile)
{
ajDie("Output file (%S) open error\n", tmpname);
}
ajFmtPrintF(tmpfile, "%S", inseq);
ajFileClose(&tmpfile);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
}
else
{
ajWarn("Sequence does not have features\n"
"Proceeding with sequence accession ID\n");
accid = ajTrue;
}
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
if(accid)
{
ajStrAssignS(&restid, seqid);
if(ajStrGetLen(seqid) == 0)
{
ajDie("Cannot proceed without header with -accid\n");
}
if(!gValID(seqid))
{
ajDie("Invalid accession ID:%S, exiting\n", seqid);
}
}
url = ajStrNew();
if(isgbk)
{
ajFmtPrintS(&url, "http://%S/%S/%S", base, restid, access);
}
else
{
ajFmtPrintS(&url, "http://%S/%S/*/%S/%S", base, restid, access, argument);
}
if(!gFilebuffURLS(url, &buff))
{
ajDie("GET error from %S\n", url);
}
while(ajBuffreadLine(buff, &line))
{
if(isgbk){
ajFmtPrintF(outfile, "%S", line);
continue;
}
ajStrRemoveLastNewline(&line);
regex = ajRegCompC("^>");
if(ajRegExec(regex, line))
{
head = ajStrNew();
ajStrAssignS(&head, line);
ajStrTrimStartC(&head, ">");
valid = ajFalse;
token = ajStrTokenNewC(ajStrNewS(gene), " ,\t\r\n");
while(ajStrTokenNextParse(token, ®exstr))
{
if(ajStrGetLen(regexstr))
{
regex = ajRegComp(regexstr);
if(ajRegExec(regex, line))
{
valid = ajTrue;
if(ajStrIsAlnum(regexstr))
{
ajStrExchangeSC(&gene, regexstr, "");
}
}
ajRegFree(®ex);
}
}
}
else
{
if(valid)
{
if(isseq)
{
ajStrFmtWrap(&line, 60);
ajFmtPrintF(outfile, ">%S\n%S\n", head, line);
}
else
{
ajFmtPrintF(outfile, "%S,%S\n", head, line);
}
valid = ajFalse;
}
}
}
ajFileClose(&outfile);
ajStrDel(&restid);
ajStrDel(&seqid);
ajStrDel(&inseq);
}
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&access);
ajStrDel(&gene);
embExit();
}
static void eprimer3_report(AjPFile outfile, const AjPStr output,
ajint numreturn, ajint begin)
{
AjPStr line = NULL;
AjPStrTok linetokenhandle;
char eol[] = "\n\r";
AjPStrTok keytokenhandle;
char equals[] = "=";
AjPStr key = NULL;
AjPStr value = NULL;
AjBool gotsequenceid = AJFALSE;
AjPTable table;
linetokenhandle = ajStrTokenNewC(output, eol);
/* get next line of relevant results */
while(ajStrTokenNextParseC(&linetokenhandle, eol, &line))
{
if(!gotsequenceid)
{
/*
** Att the start of another sequence's results?
** Start storing the results in the table.
*/
if(ajStrCmpLenC(line, "PRIMER_SEQUENCE_ID=", 19) == 0)
{
gotsequenceid = AJTRUE;
table = ajTablestrNew(TABLEGUESS);
}
else
continue;
}
else
{
/*
** At the end of this sequence? - marked by a '=' in the primer3
** output - then output the results.
*/
if(ajStrCmpC(line, "=") == 0)
{
gotsequenceid = AJFALSE;
eprimer3_output_report(outfile, table, numreturn, begin);
ajTablestrFree(&table);
continue;
}
}
/*
** store key and value in table and parse values
** when have all of the sequence
** results in the table because the LEFT, RIGHT
** and INTERNAL results for each
** resulting primer are interleaved
*/
keytokenhandle = ajStrTokenNewC(line, equals);
key = ajStrNew();
ajStrTokenNextParse(&keytokenhandle, &key);
value = ajStrNew();
ajStrTokenNextParse(&keytokenhandle, &value);
ajDebug("key=%S\tvalue=%S\n", key, value);
ajTablePut(table,(void *)key, (void *)value);
ajStrTokenDel(&keytokenhandle);
}
ajStrDel(&line);
ajStrTokenDel(&linetokenhandle);
ajTablestrFree(&table);
return;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPFile primfile;
AjPStr rdline = NULL;
Primer primdata;
AjPStrTok handle = NULL;
AjPList primList = NULL;
embInit("stssearch", argc, argv);
primfile = ajAcdGetInfile("infile");
out = ajAcdGetOutfile("outfile");
seqall = ajAcdGetSeqall("seqall");
while(ajReadlineTrim(primfile, &rdline))
{
if(ajStrGetCharFirst(rdline) == '#')
continue;
if(ajStrSuffixC(rdline, ".."))
continue;
AJNEW(primdata);
primdata->Name = NULL;
primdata->Oligoa = NULL;
primdata->Oligob = NULL;
handle = ajStrTokenNewC(rdline, " \t");
ajStrTokenNextParse(&handle, &primdata->Name);
if(!(nprimers % 1000))
ajDebug("Name [%d]: '%S'\n", nprimers, primdata->Name);
ajStrTokenNextParse(&handle, &primdata->Oligoa);
ajStrFmtUpper(&primdata->Oligoa);
primdata->Prima = ajRegComp(primdata->Oligoa);
ajStrTokenNextParse(&handle, &primdata->Oligob);
ajStrFmtUpper(&primdata->Oligob);
primdata->Primb = ajRegComp(primdata->Oligob);
ajStrTokenDel(&handle);
if(!nprimers)
primList = ajListNew();
ajListPushAppend(primList, primdata);
nprimers++;
}
if(!nprimers)
ajFatal("No primers read\n");
ajDebug("%d primers read\n", nprimers);
while(ajSeqallNext(seqall, &seq))
{
ajSeqFmtUpper(seq);
ajStrAssignS(&seqstr, ajSeqGetSeqS(seq));
ajStrAssignS(&revstr, ajSeqGetSeqS(seq));
ajSeqstrReverse(&revstr);
ajDebug("Testing: %s\n", ajSeqGetNameC(seq));
ntests = 0;
ajListMap(primList, stssearch_primTest, NULL);
}
ajFileClose(&out);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&out);
ajStrDel(&revstr);
ajStrDel(&seqstr);
ajFileClose(&primfile);
ajListMap(primList, stssearch_primDel, NULL);
ajListFree(&primList);
ajStrDel(&rdline);
embExit();
return 0;
}
static AjBool resourceoutWriteWebpage(AjPFile outf, const AjPResource resource)
{
AjPResquery tmpqry = NULL;
AjPResterm resterm = NULL;
AjPStr snstr = NULL;
AjPStr tmpstr = NULL;
AjPStr tmpurl = NULL;
AjPStr tmpid = NULL;
AjPStr tmpname = NULL;
AjPStr tmpqid = NULL;
AjPStr tmpqname = NULL;
AjPStr tmpqterm = NULL;
AjIList iter = NULL;
AjIList iterq = NULL;
ajuint i = 0;
AjPStrTok handle = NULL;
AjPStrTok namehandle = NULL;
AjPStrTok termhandle = NULL;
const char* biourl = "http://bioportal.bioontology.org/ontologies/45846";
if(!outf)
return ajFalse;
ajFmtPrintF(outf,
"<!DOCTYPE HTML PUBLIC "
"\"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");
ajFmtPrintF(outf,
"<html>\n");
ajFmtPrintF(outf,
"<head>\n");
ajFmtPrintF(outf,
"<meta http-equiv=\"Content-Type\" "
"content=\"text/html;charset=UTF-8\" />\n");
ajFmtPrintF(outf,
"<title>Bioinformatics Data Resource Catalogue</title>\n");
ajFmtPrintF(outf,
"</head>\n\n\n");
ajFmtPrintF(outf,
"<body bgcolor=\"#ffffff\">\n");
ajFmtPrintF(outf,
"<!-- ID -->\n");
if(ajStrGetLen(resource->Url))
ajFmtPrintF(outf,
"<center><h1><a href=\"%S\">%S</a></h1></center>\n",
resource->Url, resource->Id);
else
ajFmtPrintF(outf,
"<center><h1>%S</h1></center>\n",
resource->Id);
ajFmtPrintF(outf,
"<!-- Name -->\n");
ajFmtPrintF(outf,
"<center><h2>%S</h2> </center>\n",
resource->Name);
ajFmtPrintF(outf,
"<!-- Desc -->\n");
ajFmtPrintF(outf,
"<p><i>%S</i></p>\n",
resource->Desc);
ajFmtPrintF(outf,
"<table>\n");
ajFmtPrintF(outf,
"<!-- ID -->\n");
ajFmtPrintF(outf,
" <tr align=\"left\"><th>ID</th><td>%S</td></tr>\n",
resource->Id);
ajFmtPrintF(outf,
"<!-- IDalt or omit -->\n");
if(ajListGetLength(resource->Idalt))
{
ajFmtPrintF(outf,
" <tr align=\"left\"><th>IDalt</th><td>");
i = 0;
iter = ajListIterNew(resource->Idalt);
while((tmpstr = ajListstrIterGet(iter)))
{
if(i++)
ajFmtPrintF(outf, ", ");
ajFmtPrintF(outf, "%S", tmpstr);
}
ajListIterDel(&iter);
ajFmtPrintF(outf,
"</td></tr>\n");
}
if(ajStrGetLen(resource->Acc))
{
ajFmtPrintF(outf,
"<!-- ACC or omit -->\n");
ajFmtPrintF(outf,
" <tr align=\"left\"><th>Acc</th><td>%S</td></tr>\n",
resource->Acc);
}
if(ajStrGetLen(resource->Url))
ajFmtPrintF(outf,
" <tr align=\"left\"><th>Home</th><td>"
"<a href=\"%S\">%S</a></td></tr>\n",
resource->Url, resource->Url);
if(ajListGetLength(resource->Edamtpc))
{
ajFmtPrintF(outf,
"<!-- EDAMtpc -->\n");
iter = ajListIterNew(resource->Edamtpc);
while((resterm = ajListIterGet(iter)))
{
ajStrAssignS(&tmpid, resterm->Id);
ajStrCutBraces(&tmpid);
ajStrFmtPercentEncodeC(&tmpid, " /()");
ajFmtPrintF(outf,
" <tr align=\"left\"><th>EDAM topic</th><td>"
"<a href=\"%s?p=terms&conceptid=EDAM%%3A%S\">%S</a>"
"</td></tr>\n",
biourl, tmpid, resterm->Name);
}
ajListIterDel(&iter);
}
ajFmtPrintF(outf,
"<!-- Cat or omit -->\n");
if(ajListGetLength(resource->Cat))
{
iter = ajListIterNew(resource->Cat);
while((tmpstr = ajListstrIterGet(iter)))
ajFmtPrintF(outf,
" <tr align=\"left\"><th>Category</th>"
"<td>%S</td></tr>\n",
tmpstr);
ajListIterDel(&iter);
}
ajFmtPrintF(outf,
"<!-- Taxon (comma-separated list) -->\n");
ajFmtPrintF(outf,
" <tr align=\"left\"><th>Taxon</th><td>");
i = 0;
iter = ajListIterNew(resource->Taxon);
while((resterm = ajListIterGet(iter)))
{
if(i++)
ajFmtPrintF(outf, ", ");
ajFmtPrintF(outf,
"<a href=\"http://www.ncbi.nlm.nih.gov/Taxonomy/Browser/"
"wwwtax.cgi?id=%S\">%S</a>",
resterm->Id, resterm->Name);
}
ajListIterDel(&iter);
ajFmtPrintF(outf,
"</td></tr>\n");
ajFmtPrintF(outf,
"<!-- URLlink or omit -->\n");
if(ajStrGetLen(resource->Urllink))
ajFmtPrintF(outf,
"<tr align=\"left\"><th>Linking</th><td>"
"<a href=\"%S\">%S</a></td></tr>\n",
resource->Urllink, resource->Urllink);
ajFmtPrintF(outf,
"<!-- URLrest or omit -->\n");
if(ajStrGetLen(resource->Urlrest))
ajFmtPrintF(outf,
"<tr align=\"left\"><th>REST</th><td>"
"<a href=\"%S\">%S</a></td></tr>\n",
resource->Urlrest, resource->Urlrest);
ajFmtPrintF(outf,
"<!-- URLsoap or omit -->\n");
if(ajStrGetLen(resource->Urlsoap))
ajFmtPrintF(outf,
"<tr align=\"left\"><th>SOAP</th><td>"
"<a href=\"%S\">%S</a></td></tr>\n",
resource->Urlsoap, resource->Urlsoap);
ajFmtPrintF(outf,
"<!-- Xref - omit ! -->\n");
ajFmtPrintF(outf,
"</table>\n");
ajFmtPrintF(outf,
"<!-- Query or omit, free-text comments given in {} --> \n");
if(ajListGetLength(resource->Query))
{
ajFmtPrintF(outf,
"<h3>Available data</h3>\n");
ajFmtPrintF(outf,
"<table>\n");
ajFmtPrintF(outf,
" <thead>\n");
ajFmtPrintF(outf,
" <tr align=\"left\">\n");
ajFmtPrintF(outf,
" <th>Data</th>\n");
ajFmtPrintF(outf,
" <th>Format</th>\n");
ajFmtPrintF(outf,
" <th>Query</th>\n");
ajFmtPrintF(outf,
" <th>Link</th>\n");
ajFmtPrintF(outf,
" </tr>\n");
ajFmtPrintF(outf,
" </thead>\n");
ajFmtPrintF(outf,
" <tbody>\n");
iter = ajListIterNew(resource->Query);
while((tmpqry = ajListIterGet(iter)))
{
ajStrAssignS(&tmpname, tmpqry->Datatype);
ajStrCutBraces(&tmpname);
ajStrFmtPercentEncodeC(&tmpname, " /()");
ajFmtPrintF(outf,
" <tr>\n");
ajFmtPrintF(outf,
" <td>"
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a></td>\n",
biourl, tmpname, tmpqry->Datatype);
ajStrAssignS(&tmpname, tmpqry->Format);
ajStrCutBraces(&tmpname);
ajStrFmtPercentEncodeC(&tmpname, " /()");
ajFmtPrintF(outf,
" <td>"
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a></td>\n",
biourl, tmpname, tmpqry->Format);
ajStrAssignS(&tmpname, tmpqry->Term);
ajStrCutBraces(&tmpname);
ajStrFmtPercentEncodeC(&tmpname, " /()");
ajFmtPrintF(outf,
" <td>"
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a></td>\n",
biourl, tmpname, tmpqry->Term);
ajFmtPrintF(outf,
" <td>%S</td>\n",
tmpqry->Url);
ajFmtPrintF(outf,
" </tr>\n\n");
}
ajListIterDel(&iter);
ajFmtPrintF(outf,
" </tbody>\n");
ajFmtPrintF(outf,
"</table>\n");
}
ajFmtPrintF(outf,
"<!-- Example or omit -->\n");
if(ajListGetLength(resource->Example))
{
ajFmtPrintF(outf,
"<h3>Example queries</h3>\n");
ajFmtPrintF(outf,
"<table>\n");
ajFmtPrintF(outf,
" <thead>\n");
ajFmtPrintF(outf,
" <tr align=\"left\">\n");
ajFmtPrintF(outf,
" <th>Data</th>\n");
ajFmtPrintF(outf,
" <th>Format</th>\n");
ajFmtPrintF(outf,
" <th>Query</th>\n");
ajFmtPrintF(outf,
" <th>Example</th>\n");
ajFmtPrintF(outf,
" </tr>\n");
ajFmtPrintF(outf,
" </thead>\n");
ajFmtPrintF(outf,
" <tbody>\n");
iter = ajListIterNew(resource->Example);
while((tmpstr = ajListstrIterGet(iter)))
{
ajStrTokenAssignC(&handle, tmpstr, "|");
ajStrTokenNextParse(handle, &tmpid);
ajStrRemoveWhiteExcess(&tmpid);
ajStrTokenNextParse(handle, &tmpname);
ajStrRemoveWhiteExcess(&tmpname);
iterq = ajListIterNew(resource->Query);
while((tmpqry = ajListIterGet(iterq)))
{
if(!ajStrMatchS(tmpid, tmpqry->Term))
continue;
ajStrAssignS(&tmpqid, tmpqry->Datatype);
ajStrCutBraces(&tmpqid);
ajStrFmtPercentEncodeC(&tmpqid, " /()");
ajFmtPrintF(outf,
" <tr>\n");
ajFmtPrintF(outf,
" <td>"
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a></td>\n",
biourl, tmpqid, tmpqry->Datatype); /* datatype */
ajStrAssignS(&tmpqid, tmpqry->Format);
ajStrCutBraces(&tmpqid);
ajStrFmtPercentEncodeC(&tmpqid, " /()");
ajFmtPrintF(outf,
" <td>"
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a></td>\n",
biourl, tmpqid, tmpqry->Format); /* format */
ajStrAssignS(&tmpurl, tmpqry->Url);
ajStrAssignS(&tmpqid, tmpqry->Term);
ajStrCutBraces(&tmpqid);
ajStrFmtPercentEncodeC(&tmpqid, " /()");
i = 0;
ajStrTokenAssignC(&handle, tmpid, ";");
ajStrTokenAssignC(&namehandle, tmpname, ";");
ajStrTokenAssignC(&termhandle, tmpqry->Term, ";");
ajFmtPrintF(outf,
" <td>");
while(ajStrTokenNextParse(handle, &tmpqid))
{
ajStrTokenNextParse(namehandle, &tmpqname);
ajStrTokenNextParse(termhandle, &tmpqterm);
if(i)
ajFmtPrintF(outf,
"; ");
ajStrRemoveWhiteExcess(&tmpqid);
ajStrCutBraces(&tmpqid);
ajFmtPrintF(outf,
"<a href=\"%s?"
"p=terms&conceptid=EDAM%%3A%S\">%S</a>",
biourl, tmpqid, tmpqterm); /* id term */
ajFmtPrintS(&snstr, "%%s%u", (i+1));
ajStrExchangeSS(&tmpurl, snstr, tmpqname);
i++;
}
ajFmtPrintF(outf,
"</td>\n");
ajFmtPrintS(&snstr, "%%s");
ajStrExchangeSS(&tmpurl, snstr, tmpname);
ajFmtPrintF(outf,
" <td><a href=\"%S\">%S</a></td>\n",
tmpurl, tmpname); /* url, exampleid */
ajFmtPrintF(outf,
" </tr>\n");
}
ajListIterDel(&iterq);
}
ajListIterDel(&iter);
ajFmtPrintF(outf,
" </tbody>\n");
ajFmtPrintF(outf,
"</table>\n");
}
ajFmtPrintF(outf, "\n\n</body></html>\n");
ajStrDel(&tmpid);
ajStrDel(&tmpname);
ajStrDel(&tmpurl);
ajStrDel(&tmpqid);
ajStrDel(&tmpqname);
ajStrDel(&tmpqterm);
ajStrDel(&snstr);
ajStrTokenDel(&handle);
ajStrTokenDel(&namehandle);
ajStrTokenDel(&termhandle);
return ajTrue;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPStr query;
AjPOutfile outfile = NULL;
AjPResource resource = NULL;
AjPResourcein resourcein = NULL;
AjPOboin oboin = NULL;
AjPObo obo = NULL;
AjPStr oboqry = NULL;
AjPStr resourceqry = NULL;
AjPStr qrystr = NULL;
AjPTable obotable = NULL;
AjPTable foundtable = NULL;
AjBool subclasses = ajFalse;
AjPStrTok handle = NULL;
AjPList obolist = NULL;
AjPObo obotest = NULL;
ajuint i;
ajuint imax = 3;
const char* fields[] = {"id", "acc", "nam", "des"};
/* ACD processing */
embInit("drfindid", argc, argv);
query = ajAcdGetString("query");
outfile = ajAcdGetOutresource("outfile");
/* sensitive = ajAcdGetBoolean("sensitive"); */
subclasses = ajAcdGetBoolean("subclasses");
resourcein = ajResourceinNew();
resource = ajResourceNew();
oboin = ajOboinNew();
obo = ajOboNew();
obolist = ajListNew();
obotable = ajTablestrNew(600);
foundtable = ajTablestrNew(600);
handle = ajStrTokenNewC(query, ",");
while(ajStrTokenNextParse(&handle, &qrystr))
{
for(i=0; i<imax; i++)
{
ajFmtPrintS(&oboqry, "edam-%s:%S", fields[i], qrystr);
ajOboinQryS(oboin, oboqry);
while(ajOboinRead(oboin, obo))
{
ajListPushAppend(obolist, ajOboNewObo(obo));
if(subclasses)
ajOboGetTree(obo, obolist);
ajDebug("%S '%S' %u\n",
qrystr, obo->Id, ajListGetLength(obolist));
while(ajListGetLength(obolist))
{
ajListPop(obolist, (void**) &obotest);
if(!ajTableMatchS(obotable, obotest->Id))
{
ajDebug("edam %s '%S' namespace '%S' name '%S'\n",
fields[i], obotest->Id, obotest->Namespace,
obotest->Name);
ajTablePut(obotable, ajStrNewS(obotest->Id),
(void *) 1);
ajFmtPrintS(&resourceqry, "drcat-eid:%S",
ajOboGetId(obotest));
ajResourceinQryS(resourcein, resourceqry);
while(ajResourceinRead(resourcein, resource))
{
if(!ajTableMatchS(foundtable, resource->Id))
{
ajDebug("drcat id '%S' category '%S'\n",
resource->Id, resource->Cat);
ajResourceoutWrite(outfile, resource);
ajTablePut(foundtable, ajStrNewS(resource->Id),
(void *) 1);
}
}
}
ajOboDel(&obotest);
}
}
}
}
/* Memory clean-up and exit */
ajOboDel(&obo);
ajOboinDel(&oboin);
ajResourceDel(&resource);
ajResourceinDel(&resourcein);
ajListFree(&obolist);
ajStrTokenDel(&handle);
ajStrDel(&qrystr);
ajStrDel(&query);
ajStrDel(&oboqry);
ajStrDel(&resourceqry);
ajTablestrFreeKey(&obotable);
ajTablestrFreeKey(&foundtable);
ajOutfileClose(&outfile);
embExit();
return 0;
}
