static AjBool extractfeat_MatchPatternTags(const AjPFeature feat,
const AjPStr tpattern,
const AjPStr vpattern)
{
AjIList titer; /* iterator for feat */
AjPStr tagnam = NULL; /* tag structure */
AjPStr tagval = NULL; /* tag structure */
AjBool val = ajFalse; /* returned value */
AjBool tval; /* tags result */
AjBool vval; /* value result */
/*
** if there are no tags to match, but the patterns are
** both '*', then allow this as a match
*/
if(!ajStrCmpC(tpattern, "*") &&
!ajStrCmpC(vpattern, "*"))
return ajTrue;
/* iterate through the tags and test for match to patterns */
titer = ajFeatTagIter(feat);
while(ajFeatTagval(titer, &tagnam, &tagval))
{
tval = embMiscMatchPatternDelimC(tagnam, tpattern, ",;|");
/*
** If tag has no value then
** If vpattern is '*' the value pattern is a match
** Else check vpattern
*/
if(!ajStrGetLen(tagval))
{
if(!ajStrCmpC(vpattern, "*"))
vval = ajTrue;
else
vval = ajFalse;
}
else
vval = embMiscMatchPatternDelimC(tagval, vpattern, ",;|");
if(tval && vval)
{
val = ajTrue;
break;
}
}
ajListIterDel(&titer);
ajStrDel(&tagnam);
ajStrDel(&tagval);
return val;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeqout seqout;
AjPSeqout junkout;
AjPSeq seq = NULL;
AjPStr exclude = NULL;
AjPStr pattern = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
embInit("notseq", argc, argv);
seqout = ajAcdGetSeqoutall("outseq");
junkout = ajAcdGetSeqoutall("junkoutseq");
seqall = ajAcdGetSeqall("sequence");
exclude = ajAcdGetString("exclude");
notseq_readfile(exclude, &pattern);
while(ajSeqallNext(seqall, &seq))
{
ajStrAssignS(&name, ajSeqGetNameS(seq));
ajStrAssignS(&acc, ajSeqGetAccS(seq));
if(embMiscMatchPatternDelimC(name, pattern, ",;") ||
embMiscMatchPatternDelimC(acc, pattern, ",;"))
ajSeqoutWriteSeq(junkout, seq);
else
/* no match, so not excluded */
ajSeqoutWriteSeq(seqout, seq);
ajStrSetClear(&name);
ajStrSetClear(&acc);
}
ajSeqoutClose(seqout);
ajSeqoutClose(junkout);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajSeqoutDel(&junkout);
ajStrDel(&exclude);
ajStrDel(&pattern);
ajStrDel(&name);
ajStrDel(&acc);
embExit();
return 0;
}
static AjBool extractfeat_MatchPatternDescribe(const AjPFeature feat,
const AjPStr describe,
AjPStr *strout)
{
AjIList titer; /* iterator for feat */
AjPStr tagnam = NULL; /* tag structure */
AjPStr tagval = NULL; /* tag structure */
AjBool val = ajFalse; /* returned value */
/* iterate through the tags and test for match to patterns */
titer = ajFeatTagIter(feat);
while(ajFeatTagval(titer, &tagnam, &tagval))
{
if(embMiscMatchPatternDelimC(tagnam, describe, ",;|"))
{
/* There's a match, so write to strout in a pretty format */
if(!val)
ajStrAssignC(strout, "(");
else
ajStrAppendC(strout, ", ");
val = ajTrue;
ajStrAppendS(strout, tagnam);
if(ajStrGetLen(tagval))
{
ajStrAppendC(strout, "=\"");
ajStrAppendS(strout, tagval);
ajStrAppendC(strout, "\"");
}
}
}
ajListIterDel(&titer);
if(val)
ajStrAppendC(strout, ") ");
ajStrDel(&tagnam);
ajStrDel(&tagval);
return val;
}
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;
}
