Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
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;
}