blast_options.hpp

ncbi源码

            m_Local->SetGapTracebackAlgorithm(a);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_GapTracebackAlgorithm, a);
        }
    }

    void SetSkipTraceback(bool skip = true)
    {
        if (m_Local) {
            m_Local->SetSkipTraceback(skip);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_SkipTraceback, skip);
        }
    }

    /******************* Hit saving options *************************/
    int GetHitlistSize() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetHitlistSize() not available.");
        }
        return m_Local->GetHitlistSize();
    }
    void SetHitlistSize(int s)
    {
        if (m_Local) {
            m_Local->SetHitlistSize(s);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_HitlistSize, s);
        }
    }

    int GetPrelimHitlistSize() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetPrelimHitlistSize() not available.");
        }
        return m_Local->GetPrelimHitlistSize();
    }
    void SetPrelimHitlistSize(int s)
    {
        if (m_Local) {
            m_Local->SetPrelimHitlistSize(s);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_PrelimHitlistSize, s);
        }
    }

    int GetMaxNumHspPerSequence() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetMaxNumHspPerSequence() not available.");
        }
        return m_Local->GetMaxNumHspPerSequence();
    }
    void SetMaxNumHspPerSequence(int m)
    {
        if (m_Local) {
            m_Local->SetMaxNumHspPerSequence(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_MaxNumHspPerSequence, m);
        }
    }

    /// Maximum total number of HSPs to keep
    int GetTotalHspLimit() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetTotalHspLimit() not available.");
        }
        return m_Local->GetTotalHspLimit();
    }
    void SetTotalHspLimit(int l)
    {
        if (m_Local) {
            m_Local->SetTotalHspLimit(l);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_TotalHspLimit, l);
        }
    }

    bool GetCullingMode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetCullingMode() not available.");
        }
        return m_Local->GetCullingMode();
    }
    void SetCullingMode(bool m = true)
    {
        if (m_Local) {
            m_Local->SetCullingMode(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_CullingMode, m);
        }
    }

    /// Start of the region required to be part of the alignment
    int GetRequiredStart() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetRequiredStart() not available.");
        }
        return m_Local->GetRequiredStart();
    }
    void SetRequiredStart(int s)
    {
        if (m_Local) {
            m_Local->SetRequiredStart(s);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_RequiredStart, s);
        }
    }

    /// End of the region required to be part of the alignment
    int GetRequiredEnd() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetRequiredEnd() not available.");
        }
        return m_Local->GetRequiredEnd();
    }
    void SetRequiredEnd(int e)
    {
        if (m_Local) {
            m_Local->SetRequiredEnd(e);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_RequiredEnd, e);
        }
    }

    // Expect value cut-off threshold for an HSP, or a combined hit if sum
    // statistics is used
    double GetEvalueThreshold() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetEvalueThreshold() not available.");
        }
        return m_Local->GetEvalueThreshold();
    }
    void SetEvalueThreshold(double eval)
    {
        if (m_Local) {
            m_Local->SetEvalueThreshold(eval);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_EvalueThreshold, eval);
        }
    }

    double GetOriginalEvalue() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetOriginalEvalue() not available.");
        }
        return m_Local->GetOriginalEvalue();
    }
    //void SetOriginalEvalue(double e);

    // Raw score cutoff threshold
    int GetCutoffScore() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetCutoffScore() not available.");
        }
        return m_Local->GetCutoffScore();
    }
    void SetCutoffScore(int s)
    {
        if (m_Local) {
            m_Local->SetCutoffScore(s);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_CutoffScore, s);
        }
    }

    double GetPercentIdentity() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetPercentIdentity() not available.");
        }
        return m_Local->GetPercentIdentity();
    }
    void SetPercentIdentity(double p)
    {
        if (m_Local) {
            m_Local->SetPercentIdentity(p);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_PercentIdentity, p);
        }
    }

    /// Sum statistics options
    bool GetSumStatisticsMode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetSumStatisticsMode() not available.");
        }
        return m_Local->GetSumStatisticsMode();
    }
    void SetSumStatisticsMode(bool m = true)
    {
        if (m_Local) {
            m_Local->SetSumStatisticsMode(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_SumStatisticsMode, m);
        }
    }

    int GetLongestIntronLength() const // for tblastn w/ linking HSPs
    {
        if (! m_Local) {
            x_Throwx("Error: GetLongestIntronLength() not available.");
        }
        return m_Local->GetLongestIntronLength();
    }
    void SetLongestIntronLength(int l) // for tblastn w/ linking HSPs
    {
        if (m_Local) {
            m_Local->SetLongestIntronLength(l);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_LongestIntronLength, l);
        }
    }


    /// Returns true if gapped BLAST is set, false otherwise
    bool GetGappedMode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetGappedMode() not available.");
        }
        return m_Local->GetGappedMode();
    }
    void SetGappedMode(bool m = true)
    {
        if (m_Local) {
            m_Local->SetGappedMode(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_GappedMode, m);
        }
    }

    // Deprecated
    bool GetNeighboringMode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetNeighboringMode() not available.");
        }
        return m_Local->GetNeighboringMode();
    }
    // Deprecated
    void SetNeighboringMode(bool m = true)
    {
        if (m_Local) {
            m_Local->SetNeighboringMode(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_NeighboringMode, m);
        }
    }

    /************************ Scoring options ************************/
    const char* GetMatrixName() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetMatrixName() not available.");
        }
        return m_Local->GetMatrixName();
    }
    void SetMatrixName(const char* matrix)
    {
        if (m_Local) {
            m_Local->SetMatrixName(matrix);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_MatrixName, matrix);
        }
    }

    const char* GetMatrixPath() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetMatrixPath() not available.");
        }
        return m_Local->GetMatrixPath();
    }
    void SetMatrixPath(const char* path)
    {
        if (m_Local) {
            m_Local->SetMatrixPath(path);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_MatrixPath, path);
        }
    }

    int GetMatchReward() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetMatchReward() not available.");
        }
        return m_Local->GetMatchReward();
    }
    void SetMatchReward(int r)
    {
        if (m_Local) {
            m_Local->SetMatchReward(r);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_MatchReward, r);
        }
    }

    int GetMismatchPenalty() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetMismatchPenalty() not available.");
        }
        return m_Local->GetMismatchPenalty();
    }
    void SetMismatchPenalty(int p)
    {
        if (m_Local) {
            m_Local->SetMismatchPenalty(p);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_MismatchPenalty, p);
        }
    }

    int GetGapOpeningCost() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetGapOpeningCost() not available.");
        }
        return m_Local->GetGapOpeningCost();
    }
    void SetGapOpeningCost(int g)
    {
        if (m_Local) {
            m_Local->SetGapOpeningCost(g);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_GapOpeningCost, g);
        }
    }

    int GetGapExtensionCost() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetGapExtensionCost() not available.");
        }
        return m_Local->GetGapExtensionCost();
    }
    void SetGapExtensionCost(int e)
    {
        if (m_Local) {
            m_Local->SetGapExtensionCost(e);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_GapExtensionCost, e);
        }
    }

    int GetFrameShiftPenalty() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetFrameShiftPenalty() not available.");
        }
        return m_Local->GetFrameShiftPenalty();
    }
    void SetFrameShiftPenalty(int p)
    {
        if (m_Local) {
            m_Local->SetFrameShiftPenalty(p);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_FrameShiftPenalty, p);
        }
    }

    int GetDecline2AlignPenalty() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetDecline2AlignPenalty() not available.");
        }
        return m_Local->GetDecline2AlignPenalty();
    }
    void SetDecline2AlignPenalty(int p)
    {
        if (m_Local) {
            m_Local->SetDecline2AlignPenalty(p);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_Decline2AlignPenalty, p);
        }
    }

    bool GetOutOfFrameMode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetOutOfFrameMode() not available.");
        }
        return m_Local->GetOutOfFrameMode();
    }
    void SetOutOfFrameMode(bool m = true)
    {
        if (m_Local) {
            m_Local->SetOutOfFrameMode(m);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_OutOfFrameMode, m);
        }
    }

    /******************** Effective Length options *******************/
    Int8 GetDbLength() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetDbLength() not available.");
        }
        return m_Local->GetDbLength();
    }
    void SetDbLength(Int8 l)
    {
        if (m_Local) {
            m_Local->SetDbLength(l);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_DbLength, l);
        }
    }

    unsigned int GetDbSeqNum() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetDbSeqNum() not available.");
        }
        return m_Local->GetDbSeqNum();
    }
    void SetDbSeqNum(unsigned int n)
    {
        if (m_Local) {
            m_Local->SetDbSeqNum(n);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_DbSeqNum, n);
        }
    }

    Int8 GetEffectiveSearchSpace() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetEffectiveSearchSpace() not available.");
        }
        return m_Local->GetEffectiveSearchSpace();
    }
    void SetEffectiveSearchSpace(Int8 eff)
    {
        if (m_Local) {
            m_Local->SetEffectiveSearchSpace(eff);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_EffectiveSearchSpace, eff);
        }
    }

    bool GetUseRealDbSize() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetUseRealDbSize() not available.");
        }
        return m_Local->GetUseRealDbSize();
    }
    void SetUseRealDbSize(bool u = true)
    {
        if (m_Local) {
            m_Local->SetUseRealDbSize(u);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_UseRealDbSize, u);
        }
    }

    int GetDbGeneticCode() const
    {
        if (! m_Local) {
            x_Throwx("Error: GetDbGeneticCode() not available.");
        }
        return m_Local->GetDbGeneticCode();
    }
    
    //const unsigned char* GetDbGeneticCodeStr() const
    //{
    //    if (! m_Local) {
    //        throw string("Error: GetDbGeneticCodeStr() not available.");
    //    }
    //    return m_Local->GetDbGeneticCodeStr();
    //}
    //void SetDbGeneticCodeStr(const unsigned char* gc_str);
    
    // Set both integer and string genetic code in one call
    void SetDbGeneticCode(int gc)
    {
        if (m_Local) {
            m_Local->SetDbGeneticCode(gc);
        }
        if (m_Remote) {
            m_Remote->SetValue(eBlastOpt_DbGeneticCode, gc);
        }
    }