validerror_align.cpp

来自「ncbi源码」· C++ 代码 · 共 1,121 行 · 第 1/3 页

/*
 * ===========================================================================
 * PRODUCTION $Log: validerror_align.cpp,v $
 * PRODUCTION Revision 1000.1  2004/06/01 19:47:45  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.8
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: validerror_align.cpp,v 1000.1 2004/06/01 19:47:45 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Jonathan Kans, Clifford Clausen, Aaron Ucko......
 *
 * File Description:
 *   validation of seq_align
 *   .......
 *
 */
#include <ncbi_pch.hpp>
#include <corelib/ncbistd.hpp>

#include <objects/seqalign/Seq_align.hpp>
#include <objects/seqalign/Dense_diag.hpp>
#include <objects/seqalign/Dense_seg.hpp>
#include <objects/seqalign/Packed_seg.hpp>
#include <objects/seqalign/Seq_align_set.hpp>
#include <objects/seqalign/Std_seg.hpp>
#include <objmgr/util/sequence.hpp>

#include <map>
#include <vector>
#include <algorithm>

#include "validatorp.hpp"


BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)
BEGIN_SCOPE(validator)

USING_SCOPE(sequence);


// ================================  Public  ================================


CValidError_align::CValidError_align(CValidError_imp& imp) :
    CValidError_base(imp)
{
}


CValidError_align::~CValidError_align(void)
{
}


void CValidError_align::ValidateSeqAlign(const CSeq_align& align)
{
    const CSeq_align::TSegs& segs = align.GetSegs();
    CSeq_align::C_Segs::E_Choice segtype = segs.Which();
    switch ( segtype ) {
    
    case CSeq_align::C_Segs::e_Dendiag:
        x_ValidateDendiag(segs.GetDendiag(), align);
        break;

    case CSeq_align::C_Segs::e_Denseg:
        x_ValidateDenseg(segs.GetDenseg(), align);
        break;

    case CSeq_align::C_Segs::e_Std:
        x_ValidateStd(segs.GetStd(), align);
        break;
    case CSeq_align::C_Segs::e_Packed:
        x_ValidatePacked(segs.GetPacked(), align);
        break;

    case CSeq_align::C_Segs::e_Disc:
        // call recursively
        ITERATE(CSeq_align_set::Tdata, sali, segs.GetDisc().Get()) {
            ValidateSeqAlign(**sali);
        }
        return;

    case CSeq_align::C_Segs::e_not_set:
    default:
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_Segtype,
            "This alignment has undefined or unsupported Seq_align"
            "segtype " + NStr::IntToString(segtype) + ".", align);
        break;
    }  // end of switch statement
}


// ================================  Private  ===============================


void CValidError_align::x_ValidateDenseg
(const TDenseg& denseg,
 const CSeq_align& align)
{
    bool cont = true;

    // assert dim >= 2
    if ( !x_ValidateDim(denseg, align) ) {
        return;
    }

    size_t dim     = denseg.GetDim();
    size_t numseg  = denseg.GetNumseg();

    // assert dim == Ids.size()
    if ( dim != denseg.GetIds().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
                "Mismatch between specified dimension (" +
                NStr::UIntToString(dim) + 
                ") and number of Seq-ids (" + 
                NStr::UIntToString(denseg.GetIds().size()) + ")",
                align);
        cont = false;
    }

    // assert numseg == Lens.size()
    if ( numseg != denseg.GetLens().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsNumsegMismatch,
                "Mismatch between specified numseg (" +
                NStr::UIntToString(numseg) + 
                ") and number of Lens (" + 
                NStr::UIntToString(denseg.GetLens().size()) + ")",
                align);
        cont = false;
    }

    // assert dim * numseg == Starts.size()
    if ( dim * numseg != denseg.GetStarts().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsStartsMismatch,
                "The number of Starts (" + 
                NStr::UIntToString(denseg.GetStarts().size()) +
                ") does not match the expected size of dim * numseg (" +
                NStr::UIntToString(dim * numseg) + ")", align);
        cont = false;
    } 

    if( cont ) {
        x_ValidateStrand(denseg, align);
        x_ValidateFastaLike(denseg, align);
        x_ValidateSegmentGap(denseg, align);
        
        if ( m_Imp.IsRemoteFetch() ) {
            x_ValidateSeqId(align);
            x_ValidateSeqLength(denseg, align);
        }
    }
}




void CValidError_align::x_ValidatePacked
(const TPacked& packed,
 const CSeq_align& align)
{
    bool cont = true;

    // assert dim >= 2
    if ( !x_ValidateDim(packed, align) ) {
        return;
    }

    size_t dim     = packed.GetDim();
    size_t numseg  = packed.GetNumseg();
    
    // assert dim == Ids.size()
    if ( dim != packed.GetIds().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
            "Mismatch between specified dimension (" +
            NStr::UIntToString(dim) + 
            ") and number of Seq-ids (" + 
            NStr::UIntToString(packed.GetIds().size()) + ")",
            align);
        cont = false;
    }
    
    // assert numseg == Lens.size()
    if ( numseg != packed.GetLens().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
            "Mismatch between specified numseg (" +
            NStr::UIntToString(numseg) + 
            ") and number of Lens (" + 
            NStr::UIntToString(packed.GetLens().size()) + ")",
            align);
        cont = false;
    }
    
    // assert dim * numseg == Present.size()
    if ( dim * numseg != packed.GetPresent().size() ) {
        PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsPresentMismatch,
                "The number of Present (" + 
                NStr::UIntToString(packed.GetPresent().size()) +
                ") does not match the expected size of dim * numseg (" +
                NStr::UIntToString(dim * numseg) + ")", align);
        cont = false;
    } else {
        // assert # of '1' bits in present == Starts.size()
        size_t bits = x_CountBits(packed.GetPresent());
        if ( bits != packed.GetStarts().size() ) {
            PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsPresentStartsMismatch,
                "Starts does not have the same number of elements (" +
                NStr::UIntToString(packed.GetStarts().size()) + 
                ") as specified by Present (" + NStr::UIntToString(bits) +
                ")", align);
            cont = false;
        }

        // assert # of '1' bits in present == Strands.size() (if exists)
        if ( packed.IsSetStrands() ) {
            if ( bits != packed.GetStarts().size() ) {
                PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsPresentStrandsMismatch,
                    "Strands does not have the same number of elements (" +
                    NStr::UIntToString(packed.GetStrands().size()) +
                    ") as specified by Present (" +
                    NStr::UIntToString(bits) + ")", align);
                cont = false;
            }
        }
    }
    
    if( cont ) {
        x_ValidateStrand(packed, align);
        x_ValidateFastaLike(packed, align);
        x_ValidateSegmentGap(packed, align);
        
        if ( m_Imp.IsRemoteFetch() ) {
            x_ValidateSeqId(align);
            x_ValidateSeqLength(packed, align);
        }
    }
}


size_t CValidError_align::x_CountBits(const CPacked_seg::TPresent& present)
{
    size_t bits = 0;
    ITERATE( CPacked_seg::TPresent, iter, present ) {
        if ( *iter != 0 ) {
            Uchar mask = 0x01;
            for ( size_t i = 0; i < 7; ++i ) {
                bits += (*iter & mask) ? 1 : 0;
                mask = mask << 1;
            }
        }
    }
    return bits;
}


void CValidError_align::x_ValidateDendiag
(const TDendiag& dendiags,
 const CSeq_align& align)
{
    size_t num_dendiag = 0;
    ITERATE( TDendiag, dendiag_iter, dendiags ) {
        bool cont = true;
        ++num_dendiag;

        const CDense_diag& dendiag = **dendiag_iter;
        size_t dim = dendiag.GetDim();

        // assert dim >= 2
        if ( !x_ValidateDim(dendiag, align, num_dendiag) ) {
            continue;
        }

        // assert dim == Ids.size()
        if ( dim != dendiag.GetIds().size() ) {
            PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
                "Mismatch between specified dimension (" +
                NStr::UIntToString(dim) + 
                ") and number of Seq-ids (" + 
                NStr::UIntToString(dendiag.GetIds().size()) + ") in dendiag " +
                NStr::UIntToString(num_dendiag), align);
            cont = false;
        }

        // assert dim == Starts.size()
        if ( dim != dendiag.GetStarts().size() ) {
            PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
                "Mismatch between specified dimension (" +
                NStr::UIntToString(dim) + 
                ") and number ofStarts (" + 
                NStr::UIntToString(dendiag.GetStarts().size()) + 
                ") in dendiag " + NStr::UIntToString(num_dendiag), align);
            cont = false;
        } 

        // assert dim == Strands.size() (if exist)
        if ( dendiag.IsSetStrands() ) {
            if ( dim != dendiag.GetStrands().size() ) {
                PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
                    "Mismatch between specified dimension (" +
                    NStr::UIntToString(dim) + 
                    ") and number of Strands (" + 
                    NStr::UIntToString(dendiag.GetStrands().size()) + 
                    ") in dendiag " + NStr::UIntToString(num_dendiag), align);
                cont = false;
            } 
        }

        if ( cont ) {
            if ( m_Imp.IsRemoteFetch() ) {
                x_ValidateSeqId(align);
                x_ValidateSeqLength(dendiag, num_dendiag, align);
            }
        }
    }
}


void CValidError_align::x_ValidateStd
(const TStd& std_segs,
 const CSeq_align& align)
{
    bool cont = true;

    size_t num_stdseg = 0;
    ITERATE( TStd, stdseg_iter, std_segs) {
        ++num_stdseg;

        const CStd_seg& stdseg = **stdseg_iter;
        size_t dim = stdseg.GetDim();

        // assert dim >= 2
        if ( !x_ValidateDim(stdseg, align, num_stdseg) ) {
            cont = false;
            continue;
        }

        // assert dim == Loc.size()
        if ( dim != stdseg.GetLoc().size() ) {
            PostErr(eDiag_Error, eErr_SEQ_ALIGN_SegsDimMismatch,
                "Mismatch between specified dimension (" +
                NStr::UIntToString(dim) + 
                ") and number of Seq-locs (" + 
                NStr::UIntToString(stdseg.GetLoc().size()) + ") in stdseg " +
                NStr::UIntToString(num_stdseg), align);
            cont = false;
            continue;
        }

        // assert dim == Ids.size()