seqdb_src.cpp

ncbi源码

/** Retrieves the sequence identifier meeting the criteria defined by its 
 * second argument. Currently it is an ordinal id (integer value).
 * @todo Need a way to request difference sequence identifiers in redundant
 * databases.
 * Client code is responsible for deallocating the return value. 
 * @param seqdb_handle Pointer to initialized CSeqDB object [in]
 * @param args Pointer to integer indicating ordinal id [in]
 */
static char* SeqDbGetSeqIdStr(void* seqdb_handle, void* args)
{
    char* seqid_str = NULL;
    ListNode* seqid_wrap = NULL;

    seqid_wrap = SeqDbGetSeqId(seqdb_handle, args);
    if (seqid_wrap->choice != BLAST_SEQSRC_CPP_SEQID_REF)
        return NULL;
    CRef<CSeq_id>* seqid_ref = (CRef<CSeq_id>*) seqid_wrap->ptr;

    ListNodeFree(seqid_wrap);
    if (seqid_ref)
        seqid_str = strdup((*seqid_ref)->GetSeqIdString().c_str());

    delete seqid_ref;
    return seqid_str;
}

/* There is no need to return locations from seqdb, since we always search
   whole sequences in the database */
static ListNode* SeqDbGetSeqLoc(void*, void*)
{
   return NULL;
}

/** Retrieve length of a given database sequence.
 * @param seqdb_handle Pointer to initialized CSeqDB object [in]
 * @param args Pointer to integer indicating ordinal id [in]
 * @return Length of the database sequence or BLAST_SEQSRC_ERROR.
 */
static Int4 SeqDbGetSeqLen(void* seqdb_handle, void* args)
{
    CSeqDB* seqdb = (CSeqDB*) seqdb_handle;
    Int4* oid = (Int4*) args;

    if (!seqdb || !oid)
       return BLAST_SEQSRC_ERROR;

    return seqdb->GetSeqLength(*oid);
}

/* There are no error messages saved in the SeqdbFILE structure, so the 
 * following getter function is implemented as always returning NULL.
 */
static ListNode* SeqDbGetError(void*, void*)
{
    /* FIXME: error handling should not be provided by the seqsrc interface */
   return NULL;
}

static Int2 SeqDbGetNextChunk(void* seqdb_handle, BlastSeqSrcIterator* itr)
{
    CSeqDB* seqdb = (CSeqDB*) seqdb_handle;

    if (!seqdb || !itr)
        return BLAST_SEQSRC_ERROR;

    // Point current position to the next oid.
    if (itr->next_oid == UINT4_MAX) {
        return BLAST_SEQSRC_EOF;
    } else if (itr->next_oid == 0) {
        itr->current_pos = 0;
        if (!seqdb->CheckOrFindOID(itr->current_pos))
            return BLAST_SEQSRC_EOF;
    } else {
        itr->current_pos = itr->next_oid;
    }

    // Find the new next oid.
    itr->next_oid = itr->current_pos + 1;
    if (!seqdb->CheckOrFindOID(itr->next_oid))
        itr->next_oid = UINT4_MAX;
    itr->itr_type = eOidRange;
    itr->oid_range[0] = itr->current_pos;
    itr->oid_range[1] = itr->current_pos + 1;

    return BLAST_SEQSRC_SUCCESS;
}

static Int4 SeqDbIteratorNext(void* seqsrc, BlastSeqSrcIterator* itr)
{
    BlastSeqSrc* bssp = (BlastSeqSrc*) seqsrc;
    Int4 retval = BLAST_SEQSRC_EOF;
    Int4 status = BLAST_SEQSRC_SUCCESS;

    ASSERT(bssp);
    ASSERT(itr);

    /* If iterator is uninitialized/invalid, retrieve the next chunk from the
     * BlastSeqSrc */
    if (itr->current_pos == UINT4_MAX) {
        status = BLASTSeqSrcGetNextChunk(bssp, itr);
        if (status == BLAST_SEQSRC_ERROR || status == BLAST_SEQSRC_EOF) {
            return status;
        }
    }

    if (itr->itr_type == eOidRange) {
        retval = itr->current_pos++;
        if (itr->current_pos >= itr->oid_range[1]) {
            itr->current_pos = UINT4_MAX;   /* invalidate iterator */
        }
    } else if (itr->itr_type == eOidList) {
        /* Unimplemented iterator type! */
        fprintf(stderr, "eOidList iterator type is not implemented\n");
        abort();
    } else {
        /* Unsupported/invalid iterator type! */
        fprintf(stderr, "Invalid iterator type: %d\n", itr->itr_type);
        abort();
    }

    return retval;
}

}

BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
BEGIN_SCOPE(blast)

extern "C" {

BlastSeqSrc* SeqDbSrcNew(BlastSeqSrc* retval, void* args)
{
    SSeqDbSrcNewArgs* rargs = (SSeqDbSrcNewArgs*) args;

    if (!retval)
        return NULL;

    ASSERT(rargs);

    string db_name(rargs->dbname);
    char db_type = static_cast<char>((rargs->is_protein ? 'p' : 'n'));
    CSeqDB* seqdb(new CSeqDB(db_name, db_type, (Uint4)rargs->first_db_seq, 
                             (Uint4)rargs->final_db_seq, true));

    /* Initialize the BlastSeqSrc structure fields with user-defined function
     * pointers and seqdb */
    SetDeleteFnPtr(retval, &SeqDbSrcFree);
    SetDataStructure(retval, (void*) seqdb);
    SetGetNumSeqs(retval, &SeqDbGetNumSeqs);
    SetGetMaxSeqLen(retval, &SeqDbGetMaxLength);
    SetGetAvgSeqLen(retval, &SeqDbGetAvgLength);
    SetGetTotLen(retval, &SeqDbGetTotLen);
    SetGetAvgSeqLen(retval, &SeqDbGetAvgLength);
    SetGetName(retval, &SeqDbGetName);
    SetGetDefinition(retval, &SeqDbGetDefinition);
    SetGetDate(retval, &SeqDbGetDate);
    SetGetIsProt(retval, &SeqDbGetIsProt);
    SetGetSequence(retval, &SeqDbGetSequence);
    SetGetSeqIdStr(retval, &SeqDbGetSeqIdStr);
    SetGetSeqId(retval, &SeqDbGetSeqId);
    SetGetSeqLoc(retval, &SeqDbGetSeqLoc);
    SetGetSeqLen(retval, &SeqDbGetSeqLen);
    SetGetNextChunk(retval, &SeqDbGetNextChunk);
    SetIterNext(retval, &SeqDbIteratorNext);
    SetGetError(retval, &SeqDbGetError);
    SetRetSequence(retval, &SeqDbRetSequence);

    return retval;
}

BlastSeqSrc* SeqDbSrcFree(BlastSeqSrc* seq_src)
{
    if (!seq_src) 
        return NULL;
    CSeqDB* seqdb = static_cast<CSeqDB*>(GetDataStructure(seq_src));
    delete seqdb;
    sfree(seq_src);
    return NULL;
}

}

BlastSeqSrc* 
SeqDbSrcInit(const char* dbname, Boolean is_prot, Int4 first_seq, 
                      Int4 last_seq, void*)
{
    BlastSeqSrcNewInfo bssn_info;
    BlastSeqSrc* seq_src = NULL;
    SSeqDbSrcNewArgs* seqdb_args = 
        (SSeqDbSrcNewArgs*) calloc(1, sizeof(SSeqDbSrcNewArgs));;
    seqdb_args->dbname = strdup(dbname);
	seqdb_args->is_protein = is_prot ? true : false;
    seqdb_args->first_db_seq = first_seq;
    seqdb_args->final_db_seq = last_seq; 
    bssn_info.constructor = &SeqDbSrcNew;
    bssn_info.ctor_argument = (void*) seqdb_args;

    seq_src = BlastSeqSrcNew(&bssn_info);
    sfree(seqdb_args->dbname);
    sfree(seqdb_args);
    return seq_src;
}


END_SCOPE(blast)
END_NCBI_SCOPE


/* @} */

/*
 * ===========================================================================
 *
 * $Log: seqdb_src.cpp,v $
 * Revision 1000.1  2004/06/01 18:06:22  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.11
 *
 * Revision 1.11  2004/05/24 17:26:08  camacho
 * Fix PC warning
 *
 * Revision 1.10  2004/05/21 21:41:02  gorelenk
 * Added PCH ncbi_pch.hpp
 *
 * Revision 1.9  2004/05/19 15:26:47  dondosha
 * Removed unused variables
 *
 * Revision 1.8  2004/05/17 18:11:15  dondosha
 * Minor: eliminates strict compiler warning
 *
 * Revision 1.7  2004/05/17 15:49:07  dondosha
 * Removed local variable declaration in empty SeqDbGetName method, to eliminate compiler warning
 *
 * Revision 1.6  2004/05/17 15:43:21  dondosha
 * Return NULL from SeqDbGetName until CSeqDB gets a GetName method
 *
 * Revision 1.5  2004/04/28 19:38:20  dondosha
 * Added implementation of BLASTSeqSrcRetSequence function
 *
 * Revision 1.4  2004/04/12 14:58:42  ucko
 * Avoid placing static C functions inside namespace blocks to keep the
 * SGI MIPSpro compiler from segfaulting in Scope Setup.
 *
 * Revision 1.3  2004/04/08 14:45:48  camacho
 * 1. Added missing extern "C" declarations
 * 2. Removed compiler warnings about unused parameters.
 * 3. Removed dead code.
 * 4. Added FIXMEs.
 *
 * Revision 1.2  2004/04/07 18:45:13  bealer
 * - Update constructor for CSeqDB to omit obsolete first argument.
 *
 * Revision 1.1  2004/04/06 20:43:59  dondosha
 * Sequence source for CSeqDB BLAST database interface
 *
 * ===========================================================================
 */