queue_poll.cpp

ncbi源码

    }
    
    if (cb4o.Empty()) {
        err +="Combination of program [";
        err += program;
        err += "] and service [";
        err += service;
        err += " is not supported.\n";
    } else {
        cb4o->SetDatabase(database);
        
        // Should the following adjustment / workaround be in...
        // ... CRemoteBlast ?
        // ... blast4 server?
        // ... right here?
        
        if (query->GetSeq_set().front()->IsSeq()) {
            cb4o->SetQueries(query);
        } else {
            const CBioseq_set * myset = & query->GetSeq_set().front()->GetSet();
            CBioseq_set * myset2 = (CBioseq_set *) myset;
            
            cb4o->SetQueries(CRef<CBioseq_set>(myset2));
        }
        
        cb4o->SetQueries (query);
    }
    
    return cb4o;
}

static CRef<CRemoteBlast>
s_QueueSearch(string              & program,
              string              & service,
              string              & database,
              CNetblastSearchOpts & opts,
              CRef<CBioseq_set>     query,
              string              & err)
{
    CRef<CRemoteBlast> cb4o
        = s_SetBlast4Params(program,
                            service,
                            database,
                            opts,
                            query,
                            err);
    
    if (cb4o.NotEmpty()) {
        string cb4err(cb4o->GetErrors());
        
        if (cb4err.size()) {
            err += cb4err + "\n";
        }
    }
    
    return cb4o;
}

inline double dbl_time(void)
{
    struct timeval tv;
    gettimeofday(& tv, 0);
    
    return tv.tv_sec + double(tv.tv_usec) / 1000000.0;
}

static void
s_ShowAlign(CNcbiOstream         & os,
            CRef<CRemoteBlast>   cb4o,
            CRef<CScope>           scope,
            CAlignParms          & alparms,
            bool                   /*gapped*/)
{
    CRef<CSeq_align_set> alignments = cb4o->GetAlignments();
    
    if (alignments.Empty()) {
        os << "This search did not find any matches.\n";
        return;
    }
    
    list <CDisplaySeqalign::SeqlocInfo*>  none1;
    list <CDisplaySeqalign::FeatureInfo*> none2;
    
    AutoPtr<CDisplaySeqalign> dsa_ptr;
    
    // if (async_mode || (! gapped)) {
    
    // 1. The "prepare" function needs to be called in ungapped mode.
    // 2. It's safe to call this even if it is not needed (i.e. gapped mode).
    // 3. If not needed, it takes almost no time compared to the actual display,
    //    the ratio seems to be about 80,000 to 1.
    // 4. We can't tell if we are in gapped mode in the async case.
    // 5. So, we always call the prepare function.
    
    CRef<CSeq_align_set> newalign =
        CDisplaySeqalign::PrepareBlastUngappedSeqalign(*alignments);
    
    dsa_ptr = new CDisplaySeqalign(*newalign, none1, none2, 0, * scope);
    
    // } else {
    //     dsa_ptr = new CDisplaySeqalign(*alignments, none1, none2, 0, * scope);
    // }
    
    alparms.AdjustDisplay(*dsa_ptr);
    
    dsa_ptr->DisplaySeqalign(os);
}

void ShowResults(CRef<CRemoteBlast>  cb4o,
                 CRef<CScope>          scope,
                 CAlignParms         & alparms,
                 bool                  async_mode,
                 bool                  raw_asn)
{
    bool display = false;
    
    if (async_mode) {
        // Note that in ASYNC mode, we ONLY report status.  The user
        // can rerun without -async_mode to get results.  This is to
        // facilitate script writers (...is this a good decision?)
        
        bool   rid_done  = cb4o->CheckDone();
        string err       = cb4o->GetErrors();
        
        if (! err.empty()) {
            cout << "STATUS [error:" << err << "] RID [" << cb4o->GetRID() << "]" << endl;
        } else {
            string status = (rid_done ? "done" : "pending");
            cout << "STATUS [" << status << "] RID [" << cb4o->GetRID() << "]" << endl;
        }
    } else {
        cb4o->SubmitSync();
        string err = cb4o->GetErrors();
        
        if (! err.empty()) {
            cout << "STATUS [error:" << err << "] RID [" << cb4o->GetRID() << "]" << endl;
        } else {
            display = true;
        }
    }
    
    if (display) {
        bool gapped = true;
        
        // if (opts.Gapped().Exists()) {
        //     gapped = opts.Gapped().GetValue();
        // }
        
        if (raw_asn) {
            s_Output(NcbiCout, cb4o->GetAlignments());
        } else {
            s_ShowAlign(NcbiCout, cb4o, scope, alparms, gapped);
        }
    }
}

// Int4
// QueueAndPoll(string                program,
//              string                service,
//              string                database,
//              CNetblastSearchOpts & opts,
//              CNcbiIstream        & query_in,
//              bool                  verbose,
//              bool                  trust_defline,
//              bool                  raw_asn,
//              CAlignParms         & alparms,
//              bool                  async_mode,
//              string                get_RID)
// {
//     // no dice
//     return 123;
// }

Int4
QueueAndPoll(string                program,
             string                service,
             string                database,
             CNetblastSearchOpts & opts,
             CNcbiIstream        & query_in,
             bool                  verbose,
             bool                  trust_defline,
             bool                  raw_asn,
             CAlignParms         & alparms,
             bool                  async_mode,
             string                get_RID)
{
    Int4 err_ret = 0;
        
    // Read the FASTA input data
    string fasta_line1;
    string fasta_block;
        
    // Queue and poll
    CRef<CObjectManager> objmgr(new CObjectManager);
    CRef<CScope>         scope (new CScope(*objmgr));
        
    objmgr->RegisterDataLoader(*new CGBDataLoader("ID", 0, 2),
                               CObjectManager::eDefault);
    
    scope->AddDefaults();
        
    string err;
    
    CRef<CRemoteBlast> cb4o;
    
    CRef<CBioseq_set> cbss;
    
    bool amino = s_QueryIsAmino(program);
    
    int flags = fReadFasta_AllSeqIds; // | fReadFasta_OneSeq;
    
    if (amino) {
        flags |= fReadFasta_AssumeProt;
    } else {
        flags |= fReadFasta_AssumeNuc;
    }
    
    if (! trust_defline) {
        flags |= fReadFasta_NoParseID;
    }
    
    cbss = s_SetupQuery(query_in, scope, flags);
    
    if (get_RID.empty()) {
        cb4o = s_QueueSearch(program,
                             service,
                             database,
                             opts,
                             cbss,
                             err);
    
        if (cb4o.Empty() && err.empty()) {
            err = "Internal: Did not get search object from s_QueueSearch()\n";
        }
        
        if (err.empty() && verbose) {
            cb4o->SetVerbose(CRemoteBlast::eDebug);
        }
        
        if (err.empty()) {
            if (async_mode) {
                cb4o->Submit();
            } else {
                cb4o->SubmitSync();
            }
        } else {
            err_ret = 1;
        }
    } else {
        cb4o.Reset( new CRemoteBlast(get_RID) );
    }
    
    if (! err.empty()) {
        cerr << err << endl;
    } else {
        ShowResults(cb4o, scope, alparms, async_mode, raw_asn);
    }
    
    return err_ret;
}

/*
 * ===========================================================================
 *
 * $Log: queue_poll.cpp,v $
 * Revision 1000.2  2004/06/01 18:06:48  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
 *
 * Revision 1.6  2004/05/21 21:41:03  gorelenk
 * Added PCH ncbi_pch.hpp
 *
 * Revision 1.5  2004/05/19 14:52:02  camacho
 * 1. Added doxygen tags to enable doxygen processing of algo/blast/core
 * 2. Standardized copyright, CVS $Id string, $Log and rcsid formatting and i
 *    location
 * 3. Added use of @todo doxygen keyword
 *
 * Revision 1.4  2004/04/19 14:37:52  bealer
 * - Fix compiler warnings.
 *
 * Revision 1.3  2004/03/22 20:46:21  bealer
 * - Fix non-literate comments to look less like doxygen comments.
 *
 * Revision 1.2  2004/02/18 20:28:18  bealer
 * - Always call prepare function.
 * - Set verbosity flag earlier.
 *
 * Revision 1.1  2004/02/18 17:04:41  bealer
 * - Adapt blast_client code for Remote Blast API, merging code into the
 *   remote_blast demo application.
 *
 * ===========================================================================
 */