validerror_bioseq.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: validerror_bioseq.cpp 100298 2023-07-18 17:48:57Z kans $
 * ===========================================================================
 *
 *                            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, Mati Shomrat ......
 *
 * File Description:
 *   validation of bioseq
 *   .......
 *
 */
#include <ncbi_pch.hpp>
#include <corelib/ncbistd.hpp>
#include <corelib/ncbistr.hpp>
#include <corelib/ncbitime.hpp>
#include <corelib/ncbimisc.hpp>
 
#include <objtools/validator/validerror_bioseq.hpp>
#include <objtools/validator/validator_context.hpp>
#include <objtools/validator/dup_feats.hpp>
#include <objtools/error_codes.hpp>
 
#include <objects/seq/seqport_util.hpp>
 
#include <objmgr/seqdesc_ci.hpp>
#include <objmgr/graph_ci.hpp>
#include <objmgr/util/sequence.hpp>
 
#include <objects/taxon1/taxon1.hpp>
 
#include <optional>
 
 
#define NCBI_USE_ERRCODE_X   Objtools_Validator
 
BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)
BEGIN_SCOPE(validator)
USING_SCOPE(sequence);
USING_SCOPE(feature);
 
class CCdsMatchInfo;
 
class CMrnaMatchInfo : public CObject {
public:
    CMrnaMatchInfo(const CSeq_feat& mrna, CScope* scope);
    const CSeq_feat& GetSeqfeat() const;
    bool Overlaps(const CSeq_feat& cds) const;
    void SetMatch();
    bool HasMatch() const;
    void SetPseudo(bool val = true) { m_IsPseudo = val; }
    bool OkWithoutCds(bool isGenbank = false) const;
 
private:
    CConstRef<CSeq_feat> m_Mrna;
 
    CScope* m_Scope;
    bool m_HasMatch;
    bool m_IsPseudo;
};
 
 
class CCdsMatchInfo : public CObject {
public:
    CCdsMatchInfo(const CSeq_feat& cds, CScope* scope);
    const CSeq_feat& GetSeqfeat() const;
    bool Overlaps(const CSeq_feat& mrna) const;
    bool AssignXrefMatch(TmRNAList& unmatched_mrnas, const CTSE_Handle& tse);
    bool AssignOverlapMatch(TmRNAList& unmatched_mrnas, CScope& scope);
    void UpdateOtherMrnas(const TmRNAList& unmatched_mrnas);
    size_t CountOtherMrnas() { return m_OtherMrnas.size(); }
    bool AreMrnaProductsUnique() { return m_ProductsUnique; }
    void SetMatch(CRef<CMrnaMatchInfo> match);
    bool AssignMatch(TmRNAList& mrna_map, CFeatTree& feat_tree, CScope& scope);
    bool HasMatch() const;
    void NeedsMatch(bool needs_match);
    bool NeedsMatch() const;
    const CMrnaMatchInfo& GetMatch() const;
    bool IsPseudo() const;
    void SetPseudo();
 
private:
    CConstRef<CSeq_feat> m_Cds;
    CRef<CMrnaMatchInfo> m_BestMatch;
 
    sequence::EOverlapType m_OverlapType;
    CScope* m_Scope;
    bool m_IsPseudo;
    bool m_NeedsMatch;
    list<CConstRef<CSeq_feat> > m_OtherMrnas;
    bool m_ProductsUnique;
};
 
 
// =============================================================================
//                                     Public
// =============================================================================
 
CValidError_bioseq::CValidError_bioseq(CValidError_imp& imp) :
    CValidError_base(imp), m_AnnotValidator(imp), m_DescrValidator(imp), m_FeatValidator(imp), m_GeneIt(nullptr), m_AllFeatIt(nullptr)
{
}
 
 
CValidError_bioseq::~CValidError_bioseq()
{
}
 
void CValidError_bioseq::x_SetupCommonFlags (CBioseq_Handle bsh)
{
 
    CMolInfo::TTech tech = CMolInfo::eTech_unknown;
    CSeq_inst::TRepr repr = CSeq_inst::eRepr_not_set;
 
    if (bsh.IsSetInst_Repr()) {
        repr = bsh.GetInst_Repr();
    }
 
    CSeqdesc_CI m(bsh, CSeqdesc::e_Molinfo);
    while (m)
    {
        const CSeqdesc::TMolinfo& mi = m->GetMolinfo();
        if (mi.IsSetTech()) {
             tech = mi.GetTech();
        }
 
        ++m;
    }
 
    for (auto id : bsh.GetId()) {
        CSeq_id::EAccessionInfo acc_info = id.IdentifyAccession();
        unsigned int acc_div =  acc_info & CSeq_id::eAcc_division_mask;
        if (acc_div == CSeq_id::eAcc_wgs && tech == CMolInfo::eTech_wgs && repr == CSeq_inst::eRepr_virtual) {
            bool is_wgs_master = (acc_info & CSeq_id::fAcc_master) != 0;
            if (is_wgs_master) {
                m_report_short_seq = false;
            }
        }
    }
 
    CSeqdesc_CI d(bsh, CSeqdesc::e_Source);
    while (d)
    {
        const CSeqdesc::TSource& source = d->GetSource();
 
        // look for chromosome, prokaryote, linkage group
        FOR_EACH_SUBSOURCE_ON_BIOSOURCE(it, source) {
            if ((*it)->IsSetSubtype() && (*it)->IsSetName() && !NStr::IsBlank((*it)->GetName())) {
                if ((*it)->GetSubtype() == CSubSource::eSubtype_chromosome) {
                    m_report_missing_chromosome = false;
                } else if ((*it)->GetSubtype() == CSubSource::eSubtype_linkage_group) {
                    m_report_missing_chromosome = false;
                }
            }
        }
        if (source.IsSetLineage()) {
            string lineage = source.GetLineage();
            if (NStr::StartsWith(lineage, "Bacteria; ") ||
                NStr::StartsWith(lineage, "Archaea; ")) {
                m_splicing_not_expected = true;
                m_report_missing_chromosome = false;
                m_is_bact_or_arch = true;
            }
            if (NStr::StartsWith(lineage, "Viruses; ")) {
                m_report_missing_chromosome = false;
            }
        }
        if (source.IsSetDivision()) {
            string div = source.GetDivision();
            if (NStr::Equal(div, "BCT") || NStr::Equal(div, "VRL")) {
                m_splicing_not_expected = true;
                m_report_missing_chromosome = false;
            }
        }
        if (source.IsSetGenome()) {
            CBioSource::TGenome genome = source.GetGenome();
            // check for organelle
            if (IsOrganelle(genome)) {
                m_report_missing_chromosome = false;
            }
            m_is_plasmid = (genome == NCBI_GENOME(plasmid));
            m_is_chromosome = (genome == NCBI_GENOME(chromosome));
            m_is_extrachrom = (genome == NCBI_GENOME(extrachrom));
        }
 
        ++d;
    }
 
}
 
 
void CValidError_bioseq::ValidateBioseq (
    const CBioseq& seq)
{
    m_splicing_not_expected = false;
    m_report_missing_chromosome = true;
    m_report_short_seq = true;
    m_is_bact_or_arch = false;
    m_is_plasmid = false;
    m_is_chromosome = false;
    m_is_extrachrom = false;
 
    try {
        m_CurrentHandle = m_Scope->GetBioseqHandle(seq);
 
        x_SetupCommonFlags(m_CurrentHandle);
 
        CSeq_entry_Handle appropriate_parent;
        if (m_Imp.ShouldSubdivide()) {
            appropriate_parent = GetAppropriateXrefParent(m_CurrentHandle.GetSeq_entry_Handle());
        }
        if (appropriate_parent) {
            CRef<CScope> tmp_scope(new CScope(*(CObjectManager::GetInstance())));
            tmp_scope->AddDefaults();
            CSeq_entry_Handle this_seh = tmp_scope->AddTopLevelSeqEntry(*(appropriate_parent.GetCompleteSeq_entry()));
            m_FeatValidator.SetScope(*tmp_scope);
            m_FeatValidator.SetTSE(this_seh);
        } else {
            m_FeatValidator.SetScope(*m_Scope);
            m_FeatValidator.SetTSE(m_CurrentHandle.GetTopLevelEntry());
        }
 
        try {
            CCacheImpl::SFeatKey gene_key(
                CSeqFeatData::e_Gene, CCacheImpl::kAnyFeatSubtype,
                m_CurrentHandle);
            m_GeneIt = &GetCache().GetFeatFromCache(gene_key);
 
            CCacheImpl::SFeatKey all_feat_key(
                CCacheImpl::kAnyFeatType, CCacheImpl::kAnyFeatSubtype,
                m_CurrentHandle);
            m_AllFeatIt = &GetCache().GetFeatFromCache(all_feat_key);
        } catch ( const exception& ) {
            // sequence might be too broken to validate features
            m_GeneIt = nullptr;
            m_AllFeatIt = nullptr;
        }
        ValidateSeqIds(seq);
        ValidateInst(seq);
        ValidateBioseqContext(seq);
        ValidateHistory(seq);
        FOR_EACH_ANNOT_ON_BIOSEQ (annot, seq) {
            m_AnnotValidator.ValidateSeqAnnot(**annot);
            m_AnnotValidator.ValidateSeqAnnotContext(**annot, seq);
        }
        if (seq.IsSetDescr()) {
            if (m_CurrentHandle) {
                CSeq_entry_Handle ctx = m_CurrentHandle.GetSeq_entry_Handle();
                if (ctx) {
                    m_DescrValidator.ValidateSeqDescr (seq.GetDescr(), *(ctx.GetCompleteSeq_entry()));
                }
            }
        }
        if (IsWGSMaster(seq, m_CurrentHandle.GetScope())) {
            ValidateWGSMaster(m_CurrentHandle);
        }
        if (appropriate_parent) {
            m_FeatValidator.SetScope(*m_Scope);
            m_FeatValidator.SetTSE(m_Imp.GetTSEH());
        }
 
    } catch ( const exception& e ) {
        m_Imp.PostErr(eDiag_Fatal, eErr_INTERNAL_Exception,
            string("Exception while validating bioseq. EXCEPTION: ") +
            e.what(), seq);
    }
    m_CurrentHandle.Reset();
    if (m_GeneIt) {
        m_GeneIt = nullptr;
    }
    if (m_AllFeatIt) {
        m_AllFeatIt = nullptr;
    }
}
 
 
static bool s_IsSkippableDbtag (const CDbtag& dbt)
{
    if (!dbt.IsSetDb()) {
        return false;
    }
    const string& db = dbt.GetDb();
    if (NStr::EqualNocase(db, "TMSMART")
        || NStr::EqualNocase(db, "BankIt")
        || NStr::EqualNocase (db, "NCBIFILE")) {
        return true;
    } else {
        return false;
    }
}
 
static char CheckForBadSeqIdChars (const string& id)
 
{
    FOR_EACH_CHAR_IN_STRING(itr, id) {
        const char& ch = *itr;
        if (ch == '|' || ch == ',') return ch;
    }
    return '\0';
}
 
// VR-748
static char CheckForBadLocalIdChars(const string& id)
{
    for (size_t i = 0; i < id.length(); i++) {
        if (!CSeq_id::IsValidLocalID(id.substr(i, 1))) {
            return id.c_str()[i];
        }
    }
    return '\0';
}
 
 
static char CheckForBadFileIDSeqIdChars(const string& id)
{
    FOR_EACH_CHAR_IN_STRING(itr, id) {
        const char& ch = *itr;
        if (ch == '|' || ch == ',') return ch;
    }
    return '\0';
}
 
 
// validation for individual Seq-id
void CValidError_bioseq::ValidateSeqId(const CSeq_id& id, const CBioseq& ctx, bool longer_general)
{
    // see if ID can be used to find ctx
    CBioseq_Handle ctx_handle = m_Scope->GetBioseqHandle(ctx);
    if (!ctx_handle) {
        if (!m_Imp.IsPatent()) {
            PostErr(eDiag_Error, eErr_SEQ_INST_IdOnMultipleBioseqs,
                "BioseqFind (" + id.AsFastaString() +
                ") unable to find itself - possible internal error", ctx);
        }
        return;
    }
    CTSE_Handle tse = ctx_handle.GetTSE_Handle();
    CBioseq_Handle bsh = tse.GetBioseqHandle(id);
 
    if (bsh) {
        CConstRef<CBioseq> core = bsh.GetBioseqCore();
        if (!core) {
            if ( !m_Imp.IsPatent() ) {
                PostErr(eDiag_Error, eErr_SEQ_INST_IdOnMultipleBioseqs,
                    "BioseqFind (" + id.AsFastaString() +
                    ") unable to find itself - possible internal error", ctx);
            }
        } else if ( core.GetPointer() != &ctx ) {
            PostErr(eDiag_Error, eErr_SEQ_INST_IdOnMultipleBioseqs,
                "SeqID " + id.AsFastaString() +
                " is present on multiple Bioseqs in record", ctx);
        }
    } else {
        PostErr(eDiag_Error, eErr_SEQ_INST_IdOnMultipleBioseqs,
            "BioseqFind (" + id.AsFastaString() +
            ") unable to find itself - possible internal error", ctx);
    }
 
    //check formatting
    const CTextseq_id* tsid = id.GetTextseq_Id();
 
    switch (id.Which()) {
        case CSeq_id::e_Tpg:
        case CSeq_id::e_Tpe:
        case CSeq_id::e_Tpd:
            if ( IsHistAssemblyMissing(ctx)  &&  ctx.IsNa() ) {
                PostErr(eDiag_Info, eErr_SEQ_INST_HistAssemblyMissing,
                    "TPA record " + ctx.GetId().front()->AsFastaString() +
                    " should have Seq-hist.assembly for PRIMARY block",
                    ctx);
            }
        // Fall thru
        case CSeq_id::e_Genbank:
        case CSeq_id::e_Embl:
        case CSeq_id::e_Ddbj:
            if ( tsid  &&  tsid->IsSetAccession() ) {
                const string& acc = tsid->GetAccession();
                const char badch = CheckForBadSeqIdChars (acc);
                if (badch != '\0') {
                    PostErr(eDiag_Warning, eErr_SEQ_INST_BadSeqIdFormat,
                           "Bad character '" + string(1, badch) + "' in accession '" + acc + "'", ctx);
                }
                CSeq_id::EAccessionInfo info = CSeq_id::IdentifyAccession(acc);
                if (info == CSeq_id::eAcc_unknown ||
                    (ctx.IsNa() && (info & CSeq_id::fAcc_prot)) ||
                    (ctx.IsAa() && (info & CSeq_id::fAcc_nuc))) {
                    PostErr(eDiag_Error, eErr_SEQ_INST_BadSeqIdFormat,
                        "Bad accession " + acc, ctx);
                }
                // Check for secondary conflicts
                ValidateSecondaryAccConflict(acc, ctx, CSeqdesc::e_Genbank);
                ValidateSecondaryAccConflict(acc, ctx, CSeqdesc::e_Embl);
            }
        // Fall thru
        case CSeq_id::e_Other:
            if ( tsid ) {
                if ( tsid->IsSetName() ) {
                    const string& name = tsid->GetName();
                    ITERATE (string, s, name) {
                        if (isspace((unsigned char)(*s))) {
                            PostErr(eDiag_Critical,
                                eErr_SEQ_INST_SeqIdNameHasSpace,
                                "Seq-id.name '" + name + "' should be a single "
                                "word without any spaces", ctx);
                            break;
                        }
                    }
                }
 
                if ( tsid->IsSetAccession()  &&  id.IsOther() ) {
                    const string& acc = tsid->GetAccession();
                    const char badch = CheckForBadSeqIdChars (acc);
                    if (badch != '\0') {
                        PostErr(eDiag_Warning, eErr_SEQ_INST_BadSeqIdFormat,
                                "Bad character '" + string(1, badch) + "' in accession '" + acc + "'", ctx);
                    }
                    size_t num_letters = 0;
                    size_t num_digits = 0;
                    size_t num_underscores = 0;
                    bool bad_id_chars = false;
                    bool is_NZ = (NStr::CompareNocase(acc, 0, 3, "NZ_") == 0);
                    size_t i = 0;
                    bool letter_after_digit = false;
 
                    if ( is_NZ ) {
                        i = 3;
                    }
 
                    for ( ; i < acc.length(); ++i ) {
                        if ( isupper((unsigned char) acc[i]) ) {
                            num_letters++;
                        } else if ( isdigit((unsigned char) acc[i]) ) {
                            num_digits++;
                        } else if ( acc[i] == '_' ) {
                            num_underscores++;
                            if ( num_digits > 0  ||  num_underscores > 1 ) {
                                letter_after_digit = true;
                            }
                        } else {
                            bad_id_chars = true;
                        }
                    }
 
                    if ( letter_after_digit  ||  bad_id_chars ) {
                        PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                            "Bad accession " + acc, ctx);
                    } else if ( is_NZ  &&  ( num_letters == 4 || num_letters == 6 )  &&
                        ( num_digits >= 8 && num_digits <= 11 )  &&  num_underscores == 0 ) {
                        // valid accession - do nothing!
                    } else if ( is_NZ  &&  ValidateAccessionString (acc, false) == eAccessionFormat_valid ) {
                        // valid accession - do nothing!
                    } else if ( num_letters == 2  &&
                        (num_digits == 6  ||  num_digits == 8  || num_digits == 9)  &&
                        num_underscores == 1 ) {
                        // valid accession - do nothing!
                    } else if (num_letters == 4 && num_digits == 10 && ctx.IsNa()) {
                    } else {
                        PostErr(eDiag_Error, eErr_SEQ_INST_BadSeqIdFormat,
                            "Bad accession " + acc, ctx);
                    }
                }
            }
        // Fall thru
        case CSeq_id::e_Pir:
        case CSeq_id::e_Swissprot:
        case CSeq_id::e_Prf:
            if ( tsid ) {
                if ( ctx.IsNa()  &&
                     (!tsid->IsSetAccession() || tsid->GetAccession().empty())) {
                    if ( ctx.GetInst().GetRepr() != CSeq_inst::eRepr_seg  ||
                        m_Imp.IsGI()) {
                        if (!id.IsDdbj()  ||
                            ctx.GetInst().GetRepr() != CSeq_inst::eRepr_seg) {
                            string msg = "Missing accession for " + id.AsFastaString();
                            PostErr(eDiag_Error,
                                eErr_SEQ_INST_BadSeqIdFormat,
                                msg, ctx);
                        }
                    }
                }
            } else {
                PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                    "Seq-id type not handled", ctx);
            }
            break;
        case CSeq_id::e_Gi:
            if (id.GetGi() <= ZERO_GI) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_ZeroGiNumber,
                         "Invalid GI number", ctx);
            }
            break;
        case CSeq_id::e_General:
            if (!id.GetGeneral().IsSetDb() || NStr::IsBlank(id.GetGeneral().GetDb())) {
                PostErr(eDiag_Error, eErr_SEQ_INST_BadSeqIdFormat, "General identifier missing database field", ctx);
            }
            if (id.GetGeneral().IsSetDb()) {
                const CDbtag& dbt = id.GetGeneral();
                size_t dblen = dbt.GetDb().length();
                EDiagSev sev = eDiag_Error;
                if (m_Imp.IsLocalGeneralOnly()) {
                    sev = eDiag_Critical;
                } else if (m_Imp.IsRefSeq()) {
                    sev = eDiag_Error;
                } else if (m_Imp.IsINSDInSep()) {
                    sev = eDiag_Error;
                } else if (m_Imp.IsIndexerVersion()) {
                    sev = eDiag_Error;
                }
                static const auto max_dblen = CSeq_id::kMaxGeneralDBLength;
                if (dblen > max_dblen) {
                    PostErr(sev, eErr_SEQ_INST_BadSeqIdFormat, "General database longer than " + NStr::NumericToString(max_dblen) + " characters", ctx);
                }
                if (! s_IsSkippableDbtag(dbt)) {
                    if (dbt.IsSetTag() && dbt.GetTag().IsStr()) {
                        size_t idlen = dbt.GetTag().GetStr().length();
                        static const auto maxlen = CSeq_id::kMaxGeneralTagLength;
                        if (longer_general) {
                            if (idlen > 100 && ! m_Imp.IsGI()) {
                               PostErr(sev, eErr_SEQ_INST_BadSeqIdFormat, "General identifier longer than " + NStr::NumericToString(100) + " characters", ctx);
                            }
                        } else {
                            if (idlen > maxlen && ! m_Imp.IsGI()) {
                               PostErr(sev, eErr_SEQ_INST_BadSeqIdFormat, "General identifier longer than " + NStr::NumericToString(maxlen) + " characters", ctx);
                            }
                        }
                        if (idlen == 0) {
                            PostErr(eDiag_Error, eErr_SEQ_INST_BadSeqIdFormat, "General identifier must not be an empty string", ctx);
                        }
                    }
                }
                if (dbt.IsSetTag() && dbt.GetTag().IsStr()) {
                    const string& acc = dbt.GetTag().GetStr();
                    char badch;
                    if (dbt.IsSetDb() && (NStr::Equal(dbt.GetDb(), "NCBIFILE") || NStr::Equal(dbt.GetDb(), "BankIt"))) {
                        badch = CheckForBadFileIDSeqIdChars(acc);
                    } else {
                        badch = CheckForBadLocalIdChars(acc);
                        if (badch == '\0' && dbt.IsSetDb()) {
                            badch = CheckForBadLocalIdChars(dbt.GetDb());
                        }
                    }
                    if (badch != '\0') {
                        PostErr(eDiag_Warning, eErr_SEQ_INST_BadSeqIdFormat,
                                "Bad character '" + string(1, badch) + "' in sequence ID '" + id.AsFastaString() + "'", ctx);
                    }
                }
             }
           break;
        case CSeq_id::e_Local:
            if (id.IsLocal() && id.GetLocal().IsStr() && id.GetLocal().GetStr().length() > CSeq_id::kMaxLocalIDLength) {
                EDiagSev sev = eDiag_Error;
                if (! m_Imp.IsINSDInSep()) {
                    sev = eDiag_Critical;
                } else if (! m_Imp.IsIndexerVersion()) {
                    sev = eDiag_Error;
                }
                PostErr(sev, eErr_SEQ_INST_BadSeqIdFormat, "Local identifier longer than " + NStr::NumericToString(CSeq_id::kMaxLocalIDLength) + " characters", ctx);
            }
            if (id.IsLocal() && id.GetLocal().IsStr()) {
                const string& acc = id.GetLocal().GetStr();
                const char badch = CheckForBadLocalIdChars(acc);
                if (badch != '\0') {
                    PostErr(eDiag_Warning, eErr_SEQ_INST_BadSeqIdFormat,
                            "Bad character '" + string(1, badch) + "' in local ID '" + acc + "'", ctx);
                }
            }
            break;
        case CSeq_id::e_Pdb:
            if (id.IsPdb()) {
                const CPDB_seq_id& pdb = id.GetPdb();
                if (pdb.IsSetChain() && pdb.IsSetChain_id()) {
                    int chain = pdb.GetChain();
                    const string& chain_id = pdb.GetChain_id();
                    if (chain_id.size() == 1  &&  chain_id[0] == chain) {
                        break; // OK (straightforward match)
                    } else if (islower(chain)  &&  chain_id.size() == 2
                               &&  chain_id[0] == chain_id[1]
                               &&  chain_id[0] == toupper(chain)) {
                        break; // OK (historic special case)
                    } else if (chain == '|'  &&  chain_id == "VB") {
                        break; // OK (likewise)
                    } else {
                        PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                                "PDB Seq-id contains mismatched \'chain\' and"
                                " \'chain-id\' slots", ctx);
                    }
                }
            }
            break;
        default:
            break;
    }
 
#if 0
        // disabled for now
        if (!IsNCBIFILESeqId(**i)) {
            string label;
            (*i)->GetLabel(&label);
            if (label.length() > 40) {
                PostErr (eDiag_Warning, eErr_SEQ_INST_BadSeqIdFormat,
                         "Sequence ID is unusually long (" +
                         NStr::IntToString(label.length()) + "): " + label,
                         seq);
            }
        }
#endif
 
}
 
static bool x_IsWgsSecondary (const CBioseq& seq)
 
{
    FOR_EACH_DESCRIPTOR_ON_BIOSEQ (sd, seq) {
        const list< string > *extra_acc = nullptr;
        const CSeqdesc& desc = **sd;
        switch (desc.Which()) {
            case CSeqdesc::e_Genbank:
                if (desc.GetGenbank().IsSetExtra_accessions()) {
                    extra_acc = &(desc.GetGenbank().GetExtra_accessions());
                }
                break;
            case CSeqdesc::e_Embl:
                if (desc.GetEmbl().IsSetExtra_acc()) {
                    extra_acc = &(desc.GetEmbl().GetExtra_acc());
                }
                break;
            default:
                break;
        }
        if ( extra_acc ) {
            FOR_EACH_STRING_IN_LIST (acc, *extra_acc) {
                CSeq_id::EAccessionInfo info = CSeq_id::IdentifyAccession (*acc);
                if ((info & CSeq_id::eAcc_division_mask) == CSeq_id::eAcc_wgs
                     && (info & CSeq_id::fAcc_master) != 0) {
                    return true;
                }
            }
        }
    }
    return false;
}
 
// VR-728
// cannot have only seq-ids that will be stripped when loading to ID
void CValidError_bioseq::x_CheckGeneralIDs(const CBioseq& seq)
{
    bool found_good = false;
    ITERATE(CBioseq::TId, id_it, seq.GetId()) {
        if (!IsTemporary(**id_it)) {
            found_good = true;
        }
    }
    if (!found_good) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_NoIdOnBioseq,
            "The only ids on this Bioseq will be stripped during ID load", seq);
    }
}
 
 
void CValidError_bioseq::ValidateSeqIds
(const CBioseq& seq)
{
    // Ensure that CBioseq has at least one CSeq_id
    if ( !seq.IsSetId() || seq.GetId().empty() ) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_NoIdOnBioseq,
                 "No ids on a Bioseq", seq);
        return;
    }
 
    CSeq_inst::ERepr repr = seq.GetInst().GetRepr();
 
    // Loop thru CSeq_ids for this CBioseq. Determine if seq has
    // gi, NG, or NC. Check that the same CSeq_id not included more
    // than once.
    bool has_gi = false;
    bool is_lrg = false;
    bool has_ng = false;
    bool wgs_tech_needs_wgs_accession = false;
    bool is_segset_accession = false;
    bool has_wgs_general = false;
    bool is_eb_db = false;
    bool longer_general = false;
 
    FOR_EACH_SEQID_ON_BIOSEQ (i, seq) {
        if ((*i)->IsOther() || (*i)->IsEmbl() || (*i)->IsTpe()) {
            longer_general = true;
        }
    }
 
    FOR_EACH_SEQID_ON_BIOSEQ (i, seq) {
        // first, do standalone validation
        ValidateSeqId (**i, seq, longer_general);
 
        if ((*i)->IsGeneral() && (*i)->GetGeneral().IsSetDb()) {
            if (NStr::EqualNocase((*i)->GetGeneral().GetDb(), "LRG")) {
                is_lrg = true;
            }
            if (NStr::StartsWith((*i)->GetGeneral().GetDb(), "WGS:")) {
                has_wgs_general = true;
            }
        } else if ((*i)->IsOther() && (*i)->GetOther().IsSetAccession()) {
            const string& acc = (*i)->GetOther().GetAccession();
            if (NStr::StartsWith(acc, "NG_")) {
                has_ng = true;
                wgs_tech_needs_wgs_accession = true;
            } else if (NStr::StartsWith(acc, "NM_")
                        || NStr::StartsWith(acc, "NP_")
                        || NStr::StartsWith(acc, "NR_")) {
                wgs_tech_needs_wgs_accession = true;
            }
        } else if ((*i)->IsEmbl() && (*i)->GetEmbl().IsSetAccession()) {
            is_eb_db = true;
        } else if ((*i)->IsDdbj() && (*i)->GetDdbj().IsSetAccession()) {
            is_eb_db = true;
        }
 
        // Check that no two CSeq_ids for same CBioseq are same type
        CBioseq::TId::const_iterator j;
        for (j = i, ++j; j != seq.GetId().end(); ++j) {
            if ((**i).Compare(**j) != CSeq_id::e_DIFF) {
                CNcbiOstrstream os;
                os << "Conflicting ids on a Bioseq: (";
                (**i).WriteAsFasta(os);
                os << " - ";
                (**j).WriteAsFasta(os);
                os << ")";
                PostErr(eDiag_Error, eErr_SEQ_INST_ConflictingIdsOnBioseq,
                    CNcbiOstrstreamToString (os) /* os.str() */, seq);
            }
        }
 
        if ( (*i)->IsGenbank()  ||  (*i)->IsEmbl()  ||  (*i)->IsDdbj() ) {
            wgs_tech_needs_wgs_accession = true;
        }
 
        if ( (*i)->IsGi() ) {
            has_gi = true;
        }
 
        if ( (*i)->IdentifyAccession() == CSeq_id::eAcc_segset) {
            is_segset_accession = true;
        }
 
    }
    if (is_lrg && !has_ng) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_ConflictingIdsOnBioseq,
            "LRG sequence needs NG_ accession", seq);
    }
 
 
    // Loop thru CSeq_ids to check formatting
    bool is_wgs = false;
    unsigned int gi_count = 0;
    unsigned int accn_count = 0;
    unsigned int lcl_count = 0;
    FOR_EACH_SEQID_ON_BIOSEQ (k, seq) {
        const CTextseq_id* tsid = (*k)->GetTextseq_Id();
        switch ((**k).Which()) {
        case CSeq_id::e_Local:
            lcl_count++;
            break;
        case CSeq_id::e_Tpg:
        case CSeq_id::e_Tpe:
        case CSeq_id::e_Tpd:
        case CSeq_id::e_Genbank:
        case CSeq_id::e_Embl:
        case CSeq_id::e_Ddbj:
            if ( tsid  &&  tsid->IsSetAccession() ) {
                if ((*k)->IsGenbank() || (*k)->IsEmbl() || (*k)->IsDdbj()) {
                    is_wgs |= IsWGSAccession(**k);
                }
 
                if ( has_gi ) {
                    if (tsid->IsSetVersion() && tsid->GetVersion() == 0) {
                        const string& acc = tsid->GetAccession();
                        PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                            "Accession " + acc + " has 0 version", seq);
                    }
                }
            }
        // Fall thru
        case CSeq_id::e_Other:
            if ( tsid ) {
 
                if ( has_gi && !tsid->IsSetAccession() && tsid->IsSetName() ) {
                    if ( (*k)->IsDdbj()  &&  repr == CSeq_inst::eRepr_seg ) {
                        // Don't report ddbj segmented sequence missing accessions
                    } else {
                        PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                            "Missing accession for " + tsid->GetName(), seq);
                    }
                }
                accn_count++;
            }
            break;
            // Fall thru
        case CSeq_id::e_Pir:
        case CSeq_id::e_Swissprot:
        case CSeq_id::e_Prf:
            if ( tsid) {
                if ((!tsid->IsSetAccession() || NStr::IsBlank(tsid->GetAccession())) &&
                    (!tsid->IsSetName() || NStr::IsBlank(tsid->GetName())) &&
                    seq.GetInst().IsAa()) {
                    string label = (*k)->AsFastaString();
                    PostErr(eDiag_Critical, eErr_SEQ_INST_BadSeqIdFormat,
                            "Missing identifier for " + label, seq);
                }
                accn_count++;
            }
            break;
        case CSeq_id::e_Gi:
            gi_count++;
            break;
        default:
            break;
        }
    }
 
    CTypeConstIterator<CMolInfo> mi(ConstBegin(seq));
    if (!SeqIsPatent(seq) && !seq.IsAa()) {
        if ( is_wgs ) {
            if ( !mi  ||  !mi->IsSetTech()  ||
                ( mi->GetTech() != CMolInfo::eTech_wgs  &&
                  mi->GetTech() != CMolInfo::eTech_tsa &&
                  mi->GetTech() != CMolInfo::eTech_targeted) ) {
                PostErr(eDiag_Error, eErr_SEQ_DESCR_InconsistentMolInfoTechnique,
                    "WGS accession should have Mol-info.tech of wgs", seq);
            }
        } else if ( mi  &&  mi->IsSetTech()  &&
                    mi->GetTech() == CMolInfo::eTech_wgs  &&
                    wgs_tech_needs_wgs_accession &&
                    !is_segset_accession &&
                    !has_wgs_general &&
                    !x_IsWgsSecondary(seq)) {
            EDiagSev sev = eDiag_Error;
            if (is_eb_db) {
                sev = eDiag_Warning;
            }
            if (! is_eb_db) {
                PostErr(sev, eErr_SEQ_DESCR_InconsistentWGSFlags,
                    "Mol-info.tech of wgs should have WGS accession", seq);
            }
        }
 
        if ((IsNTNCNWACAccession(seq) || IsNG(seq)) && mi && seq.IsNa()
                && (!mi->IsSetBiomol()
                || (mi->GetBiomol() != CMolInfo::eBiomol_genomic
                    && mi->GetBiomol() != CMolInfo::eBiomol_cRNA))) {
            PostErr(eDiag_Error, eErr_SEQ_DESCR_InconsistentRefSeqMoltype,
                     "genomic RefSeq accession should use genomic or cRNA moltype",
                     seq);
        }
    }
    if (seq.GetInst().GetMol() == CSeq_inst::eMol_dna) {
        if (mi && mi->IsSetBiomol()) {
            switch (mi->GetBiomol()) {
                case CMolInfo::eBiomol_pre_RNA:
                case CMolInfo::eBiomol_mRNA:
                case CMolInfo::eBiomol_rRNA:
                case CMolInfo::eBiomol_tRNA:
                case CMolInfo::eBiomol_snRNA:
                case CMolInfo::eBiomol_scRNA:
                case CMolInfo::eBiomol_cRNA:
                case CMolInfo::eBiomol_snoRNA:
                case CMolInfo::eBiomol_transcribed_RNA:
                case CMolInfo::eBiomol_ncRNA:
                case CMolInfo::eBiomol_tmRNA:
                    PostErr(eDiag_Error, eErr_SEQ_DESCR_InconsistentMolType,
                            "Molecule type (DNA) does not match biomol (RNA)", seq);
                    break;
                default:
                    break;
            }
        }
    }
 
    // Check that a sequence with a gi number has exactly one accession
    if ( gi_count > 0  &&  accn_count == 0  &&  !m_Imp.IsPDB()  &&
         repr != CSeq_inst::eRepr_virtual ) {
        PostErr(eDiag_Error, eErr_SEQ_INST_GiWithoutAccession,
            "No accession on sequence with gi number", seq);
    }
    if (gi_count > 0  &&  accn_count > 1) {
        PostErr(eDiag_Error, eErr_SEQ_INST_MultipleAccessions,
            "Multiple accessions on sequence with gi number", seq);
    }
 
    x_CheckGeneralIDs(seq);
 
    if ( m_Imp.IsValidateIdSet() ) {
        ValidateIDSetAgainstDb(seq);
    }
 
    // C toolkit ensures that there is exactly one CBioseq for a CSeq_id
    // Not done here because object manager will not allow
    // the same Seq-id on multiple Bioseqs
 
}
 
 
bool CValidError_bioseq::IsHistAssemblyMissing(const CBioseq& seq)
{
    bool rval = false;
    const CSeq_inst& inst = seq.GetInst();
    if (inst.IsSetHist() && inst.GetHist().IsSetAssembly()) {
        return false;
    }
    CSeq_inst::TRepr repr = inst.CanGetRepr() ?
        inst.GetRepr() : CSeq_inst::eRepr_not_set;
 
    if ( seq.IsNa()  &&  repr != CSeq_inst::eRepr_seg ) {
        rval = true;
        // look for keyword
        CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
        CSeqdesc_CI genbank_i(bsh, CSeqdesc::e_Genbank);
        if (genbank_i && genbank_i->GetGenbank().IsSetKeywords()) {
            CGB_block::TKeywords::const_iterator keyword = genbank_i->GetGenbank().GetKeywords().begin();
            while (keyword != genbank_i->GetGenbank().GetKeywords().end() && rval) {
                if (NStr::EqualNocase(*keyword, "TPA:reassembly")) {
                    rval = false;
                }
                ++keyword;
            }
        }
        if (rval) {
            CSeqdesc_CI embl_i(bsh, CSeqdesc::e_Embl);
            if (embl_i && embl_i->GetEmbl().IsSetKeywords()) {
                CEMBL_block::TKeywords::const_iterator keyword = embl_i->GetEmbl().GetKeywords().begin();
                while (keyword != embl_i->GetEmbl().GetKeywords().end() && rval) {
                    if (NStr::EqualNocase(*keyword, "TPA:reassembly")) {
                        rval = false;
                    }
                    ++keyword;
                }
            }
        }
    }
    return rval;
}
 
 
void CValidError_bioseq::ValidateSecondaryAccConflict
(const string &primary_acc,
 const CBioseq &seq,
 int choice)
{
    CSeqdesc_CI sd(m_Scope->GetBioseqHandle(seq), static_cast<CSeqdesc::E_Choice>(choice));
    for (; sd; ++sd) {
        const list< string > *extra_acc = nullptr;
        if ( choice == CSeqdesc::e_Genbank  &&
            sd->GetGenbank().IsSetExtra_accessions() ) {
            extra_acc = &(sd->GetGenbank().GetExtra_accessions());
        } else if ( choice == CSeqdesc::e_Embl  &&
            sd->GetEmbl().IsSetExtra_acc() ) {
            extra_acc = &(sd->GetEmbl().GetExtra_acc());
        }
 
        if ( extra_acc ) {
            FOR_EACH_STRING_IN_LIST (acc, *extra_acc) {
                if ( NStr::CompareNocase(primary_acc, *acc) == 0 ) {
                    // If the same post error
                    PostErr(eDiag_Error,
                        eErr_SEQ_INST_BadSecondaryAccn,
                        primary_acc + " used for both primary and"
                        " secondary accession", seq);
                }
            }
        }
    }
}
 
 
bool HasUnverified(CBioseq_Handle bsh)
{
    for (CSeqdesc_CI it(bsh, CSeqdesc::e_User); it; ++it) {
        if (it->GetUser().GetObjectType() == CUser_object::eObjectType_Unverified) {
            return true;
        }
    }
    return false;
}
 
 
void CValidError_bioseq::x_ValidateBarcode(const CBioseq& seq)
{
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle (seq);
    CSeq_entry_Handle seh = bsh.GetSeq_entry_Handle();
    CConstRef<CSeq_entry> ctx = seh.GetCompleteSeq_entry();
 
    bool has_barcode_tech = false;
 
    CSeqdesc_CI di(bsh, CSeqdesc::e_Molinfo);
    if (di && di->GetMolinfo().IsSetTech() && di->GetMolinfo().GetTech() == CMolInfo::eTech_barcode) {
        has_barcode_tech = true;
    }
 
    bool has_barcode_keyword = false;
    for (CSeqdesc_CI it(bsh, CSeqdesc::e_Genbank); it; ++it) {
        FOR_EACH_KEYWORD_ON_GENBANKBLOCK (k, it->GetGenbank()) {
            if (NStr::EqualNocase (*k, "BARCODE")) {
                has_barcode_keyword = true;
                break;
            }
        }
        if (has_barcode_keyword && !has_barcode_tech) {
            PostErr (eDiag_Warning, eErr_SEQ_DESCR_BadKeywordNoTechnique,
                     "BARCODE keyword without Molinfo.tech barcode",
                     *ctx, *it);
        }
    }
    if (has_barcode_tech && !has_barcode_keyword && di) {
        PostErr (eDiag_Info, eErr_SEQ_DESCR_NoKeywordHasTechnique,
                 "Molinfo.tech barcode without BARCODE keyword",
                 *ctx, *di);
    }
    if (has_barcode_keyword && HasUnverified(bsh)) {
        PostErr(eDiag_Warning, eErr_SEQ_DESCR_BadKeywordUnverified,
            "Sequence has both BARCODE and UNVERIFIED keywords",
            seq);
    }
}
 
 
void CValidError_bioseq::ValidateInst(
    const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
 
 
    // Check representation
    if ( !ValidateRepr(inst, seq) ) {
        return;
    }
 
    // Check molecule, topology, and strand
    if (!inst.IsSetMol()) {
        PostErr(eDiag_Error, eErr_SEQ_INST_MolNotSet, "Bioseq.mol is 0",
            seq);
    } else {
        const CSeq_inst::EMol& mol = inst.GetMol();
        switch (mol) {
 
            case CSeq_inst::eMol_na:
                PostErr(eDiag_Error, eErr_SEQ_INST_MolNuclAcid,
                         "Bioseq.mol is type nucleic acid", seq);
                break;
 
            case CSeq_inst::eMol_aa:
                if ( inst.IsSetTopology()  &&
                     inst.GetTopology() != CSeq_inst::eTopology_not_set  &&
                     inst.GetTopology() != CSeq_inst::eTopology_linear ) {
                    PostErr(eDiag_Error, eErr_SEQ_INST_CircularProtein,
                             "Non-linear topology set on protein", seq);
                }
                if ( inst.IsSetStrand()  &&
                     inst.GetStrand() != CSeq_inst::eStrand_ss &&
                     inst.GetStrand() != CSeq_inst::eStrand_not_set) {
                    PostErr(eDiag_Error, eErr_SEQ_INST_BadProteinMoltype,
                             "Protein not single stranded", seq);
                }
                break;
 
            case CSeq_inst::eMol_dna:
                if (seq.IsSetInst() && seq.GetInst().IsSetTopology() && seq.GetInst().GetTopology() == CSeq_inst::eTopology_circular) {
                    if (m_is_bact_or_arch) {
                        if (! m_is_plasmid && ! m_is_chromosome  && ! m_is_extrachrom) {
                            EDiagSev sev = eDiag_Error;
                            if (IsRefSeq(seq) || m_Imp.IsRefSeqConventions()) {
                                sev = eDiag_Error;
                            } else if (IsEmblOrDdbj(seq)) {
                                sev = eDiag_Warning;
                            }
                            PostErr(sev, eErr_SEQ_INST_CircBactGenomeProblem,
                                     "Circular Bacteria or Archaea should be chromosome, or plasmid, or extrachromosomal", seq);
                        }
                    }
                }
                break;
 
            case CSeq_inst::eMol_not_set:
                PostErr(eDiag_Error, eErr_SEQ_INST_MolNotSet, "Bioseq.mol is 0",
                    seq);
                break;
 
            case CSeq_inst::eMol_other:
                PostErr(eDiag_Error, eErr_SEQ_INST_MolinfoOther,
                         "Bioseq.mol is type other", seq);
                break;
 
            default:
                break;
        }
    }
 
    CSeq_inst::ERepr rp = seq.GetInst().GetRepr();
 
    if (rp == CSeq_inst::eRepr_raw  ||  rp == CSeq_inst::eRepr_const) {
        // Validate raw and constructed sequences
        ValidateRawConst(seq);
    }
 
    // per VR-779
#if 1
    if (rp == CSeq_inst::eRepr_seg) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_ReprInvalid, "Segmented set format is not supported", seq);
    } else if (rp == CSeq_inst::eRepr_ref) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_ReprInvalid, "Repr_ref format is not supported", seq);
    }
#else
    if (rp == CSeq_inst::eRepr_seg  ||  rp == CSeq_inst::eRepr_ref) {
        // Validate segmented and reference sequences
        ValidateSegRef(seq);
    }
#endif
 
    if (rp == CSeq_inst::eRepr_delta) {
        // Validate delta sequences
        ValidateDelta(seq);
    }
 
    if (rp == CSeq_inst::eRepr_seg  &&  seq.GetInst().IsSetExt()  &&
        seq.GetInst().GetExt().IsSeg()) {
        // Validate part of segmented sequence
        ValidateSeqParts(seq);
    }
 
    if (rp == CSeq_inst::eRepr_raw || rp == CSeq_inst::eRepr_delta) {
        x_ValidateBarcode (seq);
    }
 
    x_ValidateTitle(seq);
    /*if ( seq.IsAa() ) {
         Validate protein title (amino acids only)
        ValidateProteinTitle(seq);
    }*/
 
    if ( seq.IsNa() ) {
        // check for N bases at start or stop of sequence,
        // or sequence entirely made of Ns
        ValidateNsAndGaps(seq);
 
        GapByGapInst(seq);
    }
 
    // Validate sequence length
    ValidateSeqLen(seq);
 
    // proteins should not have gaps
    if (seq.IsAa() && x_HasGap(seq)) {
        PostErr(eDiag_Error, eErr_SEQ_INST_ProteinShouldNotHaveGaps, "Protein sequences should not have gaps", seq);
    }
}
 
 
bool CValidError_bioseq::x_ShowBioProjectWarning(const CBioseq& seq)
 
{
    bool is_wgs = false;
    bool is_grc = false;
 
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    CSeqdesc_CI user(bsh, CSeqdesc::e_User);
    while (user) {
        if (user->GetUser().GetObjectType() == CUser_object::eObjectType_DBLink &&
            user->GetUser().HasField("BioProject", ".", NStr::eNocase)) {
            // bioproject field found
            return false;
        }
        ++user;
    }
 
    CSeqdesc_CI ti(bsh, CSeqdesc::e_Title);
    if (ti) {
        while (ti) {
            if (NStr::StartsWith(ti->GetTitle(), "GRC")) {
                is_grc = true;
                break;
            }
            ++ti;
        }
    } else {
        sequence::CDeflineGenerator defline_generator;
        string title = defline_generator.GenerateDefline(seq, *m_Scope, sequence::CDeflineGenerator::fIgnoreExisting);
        if (!NStr::IsBlank(title)) {
            if (NStr::StartsWith(title, "GRC")) {
                is_grc = true;
            }
        }
    }
 
    is_wgs = IsWGS(bsh);
 
    bool is_gb = false, /* is_eb_db = false, */ is_refseq = false, is_ng = false;
 
    FOR_EACH_SEQID_ON_BIOSEQ (sid_itr, seq) {
        const CSeq_id& sid = **sid_itr;
        switch (sid.Which()) {
            case CSeq_id::e_Genbank:
            case CSeq_id::e_Embl:
                // is_eb_db = true;
                // fall through
            case CSeq_id::e_Ddbj:
                is_gb = true;
                break;
            case CSeq_id::e_Other:
                {
                    is_refseq = true;
                    if (sid.GetOther().IsSetAccession()) {
                        string acc = sid.GetOther().GetAccession().substr(0, 3);
                        if (acc == "NG_") {
                            is_ng = true;
                        }
                    }
                }
                break;
            default:
                break;
        }
    }
 
    if (is_refseq || m_Imp.IsRefSeqConventions()) {
        if (is_ng) return false;
    } else if (is_gb) {
        if (! is_wgs && ! is_grc) return false;
    } else {
        return false;
    }
 
    const CSeq_inst & inst = seq.GetInst();
    CSeq_inst::TRepr repr = inst.GetRepr();
 
    if (repr == CSeq_inst::eRepr_delta) {
        if (x_IsDeltaLitOnly(inst)) return false;
    } else if (repr != CSeq_inst::eRepr_map) {
        return false;
    }
 
    return true;
}
 
void CValidError_bioseq::ValidateBioseqContext(
    const CBioseq& seq)
{
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
 
    // Check that proteins in nuc_prot set have a CdRegion
    if ( CdError(bsh) ) {
        EDiagSev sev = eDiag_Error;
        CBioseq_set_Handle bssh = GetNucProtSetParent (bsh);
        if (bssh) {
            CBioseq_Handle nbsh = GetNucBioseq (bssh);
            if (nbsh) {
                CSeqdesc_CI desc( nbsh, CSeqdesc::e_Molinfo );
                const CMolInfo* mi = desc ? &(desc->GetMolinfo()) : nullptr;
                if (mi) {
                    CMolInfo::TTech tech = mi->IsSetTech() ?
                        mi->GetTech() : CMolInfo::eTech_unknown;
                    if (tech == CMolInfo::eTech_wgs) {
                        sev = eDiag_Critical;
                    }
                }
            }
        }
        PostErr(sev, eErr_SEQ_PKG_NoCdRegionPtr,
            "No CdRegion in nuc-prot set points to this protein",
            seq);
    }
 
    bool is_patent = SeqIsPatent (seq);
 
    bool is_complete = false;
    CSeqdesc_CI desc(bsh, CSeqdesc::e_Molinfo);
    if (desc) {
        const CMolInfo& mi = desc->GetMolinfo();
        if (mi.GetCompleteness() == CMolInfo::eCompleteness_complete) {
            is_complete = true;
        }
    }
 
    try {
 
        // if there are no Seq-ids, the following tests can't be run
        if (seq.IsSetId()) {
 
            ValidateSeqFeatContext(seq, is_complete);
 
            // Check for duplicate features and overlapping peptide features.
            ValidateDupOrOverlapFeats(seq);
 
            // Check for introns within introns.
            ValidateTwintrons(seq);
 
            // check for tRNA contained in tmRNA features
            x_ValidateOverlappingRNAFeatures (bsh);
 
            // check for equivalent source features
            x_ValidateSourceFeatures (bsh);
 
            // check for equivalen pub features
            x_ValidatePubFeatures (bsh);
 
            // Check for colliding genes
            ValidateCollidingGenes(seq);
 
            // Detect absence of BioProject DBLink for complete bacterial genomes
            ValidateCompleteGenome(seq);
        }
 
        m_dblink_count = 0;
        m_taa_count = 0;
        m_bs_count = 0;
        m_as_count = 0;
        m_pdb_count = 0;
        m_sra_count = 0;
        m_bp_count = 0;
        m_unknown_count = 0;
 
        // Validate descriptors that affect this bioseq
        ValidateSeqDescContext(seq);
 
 
        if (m_dblink_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_MultipleDBLinkObjects,
                NStr::IntToString(m_dblink_count) + " DBLink user objects apply to a Bioseq", seq);
        }
 
        if (m_taa_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkProblem,
                "Trace Assembly Archive entries appear in " + NStr::IntToString(m_taa_count) + " DBLink user objects", seq);
        }
 
        if (m_bs_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkProblem,
                "BioSample entries appear in " + NStr::IntToString(m_bs_count) + " DBLink user objects", seq);
        }
 
        if (m_as_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkBadAssembly,
                "Assembly entries appear in " + NStr::IntToString(m_as_count) + " DBLink user objects", seq);
        }
 
        if (m_pdb_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkProblem,
                "ProbeDB entries appear in " + NStr::IntToString(m_pdb_count) + " DBLink user objects", seq);
        }
 
        if (m_sra_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkProblem,
                "Sequence Read Archive entries appear in " + NStr::IntToString(m_sra_count) + " DBLink user objects", seq);
        }
 
        if (m_bp_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkProblem,
                "BioProject entries appear in " + NStr::IntToString(m_bp_count) + " DBLink user objects", seq);
        }
 
        if (m_unknown_count > 1) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkBadFormat,
                "Unrecognized entries appear in " + NStr::IntToString(m_unknown_count) + " DBLink user objects", seq);
        } else if (m_unknown_count > 0) {
            PostErr(eDiag_Critical, eErr_SEQ_DESCR_DBLinkBadFormat,
                "Unrecognized entries appear in " + NStr::IntToString(m_unknown_count) + " DBLink user object", seq);
        }
 
        // make sure that there is a pub on this bioseq
        if (m_Imp.GetContext().PostprocessHugeFile || !m_Imp.IsNoPubs() ) {
            CheckForPubOnBioseq(seq);
        }
        // make sure that there is a source on this bioseq
        if (m_Imp.GetContext().PostprocessHugeFile || !m_Imp.IsNoBioSource() ) {
            CheckSourceDescriptor(bsh);
            //CheckForBiosourceOnBioseq(seq);
        }
 
        if (x_ShowBioProjectWarning (seq)) {
            PostErr(eDiag_Warning, eErr_SEQ_DESCR_ScaffoldLacksBioProject,
                "BioProject entries not present on CON record", seq);
        }
 
    } catch ( const exception& e ) {
        if (NStr::Find(e.what(), "Error: Cannot resolve") == string::npos) {
            PostErr(eDiag_Error, eErr_INTERNAL_Exception,
                string("Exception while validating BioseqContext. EXCEPTION: ") +
                e.what(), seq);
        }
    }
 
    if (!is_patent) {
        // flag missing molinfo even if not in Sequin
        CheckForMolinfoOnBioseq(seq);
    }
 
    CValidError_graph graph_validator(m_Imp);
    graph_validator.ValidateGraphsOnBioseq(seq);
 
    CheckTpaHistory(seq);
 
    // check for multiple publications with identical identifiers
    x_ValidateMultiplePubs(bsh);
 
    // look for orphaned proteins
    if (seq.IsAa() && bsh && !GetNucProtSetParent(bsh) && !AllowOrphanedProtein(seq, m_Imp.IsRefSeqConventions())) {
        PostErr(eDiag_Error, eErr_SEQ_PKG_OrphanedProtein,
                "Orphaned stand-alone protein", seq);
    }
 
    // look for extra protein features
    if (seq.IsAa()) {
        CCacheImpl::SFeatKey prot_key(
            CCacheImpl::kAnyFeatType, CSeqFeatData::eSubtype_prot, bsh);
        const CCacheImpl::TFeatValue & prot_feats =
            GetCache().GetFeatFromCache(prot_key);
 
        if (prot_feats.size() > 1) {
            ITERATE(CCacheImpl::TFeatValue, feat, prot_feats) {
                PostErr(eDiag_Error, eErr_SEQ_FEAT_ExtraProteinFeature,
                        "Protein sequence has multiple unprocessed protein features",
                        feat->GetOriginalFeature());
            }
        }
    }
 
    if (!m_Imp.IsNoCitSubPubs() && !x_HasCitSub(bsh) && !m_Imp.IsSeqSubmitParent()) {
        PostErr(m_Imp.IsGenomeSubmission() ? eDiag_Error : eDiag_Info, eErr_GENERIC_MissingPubRequirement,
                "Expected submission citation is missing for this Bioseq", seq);
    }
 
    //  RW-1053 check sig_peptides and mat_peptides with instantiated products
    if (seq.IsAa()) {
 
        SAnnotSelector sel(CSeqFeatData::eSubtype_mat_peptide_aa);
        sel.IncludeFeatSubtype(CSeqFeatData::eSubtype_sig_peptide_aa);
        sel.IncludeFeatSubtype(CSeqFeatData::eSubtype_transit_peptide_aa);
        try {
            for (CFeat_CI feat_ci(bsh, sel); feat_ci;  ++feat_ci) {
 
                const CSeq_feat& matpeptide = feat_ci->GetOriginalFeature();
                if (matpeptide.IsSetProduct()) {
                    const CSeq_loc& loc = matpeptide.GetLocation();
                    const CSeq_loc& prd = matpeptide.GetProduct();
 
                    int matlen = GetLength(loc, m_Scope);
                    int prdlen = GetLength(prd, m_Scope);
                    if (matlen != prdlen) {
                        PostErr(eDiag_Error, eErr_SEQ_FEAT_MisMatchAA,
                                "Mat_peptide does not match length of instantiated product",
                                matpeptide);
                     }
 
                    CSeqVector mat_vec(loc, *m_Scope, CBioseq_Handle::eCoding_Iupac);
                    CSeqVector prd_vec(prd, *m_Scope, CBioseq_Handle::eCoding_Iupac);
 
                    int len = matlen;
                    if (len > prdlen) {
                        len = prdlen;
                    }
 
                    for (TSeqPos i = 0; i < len; ++i) {
                        CSeqVectorTypes::TResidue m_res = mat_vec[i];
                        CSeqVectorTypes::TResidue p_res = prd_vec[i];
 
                        if (m_res != p_res) {
                            PostErr(eDiag_Error, eErr_SEQ_FEAT_MisMatchAA,
                                    "Mismatch in mat_peptide (" + string(1, (char)m_res) + ") and instantiated product (" + \
                                     string(1, (char)p_res) + ") at position " + NStr::NumericToString(i + 1),
                                    matpeptide);
                       }
                    }
                }
            }
 
        }
        catch (CException&) {
        }
    }
}
 
 
bool CValidError_bioseq::x_HasCitSub(const CPub_equiv& pub)
{
    ITERATE(CPub_equiv::Tdata, it, pub.Get()) {
        if (x_HasCitSub(**it)) {
            return true;
        }
    }
    return false;
}
 
 
bool CValidError_bioseq::x_HasCitSub(const CPub& pub)
{
    if (pub.IsSub()) {
        return true;
    } else if (pub.IsEquiv() && x_HasCitSub(pub.GetEquiv())) {
        return true;
    } else {
        return false;
    }
}
 
 
bool CValidError_bioseq::x_HasCitSub(CBioseq_Handle bsh) const
{
    bool has_cit_sub = false;
    CSeqdesc_CI p(bsh, CSeqdesc::e_Pub);
    while (p && !has_cit_sub) {
        if (p->GetPub().IsSetPub()) {
            has_cit_sub = x_HasCitSub(p->GetPub().GetPub());
        }
        ++p;
    }
 
    return has_cit_sub;
}
 
 
template <class Iterator, class Predicate>
bool lists_match(Iterator iter1, Iterator iter1_stop, Iterator iter2, Iterator iter2_stop, Predicate pred)
{
    while (iter1 != iter1_stop && iter2 != iter2_stop) {
        if (!pred(*iter1, *iter2)) {
            return false;
        }
        ++iter1;
        ++iter2;
    }
    if (iter1 != iter1_stop || iter2 != iter2_stop) {
        return false;
    } else {
        return true;
    }
}
 
 
static bool s_OrgModEqual (
    const CRef<COrgMod>& om1,
    const CRef<COrgMod>& om2
)
 
{
    const COrgMod& omd1 = *(om1);
    const COrgMod& omd2 = *(om2);
 
    const string& str1 = omd1.GetSubname();
    const string& str2 = omd2.GetSubname();
 
    if (NStr::CompareNocase (str1, str2) != 0) return false;
 
    TORGMOD_SUBTYPE chs1 = omd1.GetSubtype();
    TORGMOD_SUBTYPE chs2 = omd2.GetSubtype();
 
    if (chs1 == chs2) return true;
    if (chs2 == NCBI_ORGMOD(other)) return true;
 
    return false;
}
 
 
bool s_DbtagEqual (const CRef<CDbtag>& dbt1, const CRef<CDbtag>& dbt2)
{
    // is dbt1 == dbt2
    return dbt1->Compare(*dbt2) == 0;
}
 
 
// Two OrgRefs are identical if the taxnames are identical, the dbxrefs are identical,
// and the orgname orgmod lists are identical
static bool s_OrgrefEquivalent (const COrg_ref& org1, const COrg_ref& org2)
{
    if ((org1.IsSetTaxname() && !org2.IsSetTaxname())
        || (!org1.IsSetTaxname() && org2.IsSetTaxname())
        || (org1.IsSetTaxname() && org2.IsSetTaxname()
            && !NStr::EqualNocase (org1.GetTaxname(), org2.GetTaxname()))) {
        return false;
    }
 
    if ((org1.IsSetDb() && !org2.IsSetDb())
        || (!org1.IsSetDb() && org2.IsSetDb())
        || (org1.IsSetDb() && org2.IsSetDb()
            && !lists_match (org1.GetDb().begin(), org1.GetDb().end(),
                             org2.GetDb().begin(), org2.GetDb().end(),
                             s_DbtagEqual))) {
        return false;
    }
 
    if ((org1.IsSetOrgname() && !org2.IsSetOrgname())
        || (!org1.IsSetOrgname() && org2.IsSetOrgname())) {
        return false;
    }
    if (org1.IsSetOrgname() && org2.IsSetOrgname()) {
        const COrgName& on1 = org1.GetOrgname();
        const COrgName& on2 = org2.GetOrgname();
        if ((on1.IsSetMod() && !on2.IsSetMod())
            || (!on1.IsSetMod() && on2.IsSetMod())
            || (on1.IsSetMod() && on2.IsSetMod()
                && !lists_match (on1.GetMod().begin(), on1.GetMod().end(),
                                 on2.GetMod().begin(), on2.GetMod().end(),
                                 s_OrgModEqual))) {
            return false;
        }
    }
 
    return true;
}
 
 
// Two SubSources are equal and duplicates if:
// they have the same subtype
// and the same name (or don't require a name).
 
static bool s_SubsourceEquivalent (
    const CRef<CSubSource>& st1,
    const CRef<CSubSource>& st2
)
 
{
    const CSubSource& sbs1 = *(st1);
    const CSubSource& sbs2 = *(st2);
 
    TSUBSOURCE_SUBTYPE chs1 = sbs1.GetSubtype();
    TSUBSOURCE_SUBTYPE chs2 = sbs2.GetSubtype();
 
    if (chs1 != chs2) return false;
    if (CSubSource::NeedsNoText(chs2)) return true;
 
    if (sbs1.IsSetName() && sbs2.IsSetName()) {
        if (NStr::CompareNocase (sbs1.GetName(), sbs2.GetName()) == 0) return true;
    }
    if (! sbs1.IsSetName() && ! sbs2.IsSetName()) return true;
 
    return false;
}
 
 
static bool s_BiosrcFullLengthIsOk (const CBioSource& src)
{
    if (src.IsSetIs_focus()) {
        return true;
    }
    FOR_EACH_SUBSOURCE_ON_BIOSOURCE (it, src) {
        if ((*it)->IsSetSubtype() && (*it)->GetSubtype() == CSubSource::eSubtype_transgenic) {
            return true;
        }
    }
    return false;
}
 
 
static bool s_SuppressMultipleEquivBioSources (const CBioSource& src)
{
    if (!src.IsSetOrg() || !src.GetOrg().IsSetTaxname()) {
        return false;
    }
    if (NStr::EqualNocase(src.GetOrg().GetTaxname(), "unidentified phage")) {
        return true;
    }
    if (src.GetOrg().IsSetOrgname() && src.GetOrg().GetOrgname().IsSetLineage()
        && NStr::StartsWith(src.GetOrg().GetOrgname().GetLineage(), "Viruses", NStr::eNocase)) {
        return true;
    }
#if 0
    if (!src.GetOrg().IsSetOrgname()) {
      printf ("Orgname not set!\n");
    } else if (!src.GetOrg().GetOrgname().IsSetLineage()) {
      printf ("Lineage not set!\n");
    } else {
      printf ("Lineage is %s!\n", src.GetOrg().GetOrgname().GetLineage().c_str());
    }
#endif
    return false;
}
 
 
bool s_OverlapOrAbut(const CSeq_loc& loc1, const CSeq_loc& loc2, CScope* scope)
{
    TSeqPos start1 = loc1.GetStart(eExtreme_Positional);
    TSeqPos stop1 = loc1.GetStop(eExtreme_Positional);
    TSeqPos start2 = loc2.GetStart(eExtreme_Positional);
    TSeqPos stop2 = loc2.GetStop(eExtreme_Positional);
 
    if (start1 == stop2 + 1 || start2 == stop1 + 1) {
        // abut
        return true;
    } else if (TestForOverlapEx(loc1, loc2, eOverlap_Simple, scope) >= 0) {
        return true;
    } else {
        return false;
    }
}
 
 
bool s_ContainedIn(const CSeq_loc& loc1, const CSeq_loc& loc2, CScope* scope)
{
    TSeqPos start1 = loc1.GetStart(eExtreme_Positional);
    TSeqPos stop1 = loc1.GetStop(eExtreme_Positional);
    TSeqPos start2 = loc2.GetStart(eExtreme_Positional);
    TSeqPos stop2 = loc2.GetStop(eExtreme_Positional);
 
    if (start1 == stop2 + 1 || start2 == stop1 + 1) {
        // abut
        return false;
    } else if (TestForOverlapEx(loc1, loc2, eOverlap_Contained, scope) >= 0) {
        return true;
    } else {
        return false;
    }
}
 
 
bool s_CheckIntervals(const CSeq_loc& loc1, const CSeq_loc& loc2, CScope* scope)
{
    TSeqPos start1 = loc1.GetStart(eExtreme_Positional);
    TSeqPos stop1 = loc1.GetStop(eExtreme_Positional);
    TSeqPos start2 = loc2.GetStart(eExtreme_Positional);
    TSeqPos stop2 = loc2.GetStop(eExtreme_Positional);
 
    if (start1 == stop2 + 1 || start2 == stop1 + 1) {
        // abut
        return false;
    } else if (TestForOverlapEx(loc1, loc2, eOverlap_CheckIntervals, scope) >= 0) {
        return true;
    } else {
        return false;
    }
}
 
 
void CValidError_bioseq::x_ValidateOverlappingRNAFeatures(
    const CBioseq_Handle& bsh)
{
    // don't bother if can't build all feature iterator
    if (!m_AllFeatIt) {
        return;
    }
    try {
        CCacheImpl::SFeatKey rna_key(
            CSeqFeatData::e_Rna, CCacheImpl::kAnyFeatSubtype, bsh);
        const CCacheImpl::TFeatValue & rnas = GetCache().GetFeatFromCache(rna_key);
        CCacheImpl::TFeatValue::const_iterator feat = rnas.begin();
        if (feat != rnas.end()) {
 
            CCacheImpl::TFeatValue::const_iterator feat_prev = feat;
            ++feat;
            for ( ; feat != rnas.end(); ++feat_prev, ++feat) {
 
                if (!s_OverlapOrAbut(feat_prev->GetLocation(),
                    feat->GetLocation(), m_Scope)) {
                    continue;
                }
 
                const CRNA_ref& tm = feat_prev->GetData().GetRna();
                const CRNA_ref& tr = feat->GetData().GetRna();
                if ( tm.IsSetType() && tm.GetType() == CRNA_ref::eType_tmRNA ) {
                    if ( tr.IsSetType() && tr.GetType() == CRNA_ref::eType_tRNA ) {
                        if (s_ContainedIn(feat_prev->GetLocation(),
                            feat->GetLocation(), m_Scope)) {
                            PostErr (eDiag_Error, eErr_SEQ_FEAT_TRNAinsideTMRNA,
                                     "tRNA contained within tmRNA",
                                     feat->GetOriginalFeature());
                        }
                    }
                }
            }
        }
    } catch ( const exception& e ) {
        if (NStr::Find(e.what(), "Error: Cannot resolve") == string::npos) {
            PostErr(eDiag_Error, eErr_INTERNAL_Exception,
                string("Exception while validating RNA features. EXCEPTION: ") +
                e.what(), *(bsh.GetCompleteBioseq()));
        }
    }
}
 
 
 
void CValidError_bioseq::x_ValidateSourceFeatures(
    const CBioseq_Handle& bsh)
{
    // don't bother if can't build all feature iterator
    if (!m_AllFeatIt) {
        return;
    }
    try {
        CCacheImpl::SFeatKey biosrc_key(
            CSeqFeatData::e_Biosrc, CCacheImpl::kAnyFeatSubtype, bsh);
        const CCacheImpl::TFeatValue & biosrcs = GetCache().GetFeatFromCache(biosrc_key);
        CCacheImpl::TFeatValue::const_iterator feat = biosrcs.begin();
        if (feat != biosrcs.end()) {
            if (IsLocFullLength(feat->GetLocation(), bsh)) {
                CSeqdesc_CI di(bsh, CSeqdesc::e_Source);
                if (di) {
                    if (!s_BiosrcFullLengthIsOk(di->GetSource())) {
                                PostErr (eDiag_Warning, eErr_SEQ_FEAT_BadFullLengthFeature,
                         "Source feature is full length, should be descriptor",
                                 feat->GetOriginalFeature());
                    }
                }
            }
 
            CCacheImpl::TFeatValue::const_iterator feat_prev = feat;
            ++feat;
            for ( ; feat != biosrcs.end(); ++feat_prev, ++feat) {
                if (IsLocFullLength(feat->GetLocation(), bsh)) {
                    PostErr (eDiag_Warning, eErr_SEQ_FEAT_BadFullLengthFeature,
                             "Multiple full-length source features, should only be one if descriptor is transgenic",
                             feat->GetOriginalFeature());
                }
 
                if (!s_OverlapOrAbut(feat_prev->GetLocation(),
                    feat->GetLocation(), m_Scope)) {
                    // not close enough
                    continue;
                }
 
                // compare to see if feature sources are identical
                bool are_identical = true;
                if (feat_prev->IsSetComment() && feat->IsSetComment()
                    && !NStr::EqualNocase (feat_prev->GetComment(), feat->GetComment())) {
                    are_identical = false;
                } else {
                    const CBioSource& src_prev = feat_prev->GetData().GetBiosrc();
                    const CBioSource& src = feat->GetData().GetBiosrc();
                    if ((src.IsSetIs_focus() && !src_prev.IsSetIs_focus())
                        || (!src.IsSetIs_focus() && src_prev.IsSetIs_focus())) {
                        are_identical = false;
                    } else if ((src.IsSetSubtype() && !src_prev.IsSetSubtype())
                               || (!src.IsSetSubtype() && src_prev.IsSetSubtype())
                               || (src.IsSetSubtype() && src_prev.IsSetSubtype()
                                   && !lists_match (src.GetSubtype().begin(), src.GetSubtype().end(),
                                                    src_prev.GetSubtype().begin(), src_prev.GetSubtype().end(),
                                                    s_SubsourceEquivalent))) {
                        are_identical = false;
                    } else if ((src.IsSetOrg() && !src_prev.IsSetOrg())
                               || (!src.IsSetOrg() && src_prev.IsSetOrg())
                               || (src.IsSetOrg() && src_prev.IsSetOrg()
                                   && !s_OrgrefEquivalent (src.GetOrg(), src_prev.GetOrg()))) {
                        are_identical = false;
                    }
                }
                if (are_identical && !s_SuppressMultipleEquivBioSources(feat->GetData().GetBiosrc())) {
                    PostErr (eDiag_Warning, eErr_SEQ_FEAT_MultipleEquivBioSources,
                             "Multiple equivalent source features should be combined into one multi-interval feature",
                             feat->GetOriginalFeature());
                }
            }
        }
    } catch ( const exception& e ) {
        if (NStr::Find(e.what(), "Error: Cannot resolve") == string::npos) {
            PostErr(eDiag_Error, eErr_INTERNAL_Exception,
                string("Exception while validating source features. EXCEPTION: ") +
                e.what(), *(bsh.GetCompleteBioseq()));
        }
    }
 
}
 
 
static void s_MakePubLabelString (const CPubdesc& pd, string& label)
 
{
    label = "";
 
    FOR_EACH_PUB_ON_PUBDESC (it, pd) {
        if ((*it)->IsGen() && (*it)->GetGen().IsSetCit()
            && !(*it)->GetGen().IsSetCit()
            && !(*it)->GetGen().IsSetJournal()
            && !(*it)->GetGen().IsSetDate()
            && (*it)->GetGen().IsSetSerial_number()) {
            // skip over just serial number
        } else {
            (*it)->GetLabel (&label, CPub::eContent, true);
            break;
        }
    }
}
 
 
void CValidError_bioseq::x_ValidatePubFeatures(
    const CBioseq_Handle& bsh)
{
    // don't bother if can't build feature iterator at all
    if (!m_AllFeatIt) {
        return;
    }
    try {
        CCacheImpl::SFeatKey pub_key(
            CSeqFeatData::e_Pub, CCacheImpl::kAnyFeatSubtype, bsh);
        const CCacheImpl::TFeatValue & pubs =
            GetCache().GetFeatFromCache(pub_key);
        CCacheImpl::TFeatValue::const_iterator feat = pubs.begin();
        if (feat != pubs.end()) {
            if (IsLocFullLength(feat->GetLocation(), bsh)) {
                PostErr (eDiag_Warning, eErr_SEQ_FEAT_BadFullLengthFeature,
                         "Publication feature is full length, should be descriptor",
                         feat->GetOriginalFeature());
            }
 
            CCacheImpl::TFeatValue::const_iterator feat_prev = feat;
            string prev_label;
            if( feat_prev != pubs.end()) {
                s_MakePubLabelString(feat_prev->GetData().GetPub(), prev_label);
            ++feat;
            }
            for ( ; feat != pubs.end(); ++feat, ++feat_prev) {
                if (IsLocFullLength(feat->GetLocation(), bsh)) {
                    PostErr (eDiag_Warning, eErr_SEQ_FEAT_BadFullLengthFeature,
                             "Publication feature is full length, should be descriptor",
                             feat->GetOriginalFeature());
                }
                // compare to see if feature sources are identical
                bool are_identical = true;
                if (feat_prev->IsSetComment() && feat->IsSetComment()
                    && !NStr::EqualNocase (feat_prev->GetComment(), feat->GetComment())) {
                    are_identical = false;
                } else {
                    string label;
                    s_MakePubLabelString (feat->GetData().GetPub(), label);
                    if (!NStr::IsBlank (label) && !NStr::IsBlank(prev_label)
                        && !NStr::EqualNocase (label, prev_label)) {
                        are_identical = false;
                    }
 
                    // swap is faster than assignment
                    prev_label.swap(label);
 
                    // TODO: also check authors
                }
 
                if (are_identical) {
                    PostErr (eDiag_Warning, eErr_SEQ_FEAT_MultipleEquivPublications,
                             "Multiple equivalent publication features should be combined into one multi-interval feature",
                             feat->GetOriginalFeature());
                }
            }
        }
    } catch ( const exception& e ) {
        if (NStr::Find(e.what(), "Error: Cannot resolve") == string::npos) {
            PostErr(eDiag_Error, eErr_INTERNAL_Exception,
                string("Exception while validating pub features. EXCEPTION: ") +
                e.what(), *(bsh.GetCompleteBioseq()));
        }
    }
 
}
 
 
struct SCaseInsensitiveQuickLess
{
public:
    // faster than lexicographical order
    bool operator()(const CTempString& lhs, const CTempString& rhs) const
    {
        if( lhs.length() != rhs.length() ) {
            return (lhs.length() < rhs.length());
        }
        return NStr::CompareNocase (lhs, rhs) < 0;
    }
};
 
struct SCaseInsensitiveLess
{
public:
    bool operator()(const CTempString& lhs, const CTempString& rhs) const
    {
        return NStr::CompareNocase (lhs, rhs) < 0;
    }
};
 
 
void CValidError_bioseq::x_ReportDuplicatePubLabels (
    const CBioseq& seq, const vector<CTempString>& labels)
{
    if (labels.size() <= 1) {
        // optimize fast case
        return;
    }
    if (m_Imp.IsRefSeqConventions() || m_Imp.IsRefSeq()) {
        return;
    }
 
    static const string kWarningPrefix =
        "Multiple equivalent publications annotated on this sequence [";
    static const string::size_type kMaxSummaryLen = 100;
 
    // TTempStringCount maps a CTempString to the number of times it appears
    // (Note case-insensitivity and non-lexicographical order)
    typedef map<CTempString, int, SCaseInsensitiveQuickLess> TLabelCount;
    TLabelCount label_count;
 
    ITERATE(vector<CTempString>, label_it, labels) {
        ++label_count[*label_it];
                }
 
    // put the dups into a vector and sort
    vector<CTempString> sorted_dup_labels;
    ITERATE(TLabelCount, label_count_it, label_count) {
        int num_appearances = label_count_it->second;
        _ASSERT(num_appearances > 0);
        if( num_appearances > 1 ) {
            const CTempString & dup_label = label_count_it->first;
            sorted_dup_labels.push_back(dup_label);
            }
            }
    sort(BEGIN_COMMA_END(sorted_dup_labels), SCaseInsensitiveLess());
 
    // find all that appear multiple times
    string err_msg = kWarningPrefix; // avoid create and destroy on each iter'n
    ITERATE(vector<CTempString>, dup_label_it, sorted_dup_labels) {
        const CTempString & summary = *dup_label_it;
 
        err_msg.resize(kWarningPrefix.length());
        if (summary.length() > kMaxSummaryLen) {
            err_msg += summary.substr(0, kMaxSummaryLen);
            err_msg += "...";
        } else {
            err_msg += summary;
        }
        err_msg += "]";
        PostErr (eDiag_Warning, eErr_SEQ_DESCR_CollidingPublications,
                 err_msg, seq);
    }
}
 
 
void CValidError_bioseq::x_ValidateMultiplePubs(
    const CBioseq_Handle& bsh)
{
    // used to check for dups.  Currently only deals with cases where
    // there's an otherpub, but check if this comment is out of date.
    set<TEntrezId> muids_seen;
    set<TEntrezId> pmids_seen;
 
    vector<int> serials;
    vector<CTempString> published_labels;
    vector<CTempString> unpublished_labels;
 
    CConstRef<CSeq_entry> ctx =
        bsh.GetSeq_entry_Handle().GetCompleteSeq_entry();
 
    const CBioseq& seq = *(bsh.GetCompleteBioseq());
 
    for (CSeqdesc_CI it(bsh, CSeqdesc::e_Pub); it; ++it) {
        CConstRef<CPubdesc> pub = ConstRef(&it->GetPub());
        // first, try to receive from cache
        const CCacheImpl::CPubdescInfo & pubdesc_info =
            GetCache().GetPubdescToInfo(pub);
        // note that some (e.g. pmids are ignored other than maybe storing
        // in the cache above)
        copy(BEGIN_COMMA_END(pubdesc_info.m_published_labels),
             back_inserter(published_labels));
        copy(BEGIN_COMMA_END(pubdesc_info.m_unpublished_labels),
             back_inserter(unpublished_labels));
 
        TEntrezId muid = ZERO_ENTREZ_ID;
        TEntrezId pmid = ZERO_ENTREZ_ID;
        bool otherpub = false;
        FOR_EACH_PUB_ON_PUBDESC (pub_it, *pub) {
            switch ( (*pub_it)->Which() ) {
            case CPub::e_Muid:
                muid = (*pub_it)->GetMuid();
                break;
            case CPub::e_Pmid:
                pmid = (*pub_it)->GetPmid();
                break;
            default:
                otherpub = true;
                break;
            }
        }
 
        if ( otherpub ) {
            bool collision = false;
            if ( muid > ZERO_ENTREZ_ID ) {
                if ( muids_seen.find(muid) != muids_seen.end() ) {
                    collision = true;
                } else {
                    muids_seen.insert(muid);
                }
            }
            if ( pmid > ZERO_ENTREZ_ID ) {
                if ( pmids_seen.find(pmid) != pmids_seen.end() ) {
                    collision = true;
                } else {
                    pmids_seen.insert(pmid);
                }
            }
            if ( collision && !m_Imp.IsRefSeqConventions() && !m_Imp.IsRefSeq() ) {
                PostErr(eDiag_Warning, eErr_SEQ_DESCR_CollidingPubMedID,
                    "Multiple publications with identical PubMed ID", *ctx, *it);
            }
        }
    }
 
    x_ReportDuplicatePubLabels (seq, unpublished_labels);
    x_ReportDuplicatePubLabels (seq, published_labels);
 
}
 
 
void CValidError_bioseq::ValidateHistory(const CBioseq& seq)
{
    if ( !seq.GetInst().IsSetHist() ) {
        return;
    }
 
    TGi gi = ZERO_GI;
    FOR_EACH_SEQID_ON_BIOSEQ (id, seq) {
        if ( (*id)->IsGi() ) {
            gi = (*id)->GetGi();
            break;
        }
    }
    if ( gi == ZERO_GI ) {
        return;
    }
 
    const CSeq_hist& hist = seq.GetInst().GetHist();
    if ( hist.IsSetReplaced_by() && hist.GetReplaced_by().IsSetDate() ) {
        const CSeq_hist_rec& rec = hist.GetReplaced_by();
        ITERATE( CSeq_hist_rec::TIds, id, rec.GetIds() ) {
            if ( (*id)->IsGi() ) {
                if ( gi == (*id)->GetGi() ) {
                    PostErr(eDiag_Error, eErr_SEQ_INST_HistoryGiCollision,
                        "Replaced by gi (" +
                        NStr::NumericToString(gi) + ") is same as current Bioseq",
                        seq);
                    break;
                }
            }
        }
    }
 
    if ( hist.IsSetReplaces() && hist.GetReplaces().IsSetDate() ) {
        const CSeq_hist_rec& rec = hist.GetReplaces();
        ITERATE( CSeq_hist_rec::TIds, id, rec.GetIds() ) {
            if ( (*id)->IsGi() ) {
                if ( gi == (*id)->GetGi() ) {
                    PostErr(eDiag_Error, eErr_SEQ_INST_HistoryGiCollision,
                        "Replaces gi (" +
                        NStr::NumericToString(gi) + ") is same as current Bioseq",
                        seq);
                    break;
                }
            }
        }
    }
}
 
 
// =============================================================================
//                                     Private
// =============================================================================
 
 
 
 
// Is the id contained in the bioseq?
bool CValidError_bioseq::IsIdIn(const CSeq_id& id, const CBioseq& seq)
{
    FOR_EACH_SEQID_ON_BIOSEQ (it, seq) {
        if (id.Match(**it)) {
            return true;
        }
    }
    return false;
}
 
 
size_t CValidError_bioseq::GetDataLen(const CSeq_inst& inst)
{
    if (!inst.IsSetSeq_data()) {
        return 0;
    }
 
    const CSeq_data& seqdata = inst.GetSeq_data();
    switch (seqdata.Which()) {
    case CSeq_data::e_not_set:
        return 0;
    case CSeq_data::e_Iupacna:
        return seqdata.GetIupacna().Get().size();
    case CSeq_data::e_Iupacaa:
        return seqdata.GetIupacaa().Get().size();
    case CSeq_data::e_Ncbi2na:
        return seqdata.GetNcbi2na().Get().size();
    case CSeq_data::e_Ncbi4na:
        return seqdata.GetNcbi4na().Get().size();
    case CSeq_data::e_Ncbi8na:
        return seqdata.GetNcbi8na().Get().size();
    case CSeq_data::e_Ncbipna:
        return seqdata.GetNcbipna().Get().size();
    case CSeq_data::e_Ncbi8aa:
        return seqdata.GetNcbi8aa().Get().size();
    case CSeq_data::e_Ncbieaa:
        return seqdata.GetNcbieaa().Get().size();
    case CSeq_data::e_Ncbipaa:
        return seqdata.GetNcbipaa().Get().size();
    case CSeq_data::e_Ncbistdaa:
        return seqdata.GetNcbistdaa().Get().size();
    default:
        return 0;
    }
}
 
 
// Returns true if seq derived from translation ending in "*" or
// seq is 3' partial (i.e. the right of the sequence is incomplete)
bool CValidError_bioseq::SuppressTrailingXMsg(const CBioseq& seq)
{
 
    // Look for the Cdregion feature used to create this aa product
    // Use the Cdregion to translate the associated na sequence
    // and check if translation has a '*' at the end. If it does.
    // message about 'X' at the end of this aa product sequence is suppressed
    try {
        const CSeq_feat* sfp = m_Imp.GetCDSGivenProduct(seq);
        if ( sfp ) {
            // Translate na CSeq_data
            string prot;
            CSeqTranslator::Translate(*sfp, *m_Scope, prot);
            if ( prot[prot.size() - 1] == '*' ) {
                return true;
            }
            return false;
        }
 
        // Get CMolInfo for seq and determine if completeness is
        // "eCompleteness_no_right or eCompleteness_no_ends. If so
        // suppress message about "X" at end of aa sequence is suppressed
        CTypeConstIterator<CMolInfo> mi = ConstBegin(seq);
        if (mi  &&  mi->IsSetCompleteness()) {
            if (mi->GetCompleteness() == CMolInfo::eCompleteness_no_right  ||
              mi->GetCompleteness() == CMolInfo::eCompleteness_no_ends) {
                return true;
            }
        }
    } catch (const CException& ) {
    } catch (const std::exception& ) {
    }
    return false;
}
 
 
//LCOV_EXCL_START
//part of segset validation, no longer used
CRef<CSeq_loc> CValidError_bioseq::GetLocFromSeq(const CBioseq& seq)
{
    CRef<CSeq_loc> loc;
    if (!seq.GetInst().IsSetExt()) {
        return loc;
    }
 
    if (seq.GetInst().GetExt().IsSeg()) {
        CRef<CSeq_loc> nloc(new CSeq_loc());
        loc = nloc;
        CSeq_loc_mix& mix = loc->SetMix();
        ITERATE (list< CRef<CSeq_loc> >, it,
            seq.GetInst().GetExt().GetSeg().Get()) {
            mix.Set().push_back(*it);
        }
    } else if (seq.GetInst().GetExt().IsRef()) {
        CRef<CSeq_loc> nloc(new CSeq_loc());
        loc = nloc;
        loc->Add(seq.GetInst().GetExt().GetRef());
    }
    return loc;
}
//LCOV_EXCL_STOP
 
 
// Check if CdRegion required but not found
bool CValidError_bioseq::CdError(const CBioseq_Handle& bsh)
{
    if ( bsh  &&  CSeq_inst::IsAa(bsh.GetInst_Mol()) ) {
        CSeq_entry_Handle nps =
            bsh.GetExactComplexityLevel(CBioseq_set::eClass_nuc_prot);
        if ( nps ) {
            const CSeq_feat* cds = GetCDSForProduct(bsh);
            if ( !cds ) {
                const CSeq_feat* mat = GetPROTForProduct(bsh);
                if ( !mat ) {
                    return true;
                }
            }
        }
    }
 
    return false;
}
 
 
bool CValidError_bioseq::IsMrna(const CBioseq_Handle& bsh)
{
    CSeqdesc_CI sd(bsh, CSeqdesc::e_Molinfo);
 
    if ( sd ) {
        const CMolInfo &mi = sd->GetMolinfo();
        if ( mi.IsSetBiomol() ) {
            return mi.GetBiomol() == CMolInfo::eBiomol_mRNA;
        }
    } else if (bsh.GetBioseqMolType() == CSeq_inst::eMol_rna) {
        // if no molinfo, assume rna is mrna
        return true;
    }
 
    return false;
}
 
 
size_t CValidError_bioseq::NumOfIntervals(const CSeq_loc& loc)
{
    size_t counter = 0;
    for ( CSeq_loc_CI slit(loc); slit; ++slit ) {
        if ( !IsFarLocation(slit.GetEmbeddingSeq_loc(), m_Imp.GetTSEH()) ) {
            ++counter;
        }
    }
    return counter;
}
 
 
static bool s_NotPeptideException
(const CSeq_feat& curr,
 const CSeq_feat& prev)
{
    if (curr.IsSetExcept()  &&  curr.GetExcept()  &&  curr.IsSetExcept_text()) {
        if (NStr::FindNoCase(curr.GetExcept_text(), "alternative processing") != NPOS) {
            return false;
        }
    }
    if (prev.IsSetExcept()  &&  prev.GetExcept()  &&  prev.IsSetExcept_text()) {
        if (NStr::FindNoCase(prev.GetExcept_text(), "alternative processing") != NPOS) {
            return false;
        }
    }
 
    const CProt_ref& currP = curr.GetData().GetProt();
    const CProt_ref& prevP = prev.GetData().GetProt();
 
    if (currP.IsSetName() && prevP.IsSetName()) {
        string currN;
        for (auto it : currP.GetName()) {
            currN = it;
            break;
        }
        string prevN;
        for (auto it : prevP.GetName()) {
            prevN = it;
            break;
        }
        if (NStr::EqualNocase (currN, "anchored capsid protein ancC") && NStr::EqualNocase (prevN, "capsid protein C")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "anchored capsid protein ancC") && NStr::EqualNocase (currN, "capsid protein C")) {
            return false;
        }
        if (NStr::EqualNocase (currN, "membrane glycoprotein precursor prM") && NStr::EqualNocase (prevN, "protein pr")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "membrane glycoprotein precursor prM") && NStr::EqualNocase (currN, "protein pr")) {
            return false;
        }
        if (NStr::EqualNocase (currN, "membrane glycoprotein precursor prM") && NStr::EqualNocase (prevN, "membrane glycoprotein M")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "membrane glycoprotein precursor prM") && NStr::EqualNocase (currN, "membrane glycoprotein M")) {
            return false;
        }
        if (NStr::EqualNocase (currN, "anchored capsid protein C") && NStr::EqualNocase (prevN, "capsid protein C")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "anchored capsid protein C") && NStr::EqualNocase (currN, "capsid protein C")) {
            return false;
        }
        if (NStr::EqualNocase (currN, "membrane glycoprotein precursor M") && NStr::EqualNocase (prevN, "protein pr")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "membrane glycoprotein precursor M") && NStr::EqualNocase (currN, "protein pr")) {
            return false;
        }
        if (NStr::EqualNocase (currN, "membrane glycoprotein precursor M") && NStr::EqualNocase (prevN, "membrane glycoprotein M")) {
            return false;
        }
        if (NStr::EqualNocase (prevN, "membrane glycoprotein precursor M") && NStr::EqualNocase (currN, "membrane glycoprotein M")) {
            return false;
        }
    }
 
 
    return true;
}
 
 
#define FOR_EACH_SEQID_ON_BIOSEQ_HANDLE(Itr, Var) \
ITERATE (CBioseq_Handle::TId, Itr, Var.GetId())
 
bool CValidError_bioseq::IsWGSMaster(const CBioseq& seq, CScope& scope)
{
    if (!IsMaster(seq)) {
        return false;
    }
    CBioseq_Handle bsh = scope.GetBioseqHandle(seq);
    return IsWGS(bsh);
}
 
 
bool CValidError_bioseq::IsWGSMaster(const CSeq_entry& entry)
{
    bool rval = false;
    if (entry.IsSeq()) {
        if (IsMaster(entry.GetSeq()) && IsWGS(entry.GetSeq())) {
            rval = true;
        }
    } else if (entry.IsSet() && entry.GetSet().IsSetSeq_set()) {
        ITERATE(CBioseq_set::TSeq_set, it, entry.GetSet().GetSeq_set()) {
            if (IsWGSMaster(**it)) {
                rval = true;
                break;
            }
        }
    }
    return rval;
}
 
 
bool CValidError_bioseq::IsWGS(const CBioseq& seq)
{
    if (!seq.IsSetDescr()) {
        return false;
    }
    ITERATE(CBioseq::TDescr::Tdata, it, seq.GetDescr().Get()) {
        if ((*it)->IsMolinfo() && (*it)->GetMolinfo().IsSetTech() && (*it)->GetMolinfo().GetTech() == CMolInfo::eTech_wgs) {
            return true;
        }
    }
    return false;
}
 
 
bool CValidError_bioseq::IsWGS(CBioseq_Handle bsh)
{
    CSeqdesc_CI molinfo(bsh, CSeqdesc::e_Molinfo);
    if (molinfo && molinfo->GetMolinfo().IsSetTech() && molinfo->GetMolinfo().GetTech() == CMolInfo::eTech_wgs) {
        return true;
    }
    return false;
}
 
 
bool CValidError_bioseq::IsWGS(const CSeq_entry& entry)
{
    bool rval = false;
    if (entry.IsSeq()) {
        rval = IsWGS(entry.GetSeq());
    } else if (entry.IsSet() && entry.GetSet().IsSetSeq_set()) {
        for (auto it : entry.GetSet().GetSeq_set()) {
            if (IsWGS(*it)) {
                rval = true;
                break;
            }
        }
    }
    return rval;
}
 
 
bool CValidError_bioseq::IsWGSAccession(const CSeq_id& id)
{
    const CTextseq_id* txt = id.GetTextseq_Id();
    if (!txt || !txt->IsSetAccession()) {
        return false;
    }
    CSeq_id::EAccessionInfo info = CSeq_id::IdentifyAccession(txt->GetAccession());
    if ((info & CSeq_id::eAcc_division_mask) == CSeq_id::eAcc_wgs) {
        return true;
    } else {
        return false;
    }
}
 
 
bool CValidError_bioseq::IsWGSAccession(const CBioseq& seq)
{
    if (!seq.IsSetId()) {
        return false;
    }
    ITERATE(CBioseq::TId, id, seq.GetId()) {
        if (IsWGSAccession(**id)) {
            return true;
        }
    }
    return false;
}
 
 
bool CValidError_bioseq::IsTSAAccession(const CSeq_id& id)
{
    const CTextseq_id* txt = id.GetTextseq_Id();
    if (!txt || !txt->IsSetAccession()) {
        return false;
    }
    CSeq_id::EAccessionInfo info = CSeq_id::IdentifyAccession(txt->GetAccession());
    if ((info & CSeq_id::eAcc_division_mask) == CSeq_id::eAcc_tsa) {
        return true;
    } else {
        return false;
    }
}
 
 
bool CValidError_bioseq::IsTSAAccession(const CBioseq& seq)
{
    if (!seq.IsSetId()) {
        return false;
    }
    ITERATE(CBioseq::TId, id, seq.GetId()) {
        if (IsTSAAccession(**id)) {
            return true;
        }
    }
    return false;
}
 
 
bool CValidError_bioseq::IsPartial(const CBioseq& seq, CScope& scope)
{
    CBioseq_Handle bsh = scope.GetBioseqHandle(seq);
    CSeqdesc_CI desc(bsh, CSeqdesc::e_Molinfo);
    if (desc && desc->GetMolinfo().IsSetCompleteness()) {
        CMolInfo::TCompleteness completeness = desc->GetMolinfo().GetCompleteness();
        if (completeness == CMolInfo::eCompleteness_partial
            || completeness == CMolInfo::eCompleteness_no_left
            || completeness == CMolInfo::eCompleteness_no_right
            || completeness == CMolInfo::eCompleteness_no_ends) {
            return true;
        }
    }
    return false;
}
 
 
bool CValidError_bioseq::IsPdb(const CBioseq& seq)
{
    FOR_EACH_SEQID_ON_BIOSEQ(id, seq) {
        if ((*id)->IsPdb()) {
            return true;
        }
    }
    return false;
}
 
 
void CValidError_bioseq::ValidateSeqLen(const CBioseq& seq)
{
    if (IsPdb(seq) || IsWGSMaster(seq, *m_Scope)) {
        return;
    }
    const CSeq_inst& inst = seq.GetInst();
 
    TSeqPos len = inst.IsSetLength() ? inst.GetLength() : 0;
    if ( seq.IsAa() ) {
        if (len <= 3 && !IsPartial(seq, *m_Scope)) {
            PostErr(eDiag_Warning, eErr_SEQ_INST_ShortSeq, "Sequence only " +
                NStr::IntToString(len) + " residues", seq);
        }
    } else {
        if ( len <= 10 && m_report_short_seq) {
            PostErr(eDiag_Warning, eErr_SEQ_INST_ShortSeq, "Sequence only " +
                NStr::IntToString(len) + " residues", seq);
        }
    }
}
 
 
// Assumes that seq is segmented and has Seq-ext data
void CValidError_bioseq::ValidateSeqParts(const CBioseq& seq)
{
    // Get parent CSeq_entry of seq and then find the next
    // CSeq_entry in the set. This CSeq_entry should be a CBioseq_set
    // of class parts.
    const CSeq_entry* se = seq.GetParentEntry();
    if (!se) {
        return;
    }
    const CSeq_entry* parent = se->GetParentEntry ();
    if (!parent) {
        return;
    }
    if ( !parent->IsSet() || !parent->GetSet().IsSetClass() || parent->GetSet().GetClass() != CBioseq_set::eClass_segset) {
        return;
    }
 
    // Loop through seq_set looking for the parts set.
    FOR_EACH_SEQENTRY_ON_SEQSET (it, parent->GetSet()) {
        if ((*it)->Which() == CSeq_entry::e_Set
            && (*it)->GetSet().IsSetClass()
            && (*it)->GetSet().GetClass() == CBioseq_set::eClass_parts) {
            const CBioseq_set::TSeq_set& parts = (*it)->GetSet().GetSeq_set();
            const CSeg_ext::Tdata& locs = seq.GetInst().GetExt().GetSeg().Get();
 
            // Make sure the number of locations (excluding null locations)
            // match the number of parts
            size_t nulls = 0;
            ITERATE ( CSeg_ext::Tdata, loc, locs ) {
                if ( (*loc)->IsNull() ) {
                    nulls++;
                }
            }
            if ( locs.size() - nulls < parts.size() ) {
                 PostErr(eDiag_Error, eErr_SEQ_INST_PartsOutOfOrder,
                    "Parts set contains too many Bioseqs", seq);
                 return;
            } else if ( locs.size() - nulls > parts.size() ) {
                PostErr(eDiag_Error, eErr_SEQ_INST_PartsOutOfOrder,
                    "Parts set does not contain enough Bioseqs", seq);
                return;
            }
 
            // Now, simultaneously loop through the parts of se_parts and CSeq_locs of
            // seq's CSseq-ext. If don't compare, post error.
            size_t size = locs.size();  // == parts.size()
            CSeg_ext::Tdata::const_iterator loc_it = locs.begin();
            CBioseq_set::TSeq_set::const_iterator part_it = parts.begin();
            for ( size_t i = 0; i < size; ++i ) {
                try {
                    if ( (*loc_it)->IsNull() ) {
                        ++loc_it;
                        continue;
                    }
                    if ( !(*part_it)->IsSeq() ) {
                        PostErr(eDiag_Error, eErr_SEQ_INST_PartsOutOfOrder,
                            "Parts set component is not Bioseq", seq);
                        return;
                    }
                    const CSeq_id& loc_id = GetId(**loc_it, m_Scope);
                    if ( !IsIdIn(loc_id, (*part_it)->GetSeq()) ) {
                        PostErr(eDiag_Error, eErr_SEQ_INST_PartsOutOfOrder,
                            "Segmented bioseq seq_ext does not correspond to parts "
                            "packaging order", seq);
                        return;
                    }
 
                    // advance both iterators
                    ++part_it;
                    ++loc_it;
                } catch (const CObjmgrUtilException&) {
                    ERR_POST_X(4, "Seq-loc not for unique sequence");
                    return;
                } catch (CException &x1) {
                    string err_msg = "Unknown error:";
                    err_msg += x1.what();
                    ERR_POST_X(5, err_msg);
                    return;
                } catch (std::exception &x2) {
                    string err_msg = "Unknown error:";
                    err_msg += x2.what();
                    ERR_POST_X(5, err_msg);
                    return;
                }
            }
        }
    }
}
 
static bool s_IsConWithGaps(const CBioseq& seq)
 
{
 
    if (! seq.IsSetInst ()) return false;
    const CSeq_inst& inst = seq.GetInst();
    if (! inst.IsSetExt ()) return false;
    if (! inst.GetExt().IsDelta()) return false;
 
    ITERATE(CDelta_ext::Tdata, iter, inst.GetExt().GetDelta().Get()) {
        if (! (*iter)->IsLiteral() ) continue;
        const CSeq_literal& lit = (*iter)->GetLiteral();
        if (!lit.IsSetSeq_data()) return true;
        if  (lit.GetSeq_data().IsGap() && lit.GetLength() > 0) return true;
    }
 
    return false;
}
 
 
bool CValidError_bioseq::x_HasGap(const CBioseq& seq)
{
    bool has_gap = false;
    if (seq.GetInst().IsSetExt() && seq.GetInst().GetExt().IsDelta()) {
        ITERATE(CDelta_ext::Tdata, iter, seq.GetInst().GetExt().GetDelta().Get()) {
            if ((*iter)->IsLiteral() &&
                (!(*iter)->GetLiteral().IsSetSeq_data() || (*iter)->GetLiteral().GetSeq_data().IsGap())) {
                has_gap = true;
                break;
            }
        }
    }
    return has_gap;
}
 
void CValidError_bioseq::x_ValidateTitle(const CBioseq& seq)
{
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    if (!bsh) {
        return;
    }
 
    string title = sequence::CDeflineGenerator().GenerateDefline(bsh);
 
/*bsv
    CMolInfo::TTech tech = CMolInfo::eTech_unknown;
*/
    CSeqdesc_CI desc(bsh, CSeqdesc::e_Molinfo);
    if (desc) {
        const CMolInfo& mi = desc->GetMolinfo();
/*bsv
        tech = mi.GetTech();
*/
        if (mi.GetCompleteness() != CMolInfo::eCompleteness_complete) {
            if (m_Imp.IsGenbank()) {
                if (NStr::Find(title, "complete genome") != NPOS) {
                    const CSeq_entry& ctx = *seq.GetParentEntry();
                    PostErr(eDiag_Warning, eErr_SEQ_INST_CompleteTitleProblem,
                        "Complete genome in title without complete flag set",
                        ctx, *desc);
                }
            }
            if (bsh.GetInst_Topology() == CSeq_inst::eTopology_circular &&
                (! s_IsConWithGaps (seq)) &&
                !m_Imp.IsEmbl() && !m_Imp.IsDdbj()) {
                const CSeq_entry& ctx = *seq.GetParentEntry();
                PostErr(eDiag_Warning, eErr_SEQ_INST_CompleteCircleProblem,
                    "Circular topology without complete flag set", ctx, *desc);
            }
        }
    }
 
    // warning if title contains complete genome but sequence contains gap features
    if (NStr::FindNoCase (title, "complete genome") != NPOS && x_HasGap(seq)) {
        PostErr(eDiag_Warning, eErr_SEQ_INST_CompleteGenomeHasGaps,
                "Title contains 'complete genome' but sequence has gaps", seq);
    }
 
 
    // note - test for protein titles was moved to CValidError_bioseqset::ValidateNucProtSet
    // because it only applied for protein sequences in nuc-prot sets and it's more efficient
    // to create the defline generator once per nuc-prot set
}
 
static bool HasAssemblyOrNullGap (const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
    if (inst.CanGetRepr() && inst.GetRepr() == CSeq_inst::eRepr_delta && inst.CanGetExt()  &&  inst.GetExt().IsDelta()) {
        ITERATE(CDelta_ext::Tdata, sg, inst.GetExt().GetDelta().Get()) {
            if ( !(*sg) ) continue;
            if ((**sg).Which() != CDelta_seq::e_Literal) continue;
            const CSeq_literal& lit = (*sg)->GetLiteral();
            if (! lit.IsSetSeq_data()) return true;
            if (lit.GetSeq_data().IsGap()) return true;
        }
    }
 
    return false;
}
 
 
void CValidError_bioseq::ReportBadAssemblyGap (const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
    if (inst.CanGetRepr() && inst.GetRepr() == CSeq_inst::eRepr_delta && inst.CanGetExt()  &&  inst.GetExt().IsDelta()) {
        ITERATE(CDelta_ext::Tdata, sg, inst.GetExt().GetDelta().Get()) {
            if ( !(*sg) ) continue;
            if ((**sg).Which() != CDelta_seq::e_Literal) continue;
            const CSeq_literal& lit = (*sg)->GetLiteral();
            if (! lit.IsSetSeq_data()) {
                PostErr(eDiag_Warning, eErr_SEQ_INST_SeqGapProblem, "TSA Seq_data NULL", seq);
            } else {
                const CSeq_data& data = lit.GetSeq_data();
                if (data.Which() == CSeq_data::e_Gap) {
                    const CSeq_gap& gap = data.GetGap();
                    if (gap.IsSetType()) {
                        int gaptype = gap.GetType();
                        if (gaptype == CSeq_gap::eType_unknown) {
                            PostErr(eDiag_Warning, eErr_SEQ_INST_TSAseqGapProblem, "TSA Seq_gap.unknown", seq);
                        } else if (gaptype == CSeq_gap::eType_other) {
                            PostErr(eDiag_Warning, eErr_SEQ_INST_TSAseqGapProblem, "TSA Seq_gap.other", seq);
                        }
                    } else {
                        PostErr(eDiag_Warning, eErr_SEQ_INST_TSAseqGapProblem, "TSA Seq_gap NULL", seq);
                    }
                }
            }
        }
    }
}
 
 
bool CValidError_bioseq::HasBadWGSGap(const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
    if (inst.CanGetRepr() && inst.GetRepr() == CSeq_inst::eRepr_delta && inst.CanGetExt() && inst.GetExt().IsDelta()) {
        ITERATE(CDelta_ext::Tdata, sg, inst.GetExt().GetDelta().Get()) {
            if (!(*sg)) continue;
             // CON division - far delta - suppresses errors
            if ((**sg).Which() != CDelta_seq::e_Literal) /* continue */ return false;
            const CSeq_literal& lit = (*sg)->GetLiteral();
            if (!lit.IsSetSeq_data()) {
                return true;
            } else {
                const CSeq_data& data = lit.GetSeq_data();
                if (data.Which() == CSeq_data::e_Gap) {
                    const CSeq_gap& gap = data.GetGap();
                    CSeq_gap::TType gap_type = gap.IsSetType() ? gap.GetType() : CSeq_gap::eType_unknown;
 
                    if (gap_type != CSeq_gap::eType_centromere && gap_type != CSeq_gap::eType_heterochromatin &&
                        gap_type != CSeq_gap::eType_short_arm && gap_type != CSeq_gap::eType_telomere &&
                        gap_type != CSeq_gap::eType_contig) {
 
                        if (!gap.IsSetLinkage_evidence() || gap.GetLinkage_evidence().empty()) {
                            return true;
                        }
                    }
                }
            }
        }
    }
    return false;
}
 
 
void CValidError_bioseq::ReportBadWGSGap(const CBioseq& seq)
{
    if (HasBadWGSGap(seq)) {
        PostErr(eDiag_Error, eErr_SEQ_INST_WGSseqGapProblem,
            "WGS submission includes wrong gap type. Gaps for WGS genomes should be Assembly Gaps with linkage evidence.", seq);
    }
}
 
 
void CValidError_bioseq::ReportBadTSAGap(const CBioseq& seq)
{
    if (HasBadWGSGap(seq)) {
        PostErr(eDiag_Error, eErr_SEQ_INST_TSAseqGapProblem,
            "TSA submission includes wrong gap type. Gaps for TSA should be Assembly Gaps with linkage evidence.", seq);
    }
}
 
 
void CValidError_bioseq::ReportBadGenomeGap(const CBioseq& seq)
{
    if (HasBadWGSGap(seq)) {
        PostErr(eDiag_Error, eErr_SEQ_INST_SeqGapProblem,
            "Genome submission includes wrong gap type. Gaps for genomes should be Assembly Gaps with linkage evidence.", seq);
    }
}
 
 
bool s_FieldHasLabel(const CUser_field& field, const string& label)
{
    if (field.IsSetLabel() && field.GetLabel().IsStr() &&
        NStr::EqualNocase(field.GetLabel().GetStr(), label)) {
        return true;
    } else {
        return false;
    }
}
 
 
bool s_FieldHasNonBlankValue(const CUser_field& field)
{
    if (!field.IsSetData()) {
        return false;
    }
    bool rval = false;
    if (field.GetData().IsStr()) {
        if (!NStr::IsBlank(field.GetData().GetStr())) {
            rval = true;
        }
    } else if (field.GetData().IsStrs()) {
        ITERATE(CUser_field::TData::TStrs, s, field.GetData().GetStrs()) {
            if (!NStr::IsBlank(*s)) {
                rval = true;
                break;
            }
        }
    }
    return rval;
}
 
 
void CValidError_bioseq::ValidateWGSMaster(CBioseq_Handle bsh)
{
    bool has_biosample = false;
    bool has_bioproject = false;
 
    CSeqdesc_CI d(bsh, CSeqdesc::e_User);
    while (d) {
        if (d->GetUser().GetObjectType() == CUser_object::eObjectType_DBLink && d->GetUser().IsSetData()) {
            for (auto it: d->GetUser().GetData()) {
                if (s_FieldHasLabel(*it, "BioSample")) {
                    if (s_FieldHasNonBlankValue(*it)) {
                        has_biosample = true;
                    }
                } else if (s_FieldHasLabel(*it, "BioProject")) {
                    if (s_FieldHasNonBlankValue(*it)) {
                        has_bioproject = true;
                    }
                }
            }
        } else if (m_Imp.IsGenbank()) {
            const CUser_object& uo = d->GetUser();
            if (uo.GetType().IsStr()) {
                const string& type = uo.GetType().GetStr();
                if ( NStr::CompareNocase(type, "WGSProjects") == 0 ) {
                    int fr = 0;
                    int to = 0;
 
                    for (auto it: uo.GetData()) {
                        if ( !it->GetLabel().IsStr() ) {
                            continue;
                        }
                        const string& label = it->GetLabel().GetStr();
                        if ( NStr::CompareNocase(label, "WGS_accession_first") == 0  ||
                             NStr::CompareNocase(label, "Accession_first") == 0 ) {
                            const string& str = it->GetData().GetStr();
                            auto fst = str.find_first_of("0123456789");
                            fr = NStr::StringToInt (str.substr(fst));
                        } else if ( NStr::CompareNocase(label, "WGS_accession_last") == 0 ||
                                    NStr::CompareNocase(label, "Accession_last") == 0 ) {
                            const string& str = it->GetData().GetStr();
                            auto lst = str.find_first_of("0123456789");
                            to = NStr::StringToInt (str.substr(lst));
                        }
                    }
                    if ( (fr != 0)  &&  (to != 0) ) {
                        int df = to - fr + 1;
                        int blen = bsh.GetBioseqLength();
                        if (df != blen) {
                            PostErr(eDiag_Error, eErr_SEQ_DESCR_InconsistentWGSFlags,
                                "Number of accessions (" + NStr::IntToString(df) + ") does not correspond to number of records (" + NStr::IntToString(blen) +")",
                                *(bsh.GetCompleteBioseq()));
                        }
                    }
                }
            }
        }
        ++d;
    }
    if (!has_biosample && !has_bioproject) {
        PostErr(eDiag_Error, eErr_SEQ_DESCR_WGSMasterLacksBothBioSampleBioProject,
                "WGS master lacks both BioSample and BioProject",
                *(bsh.GetCompleteBioseq()));
    } else if (!has_biosample) {
        PostErr(eDiag_Error, eErr_SEQ_DESCR_WGSmasterLacksBioSample,
            "WGS master lacks BioSample",
            *(bsh.GetCompleteBioseq()));
    } else if (!has_bioproject) {
        PostErr(eDiag_Error, eErr_SEQ_DESCR_WGSmasterLacksBioProject,
            "WGS master lacks BioProject",
            *(bsh.GetCompleteBioseq()));
    }
    if (!has_biosample || !has_bioproject) {
    }
}
 
 
static EDiagSev GetBioseqEndWarning (const CBioseq& seq, bool is_circular, EBioseqEndIsType end_is_char)
{
    EDiagSev sev;
    bool only_local = true;
    bool is_NCACNTNW = false;
    bool is_patent = false;
    FOR_EACH_SEQID_ON_BIOSEQ(id_it, seq) {
        if (!(*id_it)->IsLocal()) {
            only_local = false;
            if ((*id_it)->IsPatent()) {
                is_patent = true;
            } else if (IsNTNCNWACAccession(**id_it)) {
                is_NCACNTNW = true;
            }
        }
    }
 
    if (is_NCACNTNW || is_patent) {
        sev = eDiag_Warning;
    } else if (is_circular) {
        sev = eDiag_Warning;
    } else if (only_local) {
        sev = eDiag_Warning;
    } else if (end_is_char == eBioseqEndIsType_All) {
        sev = eDiag_Error;
    } else {
        sev = eDiag_Warning;
    }
    return sev;
}
 
 
void CValidError_bioseq::x_CalculateNsStretchAndTotal(const CSeqVector& vec, TSeqPos& num_ns, TSeqPos& max_stretch, bool& n5, bool& n3)
{
 
    _ASSERT(vec.GetCoding() == CSeq_data::e_Iupacna);
 
    num_ns = 0;
    max_stretch = 0;
    n5 = false;
    n3 = false;
 
    TSeqPos this_stretch = 0;
    for (TSeqPos i = 0; i < vec.size(); i++) {
        if (vec[i] == 'N') {
            num_ns++;
            if (vec.IsInGap(i)) {
                if (max_stretch < this_stretch) {
                    max_stretch = this_stretch;
                }
                this_stretch = 0;
            } else {
                this_stretch++;
                if (this_stretch >= 10) {
                    if (i < 20) {
                        n5 = true;
                    }
                    if (vec.size() > 20 && i > vec.size() - 10) {
                        n3 = true;
                    }
                }
            }
        } else {
            if (max_stretch < this_stretch) {
                max_stretch = this_stretch;
            }
            this_stretch = 0;
        }
    }
    if (max_stretch < this_stretch) {
        max_stretch = this_stretch;
    }
}
 
 
bool CValidError_bioseq::GetTSANStretchErrors(const CBioseq& seq)
{
 
    bool rval = false;
    if (HasAssemblyOrNullGap(seq)) {
        return rval;
    }
 
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    if ( !bsh ) {
        return rval;
    }
 
 
    TSeqPos num_ns = 0;
    TSeqPos max_stretch = 0;
    bool n5 = false;
    bool n3 = false;
 
 
    auto vec = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
    x_CalculateNsStretchAndTotal(vec, num_ns, max_stretch, n5, n3);
 
    if (max_stretch >= 15) {
        PostErr (eDiag_Warning, eErr_SEQ_INST_HighNContentStretch,
                    "Sequence has a stretch of " + NStr::IntToString(max_stretch) + " Ns", seq);
        rval = true;
    } else {
        if (n5) {
            PostErr (eDiag_Warning, eErr_SEQ_INST_HighNcontent5Prime,
                        "Sequence has a stretch of at least 10 Ns within the first 20 bases", seq);
            rval = true;
        }
        if (n3) {
            PostErr (eDiag_Warning, eErr_SEQ_INST_HighNcontent3Prime,
                        "Sequence has a stretch of at least 10 Ns within the last 20 bases", seq);
            rval = true;
        }
    }
    return rval;
}
 
 
// check to see if sequence is all Ns
bool CValidError_bioseq::IsAllNs(const CSeqVector& vec)
{
    bool rval = true;
    bool at_least_one = false;
    try {
        for (CSeqVector_CI sv_iter(vec); (sv_iter) && rval; ++sv_iter) {
            if (*sv_iter != 'N') {
                rval = false;
            }
            at_least_one = true;
        }
    } catch (CException& ) {
 
    }
    return (rval && at_least_one);
}
 
 
static int CountNs(const CSeq_data& seq_data, TSeqPos len)
{
    int total = 0;
    switch (seq_data.Which()) {
        case CSeq_data::e_Ncbi4na:
            {
                vector<char>::const_iterator it = seq_data.GetNcbi4na().Get().begin();
                unsigned char mask = 0xf0;
                unsigned char shift = 4;
                for (size_t n = 0; n < len; n++) {
                    unsigned char c = ((*it) & mask) >> shift;
                    mask >>= 4;
                    shift -= 4;
                    if (!mask) {
                        mask = 0xf0;
                        shift = 4;
                        ++it;
                    }
                    if (c == 15) {
                        total++;
                    }
                }
            }
            return total;
        case CSeq_data::e_Iupacna:
            {
                const string& s = seq_data.GetIupacna().Get();
                for (size_t n = 0; n < len && n < s.length(); n++) {
                    if (s[n] == 'N') {
                        total++;
                    }
                }
            }
            return total;
        case CSeq_data::e_Ncbi8na:
        case CSeq_data::e_Ncbipna:
            {
                CSeq_data iupacna;
                if (!CSeqportUtil::Convert(seq_data, &iupacna, CSeq_data::e_Iupacna)) {
                    return total;
                }
                const string& s = iupacna.GetIupacna().Get();
                for (size_t n = 0; n < len; n++) {
                    if (s[n] == 'N') {
                        total++;
                    }
                }
            }
            return total;
        default:
            return total;
    }
}
 
 
int CValidError_bioseq::PctNs(CBioseq_Handle bsh)
{
    int count = 0;
    SSeqMapSelector sel;
    sel.SetFlags(CSeqMap::fFindData | CSeqMap::fFindGap | CSeqMap::fFindLeafRef);
    for (CSeqMap_CI seq_iter(bsh, sel); seq_iter; ++seq_iter) {
        switch (seq_iter.GetType()) {
            case CSeqMap::eSeqData:
                count += CountNs(seq_iter.GetData(), seq_iter.GetLength());
                break;
            default:
                break;
        }
    }
/*
    int pct_n = 0;
    try {
        CSeqVector vec = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
        TSeqPos num_ns = 0;
        for (size_t i = 0; i < vec.size(); i++) {
            try {
                if (vec[i] == 'N' && !vec.IsInGap(i)) {
                    num_ns++;
                }
            } catch (CException& e2) {
                //bad character
            }
        }
        pct_n = (num_ns * 100) / bsh.GetBioseqLength();
    } catch (CException& e) {
        pct_n = 100;
    }
*/
    return bsh.GetBioseqLength() ? count * 100 / bsh.GetBioseqLength() : 100;
}
 
static
bool s_GetFlankingGapTypes(const CSeq_inst& inst, CSeq_gap::TType& fst, CSeq_gap::TType& lst)
{
    CSeq_gap::TType first = CSeq_gap::eType_unknown;
    CSeq_gap::TType last = CSeq_gap::eType_unknown;
    bool is_first = true;
 
    if ( inst.CanGetExt()  &&  inst.GetExt().IsDelta() ) {
        ITERATE(CDelta_ext::Tdata, iter, inst.GetExt().GetDelta().Get()) {
            if ( (*iter)->IsLoc() ) {
                return false;
            }
            if ( (*iter)->IsLiteral() ) {
                const CSeq_literal& lit = (*iter)->GetLiteral();
                if (lit.IsSetSeq_data() && lit.GetSeq_data().IsGap()) {
                    const CSeq_gap& gap = lit.GetSeq_data().GetGap();
                    CSeq_gap::TType gaptype = CSeq_gap::eType_unknown;
                    if (gap.IsSetType()) {
                        gaptype = gap.GetType();
                    }
                    if (is_first) {
                        first = gaptype;
                    } else {
                        last = gaptype;
                    }
                } else {
                    last = CSeq_gap::eType_unknown;
                }
            }
            is_first = false;
        }
    }
    fst = first;
    lst = last;
    return true;
}
 
static bool s_WillReportTerminalGap(const CBioseq& seq, CBioseq_Handle bsh)
{
    if (!seq.IsSetInst() || !seq.GetInst().IsSetRepr()) {
        return false;
    }
    if (!seq.GetInst().IsSetMol() || seq.GetInst().GetMol() == CSeq_inst::eMol_aa) {
        return false;
    }
    CSeq_inst::TRepr repr = seq.GetInst().GetRepr();
 
    if (repr != CSeq_inst::eRepr_delta) {
        return false;
    }
 
    if ( !bsh ) {
        return false;
    }
 
    if (!seq.GetInst().IsSetLength() || seq.GetInst().GetLength() < 10) {
        return false;
    }
 
    if (!ShouldCheckForNsAndGap(bsh)) {
        return false;
    }
 
    return true;
}
 
 
static optional<int> s_MaxSeqStretchIfLessThanThreshold(const CSeqVector& vec, int threshold)
{
    int max_stretch = 0;
    auto IsN = [](char c) { return c == 'N'; };
 
    for (auto begin_it = find_if_not(begin(vec), end(vec), IsN);
         begin_it != end(vec);) {
        auto distanceToEnd = distance(begin_it, end(vec));
        // check a sequence interval no longer than the threshold length
        auto interval = (distanceToEnd > threshold) ? threshold : distanceToEnd;
        auto end_it = find_if(begin_it, next(begin_it, interval), IsN);
        const auto current_stretch = distance(begin_it, end_it);
        if (current_stretch >= threshold) { // No Ns in the interval
            return {};
        }
 
        if (current_stretch > max_stretch) {
            max_stretch = current_stretch;
        }
        begin_it = find_if_not(end_it, end(vec), IsN);
    }
    return max_stretch;
}
 
 
void CValidError_bioseq::ValidateNsAndGaps(const CBioseq& seq)
{
    if (!seq.IsSetInst() || !seq.GetInst().IsSetRepr()) {
        // can't check if no Inst or Repr
        return;
    }
    if (!seq.GetInst().IsSetMol() || seq.GetInst().GetMol() == CSeq_inst::eMol_aa) {
        // don't check proteins here
        return;
    }
    CSeq_inst::TRepr repr = seq.GetInst().GetRepr();
 
    // only check for raw or for delta sequences that are delta lit only
    if (repr == CSeq_inst::eRepr_virtual || repr == CSeq_inst::eRepr_map) {
        return;
    }
 
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    if ( !bsh ) {
        // no check if Bioseq not in scope
        return;
    }
 
    try {
        CSeqVector vec = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
 
        if (IsAllNs(vec)) {
            PostErr(m_Imp.IsPDB() ? eDiag_Warning : eDiag_Critical, eErr_SEQ_INST_AllNs, "Sequence is all Ns", seq);
            return;
        }
 
        // don't bother checking if length is less than 10
        if (!seq.IsSetInst() || !seq.GetInst().IsSetRepr()
            || !seq.GetInst().IsSetLength() || seq.GetInst().GetLength() < 10) {
            return;
        }
 
        if (const auto oMaxLength = s_MaxSeqStretchIfLessThanThreshold(vec, 10); oMaxLength.has_value()) {
            PostErr(eDiag_Error, eErr_SEQ_INST_ContigsTooShort,
                    "Maximum contig length is " + NStr::IntToString(*oMaxLength) + " bases", seq);
        }
 
        EBioseqEndIsType begin_n = eBioseqEndIsType_None;
        EBioseqEndIsType begin_gap = eBioseqEndIsType_None;
        EBioseqEndIsType end_n = eBioseqEndIsType_None;
        EBioseqEndIsType end_gap = eBioseqEndIsType_None;
        bool begin_ambig = false, end_ambig = false;
        CSeq_gap::TType fst = CSeq_gap::eType_unknown;
        CSeq_gap::TType lst = CSeq_gap::eType_unknown;
        if (ShouldCheckForNsAndGap(bsh) && x_IsDeltaLitOnly(seq.GetInst())) {
            CheckBioseqEndsForNAndGap(vec, begin_n, begin_gap, end_n, end_gap, begin_ambig, end_ambig);
            s_GetFlankingGapTypes(seq.GetInst(), fst, lst);
        }
 
        bool is_circular = false;
        if (bsh.IsSetInst_Topology() && bsh.GetInst_Topology() == CSeq_inst::eTopology_circular) {
            is_circular = true;
        }
        EDiagSev sev;
        if (begin_n != eBioseqEndIsType_None) {
            sev = GetBioseqEndWarning(seq, is_circular, begin_n);
            PostErr(sev, eErr_SEQ_INST_TerminalNs, "N at beginning of sequence", seq);
        } else if (begin_gap != eBioseqEndIsType_None && fst != CSeq_gap::eType_contamination) {
            sev = GetBioseqEndWarning(seq, is_circular, begin_gap);
            PostErr (sev, eErr_SEQ_INST_TerminalGap, "Gap at beginning of sequence", seq);
        }
 
        if (end_n != eBioseqEndIsType_None) {
            sev = GetBioseqEndWarning(seq, is_circular, end_n);
            PostErr(sev, eErr_SEQ_INST_TerminalNs, "N at end of sequence", seq);
        } else if (end_gap != eBioseqEndIsType_None &&  lst != CSeq_gap::eType_contamination) {
            sev = GetBioseqEndWarning(seq, is_circular, end_gap);
            PostErr (sev, eErr_SEQ_INST_TerminalGap, "Gap at end of sequence", seq);
        }
 
        if (begin_ambig && !s_WillReportTerminalGap(seq, bsh)) {
            PostErr(eDiag_Info, eErr_SEQ_INST_HighNpercent5Prime,
                "Sequence has more than 5 Ns in the first 10 bases or more than 15 Ns in the first 50 bases",
                seq);
        }
        if (end_ambig && !s_WillReportTerminalGap(seq, bsh)) {
            PostErr(eDiag_Info, eErr_SEQ_INST_HighNpercent3Prime,
                "Sequence has more than 5 Ns in the last 10 bases or more than 15 Ns in the last 50 bases",
                seq);
        }
 
        // don't check N content for patent sequences
        if (SeqIsPatent(seq)) {
            return;
        }
 
        // if TSA, check for percentage of Ns and max stretch of Ns
        if (IsBioseqTSA(seq, m_Scope)) {
            ReportBadAssemblyGap (seq);
            if (!HasAssemblyOrNullGap(seq)) {
                bool n5 = false;
                bool n3 = false;
                TSeqPos num_ns = 0, max_stretch = 0;
                x_CalculateNsStretchAndTotal(vec, num_ns, max_stretch, n5, n3);
 
                int pct_n = (num_ns * 100) / seq.GetLength();
                if (pct_n > 10) {
                    PostErr (eDiag_Warning, eErr_SEQ_INST_HighNContentPercent,
                            "Sequence contains " + NStr::IntToString(pct_n) + " percent Ns", seq);
                }
 
                if (max_stretch >= 15) {
                    PostErr (eDiag_Warning, eErr_SEQ_INST_HighNContentStretch,
                            "Sequence has a stretch of " + NStr::IntToString(max_stretch) + " Ns", seq);
                } else {
                    if (n5) {
                        PostErr (eDiag_Warning, eErr_SEQ_INST_HighNcontent5Prime,
                                "Sequence has a stretch of at least 10 Ns within the first 20 bases", seq);
                    }
                    if (n3) {
                        PostErr (eDiag_Warning, eErr_SEQ_INST_HighNcontent3Prime,
                                "Sequence has a stretch of at least 10 Ns within the last 20 bases", seq);
                    }
                }
            }
        } else {
            // not TSA, just check for really high N percent
            int pct_n = PctNs(bsh);
            if (pct_n > 50) {
                PostErr (eDiag_Warning, eErr_SEQ_INST_HighNContentPercent,
                            "Sequence contains " + NStr::IntToString(pct_n) + " percent Ns", seq);
            }
        }
 
        if (!m_Imp.IsRefSeqConventions() && !IsRefSeq(seq) && !IsEmblOrDdbj(seq)) {
            if (IsWGS(bsh)) {
                ReportBadWGSGap(seq);
            } else if (IsBioseqTSA(seq, m_Scope)) {
                ReportBadTSAGap(seq);
            } else if (m_Imp.IsGenomeSubmission()) {
                ReportBadGenomeGap(seq);
            }
        }
    } catch ( exception& ) {
        // just ignore, and continue with the validation process.
    }
}
 
void CValidError_bioseq::GapByGapInst (const CBioseq& seq)
{
    // rough measure of where exception occurs - triggered by certain conditions set up in unit_test_validator
    int errPt = 0;
 
    try {
 
        errPt++;
 
        if (!seq.IsSetInst() || !seq.GetInst().IsSetRepr()) {
            // can't check if no Inst or Repr
            return;
        }
        if (!seq.GetInst().IsSetMol() || seq.GetInst().GetMol() == CSeq_inst::eMol_aa) {
            // don't check proteins here
            return;
        }
        CSeq_inst::TRepr repr = seq.GetInst().GetRepr();
 
        // only check for raw or for delta sequences that are delta lit only
        if (repr == CSeq_inst::eRepr_virtual || repr == CSeq_inst::eRepr_map) {
            return;
        }
 
        CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
        if ( !bsh ) {
            // no check if Bioseq not in scope
            return;
        }
 
        errPt++;
 
        vector<TSeqPos> gapPositions;
 
        SSeqMapSelector sel;
 
        sel.SetFlags(CSeqMap::fFindGap).SetResolveCount(1);
 
        for (CSeqMap_CI gap_it(bsh, sel); gap_it; ++gap_it) {
 
            TSeqPos gp_start = gap_it.GetPosition();
            TSeqPos gp_end = gap_it.GetEndPosition() - 1;
 
            gapPositions.push_back(gp_start);
            gapPositions.push_back(gp_end);
 
            // cout << "gap start: " << gp_start << ", end: " << gp_end << endl;
        }
 
        errPt++;
 
        vector<TSeqPos> featPositions;
 
        for (CFeat_CI feat_it(bsh); feat_it; ++feat_it) {
 
            CSeq_feat_Handle feat = feat_it->GetSeq_feat_Handle();
            CSeqFeatData::ESubtype subtype = feat.GetFeatSubtype();
            if (subtype != CSeqFeatData::eSubtype_gap) continue;
 
            CConstRef<CSeq_loc> feat_loc(&feat_it->GetLocation());
 
            int ft_start = feat_loc->GetStart(eExtreme_Positional);
            int ft_end = feat_loc->GetStop(eExtreme_Positional);
 
            featPositions.push_back(ft_start);
            featPositions.push_back(ft_end);
 
            // cout << "feat start: " << ft_start << ", end: " << ft_end << endl;
        }
 
        errPt++;
 
        int remaininig_gaps = (int) gapPositions.size() / 2;
        int remaining_feats = (int) featPositions.size() / 2;
 
        if (remaininig_gaps < 1 || remaining_feats < 1) {
            return;
        }
 
        int gap_idx = 0;
        int feat_idx = 0;
 
        TSeqPos gap_start = gapPositions[gap_idx];
        gap_idx++;
        TSeqPos gap_end = gapPositions[gap_idx];
        gap_idx++;
        remaininig_gaps--;
 
        TSeqPos feat_start = featPositions[feat_idx];
        feat_idx++;
        TSeqPos feat_end = featPositions[feat_idx];
        feat_idx++;
        remaining_feats--;
 
        errPt++;
 
        while (remaininig_gaps >= 0 && remaining_feats >= 0) {
            if (gap_end < feat_start) {
                if (remaininig_gaps <= 0) {
                    return;
                }
                gap_start = gapPositions[gap_idx];
                gap_idx++;
                gap_end = gapPositions[gap_idx];
                gap_idx++;
                remaininig_gaps--;
            } else if (feat_end < gap_start) {
                if (remaining_feats <= 0) {
                    return;
                }
                feat_start = featPositions[feat_idx];
                feat_idx++;
                feat_end = featPositions[feat_idx];
                feat_idx++;
                remaining_feats--;
            } else {
                // cout << "overlap gap start: " << gap_start << ", end: " << gap_end << ", feat start: " << feat_start << ", end: " << feat_end << endl;
                if (feat_start != gap_start || feat_end != gap_end) {
                    PostErr(eDiag_Warning, eErr_SEQ_INST_InstantiatedGapMismatch, "Gap feature location does not match delta gap coordinates", seq);
                }
                if (remaininig_gaps <= 0) {
                    return;
                }
                gap_start = gapPositions[gap_idx];
                gap_idx++;
                gap_end = gapPositions[gap_idx];
                gap_idx++;
                remaininig_gaps--;
                if (remaining_feats <= 0) {
                    return;
                }
                feat_start = featPositions[feat_idx];
                feat_idx++;
                feat_end = featPositions[feat_idx];
                feat_idx++;
                remaining_feats--;
            }
        }
 
        errPt++;
 
    } catch ( const exception& ) {
        PostErr(eDiag_Warning, eErr_SEQ_INST_InstantiatedGapMismatch,
            string("Exception " + NStr::IntToString(errPt) + " in GapByGapInst"), seq);
    }
}
 
// Assumes that seq is eRepr_raw or eRepr_inst
void CValidError_bioseq::ValidateRawConst(
    const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
    const CEnumeratedTypeValues* tv = CSeq_inst::GetTypeInfo_enum_ERepr();
    const string& rpr = tv->FindName(inst.GetRepr(), true);
 
    if (inst.IsSetFuzz() && (!inst.IsSetSeq_data() || !inst.GetSeq_data().IsGap())) {
        PostErr(eDiag_Error, eErr_SEQ_INST_FuzzyLen,
            "Fuzzy length on " + rpr + " Bioseq", seq);
    }
 
    if (!inst.IsSetLength()  ||  inst.GetLength() == 0) {
        string len = inst.IsSetLength() ?
            NStr::IntToString(inst.GetLength()) : "0";
        PostErr(eDiag_Error, eErr_SEQ_INST_InvalidLen,
                 "Invalid Bioseq length [" + len + "]", seq);
    }
 
    if (inst.GetRepr() == CSeq_inst::eRepr_raw) {
        const CMolInfo* mi = nullptr;
        CSeqdesc_CI mi_desc(m_Scope->GetBioseqHandle(seq), CSeqdesc::e_Molinfo);
        if ( mi_desc ) {
            mi = &(mi_desc->GetMolinfo());
        }
        CMolInfo::TTech tech = mi ? mi->GetTech() : CMolInfo::eTech_unknown;
        if (tech == CMolInfo::eTech_htgs_2  &&
            !GraphsOnBioseq(seq)  &&
            !x_IsActiveFin(seq)) {
            PostErr(eDiag_Warning, eErr_SEQ_INST_BadHTGSeq,
                "HTGS 2 raw seq has no gaps and no graphs", seq);
        }
    }
 
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
 
    CSeq_data::E_Choice seqtyp = inst.IsSetSeq_data() ?
        inst.GetSeq_data().Which() : CSeq_data::e_not_set;
    if (seqtyp != CSeq_data::e_Gap) {
        switch (seqtyp) {
        case CSeq_data::e_Iupacna:
        case CSeq_data::e_Ncbi2na:
        case CSeq_data::e_Ncbi4na:
        case CSeq_data::e_Ncbi8na:
        case CSeq_data::e_Ncbipna:
            if (inst.IsAa()) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidAlphabet,
                         "Using a nucleic acid alphabet on a protein sequence",
                         seq);
                return;
            }
            break;
        case CSeq_data::e_Iupacaa:
        case CSeq_data::e_Ncbi8aa:
        case CSeq_data::e_Ncbieaa:
        case CSeq_data::e_Ncbipaa:
        case CSeq_data::e_Ncbistdaa:
            if (inst.IsNa()) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidAlphabet,
                         "Using a protein alphabet on a nucleic acid",
                         seq);
                return;
            }
            break;
        case CSeq_data::e_Gap:
            break;
        default:
            PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidAlphabet,
                     "Sequence alphabet not set",
                     seq);
            return;
        }
 
        bool check_alphabet = false;
        unsigned int factor = 1;
        switch (seqtyp) {
        case CSeq_data::e_Iupacaa:
        case CSeq_data::e_Iupacna:
        case CSeq_data::e_Ncbieaa:
        case CSeq_data::e_Ncbistdaa:
            check_alphabet = true;
            break;
        case CSeq_data::e_Ncbi8na:
        case CSeq_data::e_Ncbi8aa:
            break;
        case CSeq_data::e_Ncbi4na:
            factor = 2;
            break;
        case CSeq_data::e_Ncbi2na:
            factor = 4;
            break;
        case CSeq_data::e_Ncbipna:
            factor = 5;
            break;
        case CSeq_data::e_Ncbipaa:
            factor = 21;
            break;
        default:
            // Logically, should not occur
            PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidAlphabet,
                     "Sequence alphabet not set",
                     seq);
            return;
        }
        TSeqPos calc_len = inst.IsSetLength() ? inst.GetLength() : 0;
        if (calc_len % factor) {
            calc_len += factor;
        }
        calc_len /= factor;
 
        string s_len = NStr::UIntToString(inst.GetLength());
 
        size_t data_len = GetDataLen(inst);
        string data_len_str = NStr::NumericToString(data_len * factor);
        if (calc_len > data_len) {
            PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
                     "Bioseq.seq_data too short [" + data_len_str +
                     "] for given length [" + s_len + "]", seq);
            return;
        } else if (calc_len < data_len) {
            PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
                     "Bioseq.seq_data is larger [" + data_len_str +
                     "] than given length [" + s_len + "]", seq);
        }
 
        if (check_alphabet) {
            unsigned int trailingX = 0;
            size_t dashes = 0;
            bool leading_x = false, found_lower = false, cds_5_prime = false;
 
            CConstRef<CSeqVector> sv = MakeSeqVectorForResidueCounting(bsh);
            CSeqVector sv_res = bsh.GetSeqVector(CBioseq_Handle::eCoding_Ncbi);
 
            size_t bad_cnt = 0;
            TSeqPos pos = 1;
            for ( CSeqVector_CI sv_iter(*sv), sv_res_iter(sv_res); (sv_iter) && (sv_res_iter); ++sv_iter, ++sv_res_iter ) {
                CSeqVector::TResidue res = *sv_iter;
                CSeqVector::TResidue n_res = *sv_res_iter;
                if ( !IsResidue(n_res) ) {
                    if (res == 'U' && bsh.IsSetInst_Mol() && bsh.GetInst_Mol() == CSeq_inst::eMol_rna) {
                        // U is ok for RNA
                    }
                    else if (res == '*' && bsh.IsAa()) {
                        trailingX = 0;
                    } else if (res == '-' && bsh.IsAa()) {
                        dashes++;
                        PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                                "Invalid residue [" + NStr::UIntToString(res)
                                + "] at position [" + NStr::UIntToString(pos) + "]",
                                seq);
                    } else {
                        if ( ! IsResidue(res)) {
                            if ( ++bad_cnt > 10 ) {
                                PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                                    "More than 10 invalid residues. Checking stopped",
                                    seq);
                                return;
                            } else {
                                PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                                        "Invalid residue [" + NStr::UIntToString(res)
                                        + "] at position [" + NStr::UIntToString(pos) + "]",
                                        seq);
                            }
                        } else if (islower (res)) {
                            found_lower = true;
                        } else {
                            string msg = "Invalid";
                            if (seq.IsNa() && strchr ("EFIJLOPQXZ", res) != NULL) {
                                msg += " nucleotide";
                            } else if (seq.IsNa() && res == 'U') {
                                msg += " nucleotide";
                            }
                            msg += " residue ";
                            if (seqtyp == CSeq_data::e_Ncbistdaa) {
                                msg += "[" + NStr::UIntToString(res) + "]";
                            } else {
                                msg += "'";
                                msg += res;
                                msg += "'";
                            }
                            msg += " at position [" + NStr::UIntToString(pos) + "]";
 
                            PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                                msg, seq);
                        }
                    }
                } else if ( res == '-' || sv->IsInGap(pos - 1) ) {
                    dashes++;
                } else if ( res == '*') {
                    trailingX = 0;
                } else if ( res == 'X' ) {
                    trailingX++;
                    if (pos == 1) {
                        leading_x = true;
                    }
                } else if (!isalpha (res)) {
                    string msg = "Invalid residue [";
                    msg += res;
                    msg += "] in position [" + NStr::UIntToString(pos) + "]";
                    PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                        msg, seq);
                } else {
                    trailingX = 0;
                }
                ++pos;
            }
 
            bool gap_at_start = HasBadProteinStart(*sv);
            size_t terminations = CountProteinStops(*sv);
 
            // only show leading or trailing X if product of NNN in nucleotide
            if (seq.IsAa() && (leading_x || trailingX > 0)) {
                CBioseq_Handle bsh = m_Scope->GetBioseqHandle (seq);
                const CSeq_feat* cds = GetCDSForProduct(bsh);
                if (cds && cds->IsSetLocation()) {
                    const CSeq_loc& cdsloc = cds->GetLocation();
                    size_t dna_len = GetLength (cdsloc, m_Scope);
                    if (dna_len > 5) {
                        string cds_seq = GetSequenceStringFromLoc (cdsloc, *m_Scope);
                        if (cds->GetData().GetCdregion().IsSetFrame()) {
                            if (cds->GetData().GetCdregion().GetFrame() == 2) {
                                cds_seq = cds_seq.substr(1);
                            } else if (cds->GetData().GetCdregion().GetFrame() == 3) {
                                cds_seq = cds_seq.substr(2);
                            }
                        }
 
                        if (!NStr::StartsWith (cds_seq, "NNN")) {
                            leading_x = false;
                        }
                        if (cds_seq.length() >= 3) {
                            string lastcodon = cds_seq.substr(cds_seq.length() - 3);
                            if (!NStr::StartsWith(lastcodon, "NNN")) {
                                trailingX = 0;
                            }
                        }
                    }
                    // only need to calculate cds_5_prime to set severity for subsequent eErr_SEQ_INST_LeadingX message
                    if (leading_x) {
                        if (cdsloc.IsPartialStart(eExtreme_Biological)) {
                            cds_5_prime = true;
                        }
                    }
                }
            }
 
            if (leading_x) {
                EDiagSev sev = eDiag_Warning;
                if (cds_5_prime) {
                    sev = eDiag_Info;
                }
                PostErr (sev, eErr_SEQ_INST_LeadingX,
                         "Sequence starts with leading X", seq);
            }
 
            if ( trailingX > 0 && !SuppressTrailingXMsg(seq) ) {
                // Suppress if cds ends in "*" or 3' partial
                string msg = "Sequence ends in " +
                    NStr::IntToString(trailingX) + " trailing X";
                if ( trailingX > 1 ) {
                    msg += "s";
                }
                PostErr(eDiag_Warning, eErr_SEQ_INST_TrailingX, msg, seq);
            }
 
            if (found_lower) {
                PostErr (eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                         "Sequence contains lower-case characters", seq);
            }
 
            if (terminations > 0 || dashes > 0) {
                // Post error indicating terminations found in protein sequence
                // if possible, get gene and protein names
                CBioseq_Handle bsh = m_Scope->GetBioseqHandle (seq);
                // First get gene label
                string gene_label;
                try {
                    const CSeq_feat* cds = GetCDSForProduct(bsh);
                    if (cds) {
                        CConstRef<CSeq_feat> gene = m_Imp.GetCachedGene(cds);
                        if (gene && gene->IsSetData() && gene->GetData().IsGene()) {
                            gene->GetData().GetGene().GetLabel(&gene_label);
                        }
                    }
                } catch (...) {
                }
                // get protein label
                string protein_label;
                try {
                    CCacheImpl::SFeatKey prot_key(
                        CSeqFeatData::e_Prot, CCacheImpl::kAnyFeatSubtype, bsh);
                    const CCacheImpl::TFeatValue & prots =
                        GetCache().GetFeatFromCache(prot_key);
                    if( ! prots.empty() ) {
                        const CSeqFeatData_Base::TProt & first_prot =
                            prots[0].GetData().GetProt();
                        if( ! RAW_FIELD_IS_EMPTY_OR_UNSET(first_prot, Name) ) {
                            protein_label = first_prot.GetName().front();
                    }
                    }
                } catch (const CException& ) {
                } catch (const std::exception& ) {
                }
 
                if (NStr::IsBlank(gene_label)) {
                    gene_label = "gene?";
                }
                if (NStr::IsBlank(protein_label)) {
                    protein_label = "prot?";
                }
 
                if (dashes > 0) {
                    if (gap_at_start && dashes == 1) {
                      PostErr (eDiag_Error, eErr_SEQ_INST_BadProteinStart,
                               "gap symbol at start of protein sequence (" + gene_label + " - " + protein_label + ")",
                               seq);
                    } else if (gap_at_start) {
                      PostErr (eDiag_Error, eErr_SEQ_INST_BadProteinStart,
                               "gap symbol at start of protein sequence (" + gene_label + " - " + protein_label + ")",
                               seq);
                      PostErr (eDiag_Error, eErr_SEQ_INST_GapInProtein,
                               "[" + NStr::SizetToString (dashes - 1) + "] internal gap symbols in protein sequence (" + gene_label + " - " + protein_label + ")",
                               seq);
                    } else {
                      PostErr (eDiag_Error, eErr_SEQ_INST_GapInProtein,
                               "[" + NStr::SizetToString (dashes) + "] internal gap symbols in protein sequence (" + gene_label + " - " + protein_label + ")",
                               seq);
                    }
                }
 
                if (terminations > 0) {
                    string msg = "[" + NStr::SizetToString(terminations) + "] termination symbols in protein sequence";
                    msg += " (" + gene_label + " - " + protein_label + ")";
                    const CSeq_feat* cds = GetCDSForProduct(bsh);
                    if (cds) {
                        PostErr(eDiag_Error, eErr_SEQ_INST_StopInProtein, msg, *cds);
                    } else {
                        PostErr(eDiag_Error, eErr_SEQ_INST_StopInProtein, msg, seq);
                    }
                }
            }
        }
 
        bool is_wgs = IsWGS(bsh);
 
        if (seq.IsNa() && seq.GetInst().GetRepr() == CSeq_inst::eRepr_raw) {
            // look for runs of Ns and gap characters
            bool has_gap_char = false;
            size_t run_len = 0;
            TSeqPos start_pos = 0;
            TSeqPos pos = 1;
            CSeqVector sv = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
            const size_t run_len_cutoff = ( is_wgs ? 20 : 100 );
            for ( CSeqVector_CI sv_iter(sv); (sv_iter); ++sv_iter, ++pos ) {
                CSeqVector::TResidue res = *sv_iter;
                switch(res) {
                case 'N':
                    if (run_len == 0) {
                        start_pos = pos;
                    }
                    run_len++;
                    break;
                case '-':
                    has_gap_char = true;
                    ///////////////////////////////////
                    ////////// FALL-THROUGH! //////////
                    ///////////////////////////////////
                default:
                    if (run_len >= run_len_cutoff && start_pos > 1)
                    {
                        PostErr (eDiag_Warning, eErr_SEQ_INST_InternalNsInSeqRaw,
                                 "Run of " + NStr::SizetToString (run_len) + " Ns in raw sequence starting at base "
                                 + NStr::IntToString (start_pos),
                                 seq);
                    }
                    run_len = 0;
                    break;
                    }
                }
            if (has_gap_char) {
                PostErr (eDiag_Warning, eErr_SEQ_INST_InternalGapsInSeqRaw,
                         "Raw nucleotide should not contain gap characters", seq);
            }
        }
    }
}
 
 
//LCOV_EXCL_START
//part of segset validation, no longer used
// Assumes seq is eRepr_seg or eRepr_ref
void CValidError_bioseq::ValidateSegRef(const CBioseq& seq)
{
    string id_test_label;
    seq.GetLabel(&id_test_label, CBioseq::eContent);
 
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    const CSeq_inst& inst = seq.GetInst();
 
    // Validate extension data -- wrap in CSeq_loc_mix for convenience
    CRef<CSeq_loc> loc = GetLocFromSeq(seq);
    if (loc) {
        if (inst.IsSetRepr() && inst.GetRepr() == CSeq_inst::eRepr_seg) {
            m_Imp.ValidateSeqLoc(*loc, bsh, true, "Segmented Bioseq", seq);
        }
 
        // Validate Length
        try {
            TSeqPos loclen = GetLength(*loc, m_Scope);
            TSeqPos seqlen = inst.IsSetLength() ? inst.GetLength() : 0;
            if (seqlen > loclen) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
                    "Bioseq.seq_data too short [" + NStr::IntToString(loclen) +
                    "] for given length [" + NStr::IntToString(seqlen) + "]",
                    seq);
            } else if (seqlen < loclen) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
                    "Bioseq.seq_data is larger [" + NStr::IntToString(loclen) +
                    "] than given length [" + NStr::IntToString(seqlen) + "]",
                    seq);
            }
        } catch (const CObjmgrUtilException&) {
            ERR_POST_X(6, Critical << "Unable to calculate length: ");
        }
    }
 
    // Check for multiple references to the same Bioseq
    if (inst.IsSetExt()  &&  inst.GetExt().IsSeg()) {
        const list< CRef<CSeq_loc> >& locs = inst.GetExt().GetSeg().Get();
        ITERATE(list< CRef<CSeq_loc> >, i1, locs) {
           if (!IsOneBioseq(**i1, m_Scope)) {
                continue;
            }
            const CSeq_id& id1 = GetId(**i1, m_Scope);
            list< CRef<CSeq_loc> >::const_iterator i2 = i1;
            for (++i2; i2 != locs.end(); ++i2) {
                if (!IsOneBioseq(**i2, m_Scope)) {
                    continue;
                }
                const CSeq_id& id2 = GetId(**i2, m_Scope);
                if (IsSameBioseq(id1, id2, m_Scope)) {
                    string sid;
                    id1.GetLabel(&sid);
                    if ((**i1).IsWhole()  &&  (**i2).IsWhole()) {
                        PostErr(eDiag_Error,
                            eErr_SEQ_INST_DuplicateSegmentReferences,
                            "Segmented sequence has multiple references to " +
                            sid, seq);
                    } else {
                        PostErr(eDiag_Warning,
                            eErr_SEQ_INST_DuplicateSegmentReferences,
                            "Segmented sequence has multiple references to " +
                            sid + " that are not SEQLOC_WHOLE", seq);
                    }
                }
            }
        }
    }
 
    // Check that partial sequence info on sequence segments is consistent with
    // partial sequence info on sequence -- aa  sequences only
    int partial = SeqLocPartialCheck(*loc, m_Scope);
    if (seq.IsAa()) {
        bool got_partial = false;
        FOR_EACH_DESCRIPTOR_ON_BIOSEQ (sd, seq) {
            if (!(*sd)->IsMolinfo() || !(*sd)->GetMolinfo().IsSetCompleteness()) {
                continue;
            }
 
            switch ((*sd)->GetMolinfo().GetCompleteness()) {
                case CMolInfo::eCompleteness_partial:
                    got_partial = true;
                    if (!partial) {
                        PostErr (eDiag_Error, eErr_SEQ_INST_PartialInconsistent,
                                 "Complete segmented sequence with MolInfo partial", seq);
                    }
                    break;
                case CMolInfo::eCompleteness_no_left:
                    if (!(partial & eSeqlocPartial_Start) || (partial & eSeqlocPartial_Stop)) {
                        PostErr (eDiag_Error, eErr_SEQ_INST_PartialInconsistent,
                                 "No-left inconsistent with segmented SeqLoc",
                                 seq);
                    }
                    got_partial = true;
                    break;
                case CMolInfo::eCompleteness_no_right:
                    if (!(partial & eSeqlocPartial_Stop) || (partial & eSeqlocPartial_Start)) {
                        PostErr (eDiag_Error, eErr_SEQ_INST_PartialInconsistent,
                                 "No-right inconsistent with segmented SeqLoc",
                                 seq);
                    }
                    got_partial = true;
                    break;
                case CMolInfo::eCompleteness_no_ends:
                    if (!(partial & eSeqlocPartial_Start) || !(partial & eSeqlocPartial_Stop)) {
                        PostErr (eDiag_Error, eErr_SEQ_INST_PartialInconsistent,
                                 "No-ends inconsistent with segmented SeqLoc",
                                 seq);
                    }
                    got_partial = true;
                    break;
                default:
                    break;
            }
        }
        if (!got_partial) {
            PostErr(eDiag_Error, eErr_SEQ_INST_PartialInconsistent,
                "Partial segmented sequence without MolInfo partial", seq);
        }
    }
}
//LCOV_EXCL_STOP
 
 
static int s_MaxNsInSeqLitForTech (CMolInfo::TTech tech)
{
    int max_ns = -1;
 
    switch (tech) {
        case CMolInfo::eTech_htgs_1:
        case CMolInfo::eTech_htgs_2:
        case CMolInfo::eTech_composite_wgs_htgs:
            max_ns = 80;
            break;
        case CMolInfo::eTech_wgs:
            max_ns = 19;
            break;
        default:
            max_ns = 99;
            break;
    }
    return max_ns;
}
 
 
static bool s_IsSwissProt (const CBioseq& seq)
{
    FOR_EACH_SEQID_ON_BIOSEQ (it, seq) {
        if ((*it)->IsSwissprot()) {
            return true;
        }
    }
    return false;
}
 
static bool s_LocSortCompare (const CConstRef<CSeq_loc>& q1, const CConstRef<CSeq_loc>& q2)
{
    TIntId cmp = q1->GetId()->CompareOrdered(*(q2->GetId()));
    if (cmp < 0) {
        return true;
    } else if (cmp > 0) {
        return false;
    }
 
    TSeqPos start1 = q1->GetStart(eExtreme_Positional);
    TSeqPos start2 = q2->GetStart(eExtreme_Positional);
    if (start1 < start2) {
        return true;
    } else if (start2 < start1) {
        return false;
    }
 
    TSeqPos stop1 = q1->GetStop(eExtreme_Positional);
    TSeqPos stop2 = q2->GetStop(eExtreme_Positional);
 
    if (stop1 < stop2) {
        return true;
    } else {
        return false;
    }
}
 
 
bool CValidError_bioseq::IsSelfReferential(const CBioseq& seq)
{
    bool rval = false;
 
    if (!seq.IsSetInst() || !seq.GetInst().IsSetExt() ||
        !seq.GetInst().GetExt().IsDelta()) {
        return false;
    }
 
    ITERATE(CDelta_ext::Tdata, sg, seq.GetInst().GetExt().GetDelta().Get()) {
        if (!(*sg)) {
            // skip NULL element
        } else if ((*sg)->IsLoc()) {
            const CSeq_id *id = (*sg)->GetLoc().GetId();
            if (id) {
                FOR_EACH_SEQID_ON_BIOSEQ(id_it, seq) {
                    if ((*id_it)->Compare(*id) == CSeq_id::e_YES) {
                        rval = true;
                        break;
                    }
                }
            }
            if (rval) break;
        }
    }
    return rval;
}
 
 
bool HasExcludedAnnotation(const CSeq_loc& loc, CBioseq_Handle far_bsh)
{
    if (!loc.IsInt()) {
        return false;
    }
 
    TSeqPos stop = loc.GetStop(eExtreme_Positional);
    TSeqPos start = loc.GetStart(eExtreme_Positional);
 
    if (start > 1) {
        CRef<CSeq_loc> far_loc(new CSeq_loc());
        far_loc->SetInt().SetFrom(start - 2);
        far_loc->SetInt().SetTo(start - 1);
        far_loc->SetInt().SetId().Assign(loc.GetInt().GetId());
        CFeat_CI f(far_bsh.GetScope(), *far_loc);
        if (f) {
            return true;
        }
    }
    if (stop < far_bsh.GetBioseqLength() - 2) {
        CRef<CSeq_loc> far_loc(new CSeq_loc());
        far_loc->SetInt().SetFrom(stop + 1);
        far_loc->SetInt().SetTo(stop + 2);
        far_loc->SetInt().SetId().Assign(loc.GetInt().GetId());
        CFeat_CI f(far_bsh.GetScope(), *far_loc);
        if (f) {
            return true;
        }
    }
    return false;
}
 
 
void CValidError_bioseq::ValidateDeltaLoc
(const CSeq_loc& loc,
 const CBioseq& seq,
 TSeqPos& len)
{
    if (loc.IsWhole()) {
        PostErr (eDiag_Error, eErr_SEQ_INST_WholeComponent,
                 "Delta seq component should not be of type whole", seq);
    }
 
    const CSeq_id *id = loc.GetId();
    if (id) {
        if (id->IsGi() && loc.GetId()->GetGi() == ZERO_GI) {
            PostErr (eDiag_Critical, eErr_SEQ_INST_DeltaComponentIsGi0,
                     "Delta component is gi|0", seq);
        }
        if (!loc.IsWhole()
            && (id->IsGi()
                || id->IsGenbank()
                || id->IsEmbl()
                || id->IsDdbj() || id->IsTpg()
                || id->IsTpe()
                || id->IsTpd()
                || id->IsOther())) {
            TSeqPos stop = loc.GetStop(eExtreme_Positional);
            try {
                CBioseq_Handle bsh = m_Scope->GetBioseqHandle(*id, CScope::eGetBioseq_All);
                if (bsh) {
                    TSeqPos seq_len = bsh.GetBioseqLength();
                    if (seq_len <= stop) {
                        string id_label = id->AsFastaString();
                        PostErr (eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
                                 "Seq-loc extent (" + NStr::IntToString (stop + 1)
                                 + ") greater than length of " + id_label
                                 + " (" + NStr::IntToString(seq_len) + ")",
                                seq);
                    }
                    if (!m_Imp.IsRefSeq() && IsWGS(seq) && HasExcludedAnnotation(loc, bsh)) {
                        string id_label = id->AsFastaString();
                        PostErr(eDiag_Error, eErr_SEQ_INST_FarLocationExcludesFeatures,
                                "Scaffold points to some but not all of " +
                                id_label + ", excluded portion contains features", seq);
                    }
                } else {
                    PostErr(eDiag_Error, eErr_GENERIC_DeltaSeqError,
                        "Unable to find far delta sequence component", seq);
                }
            } catch (const CException& ) {
            } catch (const std::exception& ) {
            }
        }
    }
 
    try {
        if (seq.IsSetInst ()) {
            const CSeq_inst& inst = seq.GetInst();
            TSeqPos loc_len = GetLength(loc, m_Scope);
            if (loc_len == numeric_limits<TSeqPos>::max()) {
                PostErr (eDiag_Error, eErr_SEQ_INST_SeqDataLenWrong,
                         "-1 length on seq-loc of delta seq_ext", seq);
                string loc_str;
                loc.GetLabel(&loc_str);
                if ( loc_str.empty() ) {
                    loc_str = "?";
                }
                if (x_IsDeltaLitOnly(inst)) {
                    PostErr(eDiag_Warning, eErr_SEQ_INST_SeqLocLength,
                        "Short length (-1) on seq-loc (" + loc_str + ") of delta seq_ext", seq);
                }
            } else {
                len += loc_len;
            }
            if ( loc_len <= 10 ) {
                string loc_str;
                loc.GetLabel(&loc_str);
                if ( loc_str.empty() ) {
                    loc_str = "?";
                }
                if (x_IsDeltaLitOnly(inst)) {
                    PostErr(eDiag_Warning, eErr_SEQ_INST_SeqLocLength,
                        "Short length (" + NStr::SizetToString(loc_len) +
                        ") on seq-loc (" + loc_str + ") of delta seq_ext", seq);
                }
            }
        }
 
    } catch (const CObjmgrUtilException&) {
        string loc_str;
        loc.GetLabel(&loc_str);
        if ( loc_str.empty() ) {
            loc_str = "?";
        }
        PostErr(eDiag_Error, eErr_SEQ_INST_SeqDataLenWrong,
            "No length for Seq-loc (" + loc_str + ") of delta seq-ext",
            seq);
    }
}
 
 
static size_t s_GetDeltaLen (const CDelta_seq& seg, CScope* scope)
{
    if (seg.IsLiteral()) {
        return seg.GetLiteral().GetLength();
    } else if (seg.IsLoc()) {
        return GetLength (seg.GetLoc(), scope);
    } else {
        return 0;
    }
}
 
 
static string linkEvStrings [] = {
    "paired-ends",
    "align genus",
    "align xgenus",
    "align trnscpt",
    "within clone",
    "clone contig",
    "map",
    "strobe",
    "unspecified",
    "pcr",
    "proximity ligation",
    "other",
    "UNKNOWN VALUE"
};
 
/*bsv
static bool s_IsGapComponent (const CDelta_seq& seg)
{
    if (! seg.IsLiteral()) return false;
    const CSeq_literal& lit = seg.GetLiteral();
    if (! lit.IsSetSeq_data()) return true;
    if  (lit.GetSeq_data().IsGap() && lit.GetLength() > 0) return true;
    return false;
}
*/
 
static bool s_IsUnspecified(const CSeq_gap& gap)
{
    bool is_unspec = false;
    ITERATE(CSeq_gap::TLinkage_evidence, ev_itr, gap.GetLinkage_evidence()) {
        const CLinkage_evidence & evidence = **ev_itr;
        if (!evidence.CanGetType()) continue;
        int linktype = evidence.GetType();
        if (linktype == 8) {
            is_unspec = true;
        }
    }
    return is_unspec;
}
 
 
bool CValidError_bioseq::x_IgnoreEndGap(CBioseq_Handle bsh, CSeq_gap::TType gap_type)
{
    // always ignore for circular sequences
    if (bsh.GetInst().IsSetTopology() &&
        bsh.GetInst().GetTopology() == CSeq_inst::eTopology_circular) {
        return true;
    }
 
    // ignore if location is genomic and gap is of certain type
    if (gap_type != CSeq_gap::eType_centromere &&
        gap_type != CSeq_gap::eType_telomere &&
        gap_type != CSeq_gap::eType_heterochromatin &&
        gap_type != CSeq_gap::eType_short_arm &&
        gap_type != CSeq_gap::eType_contamination) {
        return false;
    }
 
    CSeqdesc_CI src(bsh, CSeqdesc::e_Source);
    if (src && src->GetSource().IsSetGenome() && src->GetSource().GetGenome() == CBioSource::eGenome_chromosome) {
        return true;
    } else {
        return false;
    }
}
 
 
// Assumes seq is a delta sequence
void CValidError_bioseq::ValidateDelta(const CBioseq& seq)
{
    const CSeq_inst& inst = seq.GetInst();
 
    // Get CMolInfo and tech used for validating technique and gap positioning
    const CMolInfo* mi = nullptr;
    CSeqdesc_CI mi_desc(m_Scope->GetBioseqHandle(seq), CSeqdesc::e_Molinfo);
    if ( mi_desc ) {
        mi = &(mi_desc->GetMolinfo());
    }
    CMolInfo::TTech tech = mi ? mi->GetTech() : CMolInfo::eTech_unknown;
 
    if (!inst.IsSetExt()  ||  !inst.GetExt().IsDelta()  ||
        inst.GetExt().GetDelta().Get().empty()) {
        PostErr(eDiag_Error, eErr_SEQ_INST_SeqDataLenWrong,
            "No CDelta_ext data for delta Bioseq", seq);
    }
 
    bool any_tech_ok = false;
    bool has_gi = false;
    FOR_EACH_SEQID_ON_BIOSEQ (id_it, seq) {
        if (IsNTNCNWACAccession(**id_it)) {
            any_tech_ok = true;
            break;
        } else if ((*id_it)->IsGi()) {
            has_gi = true;
        }
    }
    CBioseq_Handle bsh = m_Scope->GetBioseqHandle(seq);
    if (!any_tech_ok && seq.IsNa()
        && tech != CMolInfo::eTech_htgs_0 && tech != CMolInfo::eTech_htgs_1
        && tech != CMolInfo::eTech_htgs_2 && tech != CMolInfo::eTech_htgs_3
        && tech != CMolInfo::eTech_wgs && tech != CMolInfo::eTech_composite_wgs_htgs
        && tech != CMolInfo::eTech_unknown && tech != CMolInfo::eTech_standard
        && tech != CMolInfo::eTech_htc && tech != CMolInfo::eTech_barcode
        && tech != CMolInfo::eTech_tsa) {
        PostErr(eDiag_Error, eErr_SEQ_INST_BadDeltaSeq,
            "Delta seq technique should not be [" + NStr::IntToString(tech) + "]", seq);
    }
 
   // set severity for first / last gap error
    TSeqPos len = 0;
    TSeqPos seg = 0;
    bool last_is_gap = false;
    int prev_gap_linkage = -1;
    CSeq_gap::TType prev_gap_type = CSeq_gap::eType_unknown;
    int gap_linkage = -1;
    CSeq_gap::TType gap_type = CSeq_gap::eType_unknown;
    size_t num_gaps = 0;
    size_t num_adjacent_gaps = 0;
    bool non_interspersed_gaps = false;
    bool first = true;
    int num_gap_known_or_spec = 0;
    int num_gap_unknown_unspec = 0;
 
    vector<CConstRef<CSeq_loc> > delta_locs;
 
    ITERATE(CDelta_ext::Tdata, sg, inst.GetExt().GetDelta().Get()) {
        ++seg;
        if ( !(*sg) ) {
            PostErr(eDiag_Error, eErr_SEQ_INST_SeqDataLenWrong,
                "NULL pointer in delta seq_ext valnode (segment " +
                NStr::IntToString(seg) + ")", seq);
            continue;
        }
        switch ( (**sg).Which() ) {
        case CDelta_seq::e_Loc:
        {
            const CSeq_loc& loc = (**sg).GetLoc();
            CConstRef<CSeq_loc> tmp(&loc);
            delta_locs.push_back (tmp);
 
            ValidateDeltaLoc (loc, seq, len);
 
            if ( !last_is_gap && !first) {
                non_interspersed_gaps = true;
            }
            last_is_gap = false;
            prev_gap_linkage = -1;
            prev_gap_type = CSeq_gap::eType_unknown;
            gap_linkage = CSeq_gap::eType_unknown;
            first = false;
            break;
        }
        case CDelta_seq::e_Literal:
        {
            // The C toolkit code checks for valid alphabet here
            // The C++ object serializaton will not load if invalid alphabet
            // so no check needed here
            const CSeq_literal& lit = (*sg)->GetLiteral();
            TSeqPos start_len = len;
            len += lit.CanGetLength() ? lit.GetLength() : 0;
            if (lit.IsSetSeq_data() && ! lit.GetSeq_data().IsGap()
                && (!lit.IsSetLength() || lit.GetLength() == 0)) {
                PostErr (eDiag_Error, eErr_SEQ_INST_SeqLitDataLength0,
                         "Seq-lit of length 0 in delta chain", seq);
            }
 
            // Check for invalid residues
            if ( lit.IsSetSeq_data() && !lit.GetSeq_data().IsGap() ) {
                if ( !last_is_gap && !first) {
                    non_interspersed_gaps = true;
                }
                last_is_gap = false;
                prev_gap_linkage = -1;
                prev_gap_type = CSeq_gap::eType_unknown;
                const CSeq_data& data = lit.GetSeq_data();
                vector<TSeqPos> badIdx;
                CSeqportUtil::Validate(data, &badIdx);
                const string* ss = nullptr;
                switch (data.Which()) {
                case CSeq_data::e_Iupacaa:
                    ss = &data.GetIupacaa().Get();
                    break;
                case CSeq_data::e_Iupacna:
                    ss = &data.GetIupacna().Get();
                    break;
                case CSeq_data::e_Ncbieaa:
                    ss = &data.GetNcbieaa().Get();
                    break;
                case CSeq_data::e_Ncbistdaa:
                    {
                        const vector<char>& c = data.GetNcbistdaa().Get();
                        ITERATE (vector<TSeqPos>, ci, badIdx) {
                            PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                                "Invalid residue [" +
                                NStr::IntToString((int)c[*ci]) + "] at position [" +
                                NStr::IntToString((*ci) + 1) + "]", seq);
                        }
                        break;
                    }
                default:
                    break;
                }
 
                if ( ss ) {
                    ITERATE (vector<TSeqPos>, it, badIdx) {
                        PostErr(eDiag_Critical, eErr_SEQ_INST_InvalidResidue,
                            "Invalid residue [" +
                            ss->substr(*it, 1) + "] at position [" +
                            NStr::IntToString((*it) + 1) + "]", seq);
                    }
                }
 
                if (mi) {
                    // Count adjacent Ns in Seq-lit
                    int max_ns = s_MaxNsInSeqLitForTech (tech);
                    size_t adjacent_ns = x_CountAdjacentNs(lit);
                    if (max_ns > -1 && adjacent_ns > max_ns) {
                        PostErr(eDiag_Warning, eErr_SEQ_INST_InternalNsInSeqLit,
                                "Run of " + NStr::NumericToString(adjacent_ns) +
                                " Ns in delta component " + NStr::UIntToString(seg) +
                                " that starts at base " + NStr::UIntToString(start_len + 1),
                                seq);
                    }
                }
            } else {
                gap_linkage = -1;
                gap_type = CSeq_gap::eType_unknown;
                if ( lit.IsSetSeq_data() && lit.GetSeq_data().IsGap() ) {
                    const CSeq_data& data = lit.GetSeq_data();
                    if (data.Which() == CSeq_data::e_Gap) {
                        const CSeq_gap& gap = data.GetGap();
 
                        if (gap.IsSetType()) {
                            gap_type = gap.GetType();
                            if (gap_type == CSeq_gap::eType_unknown && s_IsUnspecified(gap)) {
                                num_gap_unknown_unspec++;
                            }
                            else {
                                num_gap_known_or_spec++;
                            }
                        }
                        if(gap.IsSetLinkage())
                            gap_linkage = gap.GetLinkage();
                    }
                }
                if (first  && !x_IgnoreEndGap(bsh, gap_type) && !s_WillReportTerminalGap(seq, bsh)) {
                    EDiagSev sev = eDiag_Error;
                    if (tech != CMolInfo::eTech_htgs_0 && tech != CMolInfo::eTech_htgs_1
                        && tech != CMolInfo::eTech_htgs_2 && tech != CMolInfo::eTech_htgs_3) {
                        sev = eDiag_Warning;
                    }
                    PostErr(sev, eErr_SEQ_INST_BadDeltaSeq,
                            "First delta seq component is a gap", seq);
                }
 
                if(last_is_gap &&
                   (prev_gap_type == gap_type ||
                    prev_gap_linkage != gap_linkage ||
                    gap_linkage != CSeq_gap::eLinkage_unlinked)) {
                        if (prev_gap_type != CSeq_gap::eType_contamination && gap_type != CSeq_gap::eType_contamination) {
                            ++num_adjacent_gaps;
                        }
                    }
 
                if (lit.IsSetSeq_data() && lit.GetSeq_data().IsGap()) {
                    ValidateSeqGap(lit.GetSeq_data().GetGap(), seq);
                } else if (!lit.CanGetLength() || lit.GetLength() == 0) {
                    if (!lit.IsSetFuzz() || !lit.GetFuzz().IsLim() || lit.GetFuzz().GetLim() != CInt_fuzz::eLim_unk) {
                        PostErr(s_IsSwissProt(seq) ? eDiag_Warning : eDiag_Error, eErr_SEQ_INST_SeqLitGapLength0,
                            "Gap of length 0 in delta chain", seq);
                    } else {
                        PostErr(s_IsSwissProt(seq) ? eDiag_Warning : eDiag_Error, eErr_SEQ_INST_SeqLitGapLength0,
                            "Gap of length 0 with unknown fuzz in delta chain", seq);
                    }
                } else if (lit.CanGetLength() && lit.GetLength() != 100) {
                    if (lit.IsSetFuzz()) {
                        PostErr(eDiag_Warning, eErr_SEQ_INST_UnknownLengthGapNot100,
                            "Gap of unknown length should have length 100", seq);
                    }
                }
                last_is_gap = true;
                prev_gap_type = gap_type;
                prev_gap_linkage = gap_linkage;
                ++num_gaps;
            }
            first = false;
            break;
        }
        default:
            PostErr(eDiag_Critical, eErr_SEQ_INST_ExtNotAllowed,
                "CDelta_seq::Which() is e_not_set", seq);
        }
    }
 
    if (num_gap_unknown_unspec > 0 && num_gap_known_or_spec == 0) {
        if (num_gap_unknown_unspec > 1) {
            PostErr(eDiag_Warning, eErr_SEQ_INST_SeqGapBadLinkage,
                "All " + NStr::IntToString(num_gap_unknown_unspec) +
                " Seq-gaps have unknown type and unspecified linkage", seq);
        } else {
            PostErr(eDiag_Warning, eErr_SEQ_INST_SeqGapBadLinkage,
                "Single Seq-gap has unknown type and unspecified linkage", seq);
        }
    }
 
    if (inst.GetLength() > len) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
            "Bioseq.seq_data too short [" + NStr::IntToString(len) +
            "] for given length [" + NStr::IntToString(inst.GetLength()) +
            "]", seq);
    } else if (inst.GetLength() < len) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_SeqDataLenWrong,
            "Bioseq.seq_data is larger [" + NStr::IntToString(len) +
            "] than given length [" + NStr::IntToString(inst.GetLength()) +
            "]", seq);
    }
    if ( non_interspersed_gaps  &&  !has_gi && mi  &&
        (tech == CMolInfo::eTech_htgs_0  ||  tech == CMolInfo::eTech_htgs_1  ||
         tech == CMolInfo::eTech_htgs_2) ) {
        EDiagSev missing_gaps_sev = eDiag_Error;
        CSeqdesc_CI desc_i(m_Scope->GetBioseqHandle(seq), CSeqdesc::e_User);
        while (desc_i) {
            if (desc_i->GetUser().IsRefGeneTracking()) {
                missing_gaps_sev = eDiag_Info;
                break;
            }
            ++desc_i;
        }
 
        PostErr(missing_gaps_sev, eErr_SEQ_INST_MissingGaps,
            "HTGS delta seq should have gaps between all sequence runs", seq);
    }
    if ( num_adjacent_gaps >= 1 ) {
        string msg = (num_adjacent_gaps == 1) ?
            "There is 1 adjacent gap in delta seq" :
            "There are " + NStr::SizetToString(num_adjacent_gaps) +
            " adjacent gaps in delta seq";
        PostErr(m_Imp.IsRefSeq() ? eDiag_Warning : eDiag_Error, eErr_SEQ_INST_BadDeltaSeq, msg, seq);
    }
    if (last_is_gap && !x_IgnoreEndGap(bsh, gap_type) && !s_WillReportTerminalGap(seq, bsh)) {
        EDiagSev sev = eDiag_Error;
        if (tech != CMolInfo::eTech_htgs_0 && tech != CMolInfo::eTech_htgs_1
            && tech != CMolInfo::eTech_htgs_2 && tech != CMolInfo::eTech_htgs_3) {
            sev = eDiag_Warning;
        }
        PostErr(sev, eErr_SEQ_INST_BadDeltaSeq,
                "Last delta seq component is a gap", seq);
    }
 
    // Validate technique
    if (num_gaps == 0  &&  mi) {
        if ( tech == CMolInfo::eTech_htgs_2  &&
             !GraphsOnBioseq(seq)  &&
             !x_IsActiveFin(seq) ) {
            PostErr(eDiag_Warning, eErr_SEQ_INST_BadHTGSeq,
                "HTGS 2 delta seq has no gaps and no graphs", seq);
        }
    }
 
    // look for multiple delta locs overlapping
    if (delta_locs.size() > 1) {
        stable_sort (delta_locs.begin(), delta_locs.end(), s_LocSortCompare);
        vector<CConstRef<CSeq_loc> >::iterator it1 = delta_locs.begin();
        vector<CConstRef<CSeq_loc> >::iterator it2 = it1;
        ++it2;
        while (it2 != delta_locs.end()) {
            if ((*it1)->GetId()->Compare(*(*it2)->GetId()) == CSeq_id::e_YES
                && Compare (**it1, **it2, m_Scope, fCompareOverlapping) != eNoOverlap) {
                string seq_label = (*it1)->GetId()->AsFastaString();
                PostErr (eDiag_Warning, eErr_SEQ_INST_OverlappingDeltaRange,
                         "Overlapping delta range " + NStr::IntToString((*it2)->GetStart(eExtreme_Positional) + 1)
                         + "-" + NStr::IntToString((*it2)->GetStop(eExtreme_Positional) + 1)
                         + " and " + NStr::IntToString((*it1)->GetStart(eExtreme_Positional) + 1)
                         + "-" + NStr::IntToString((*it1)->GetStop(eExtreme_Positional) + 1)
                         + " on a Bioseq " + seq_label,
                         seq);
            }
            ++it1;
            ++it2;
        }
    }
 
    if (IsSelfReferential(seq)) {
        PostErr(eDiag_Critical, eErr_SEQ_INST_SelfReferentialSequence,
            "Self-referential delta sequence", seq);
    }
 
    // look for Ns next to gaps
    if (seq.IsNa() && seq.GetLength() > 1 && x_IsDeltaLitOnly(inst)) {
        try {
            TSeqPos pos = 0;
            CSeqVector sv = bsh.GetSeqVector(CBioseq_Handle::eCoding_Iupac);
            ITERATE (CDelta_ext::Tdata, delta_i, seq.GetInst().GetExt().GetDelta().Get()) {
                if (delta_i->Empty()) {
                    continue; // Ignore NULLs, reported separately above.
                }
                const CDelta_seq& seg = **delta_i;
                TSeqPos delta_len = (TSeqPos)s_GetDeltaLen (seg, m_Scope);
                if (pos > 0) {
                    if (sv.IsInGap (pos)) {
                        CSeqVector::TResidue res = sv [pos - 1];
                        if (res == 'N' && !sv.IsInGap(pos - 1)) {
                            PostErr (eDiag_Error, eErr_SEQ_INST_InternalNsAdjacentToGap,
                                     "Ambiguous residue N is adjacent to a gap around position " + NStr::SizetToString (pos + 1),
                                     seq);
                        }
                    }
                }
                if (delta_len > 0 && pos + delta_len < len) {
                    if (sv.IsInGap(pos + delta_len - 1)) {
                        CSeqVector::TResidue res = sv[pos + delta_len];
                        if (res == 'N' && !sv.IsInGap(pos + delta_len)) {
                            PostErr(eDiag_Error, eErr_SEQ_INST_InternalNsAdjacentToGap,
                                "Ambiguous residue N is adjacent to a gap around position " + NStr::SizetToString(pos + delta_len + 1),
                                seq);
                        }
                    }
                }
                pos += delta_len;
            }
        } catch (const CException& ) {
        } catch (const std::exception& ) {
        }
    }
 
}
 
 
bool s_HasGI(const CBioseq& seq)
{
    bool has_gi = false;
    FOR_EACH_SEQID_ON_BIOSEQ(id_it, seq) {
        if ((*id_it)->IsGi()) {
            has_gi = true;
            break;
        }
    }
    return has_gi;
}
 
 
void CValidError_bioseq::ValidateSeqGap(const CSeq_gap& gap, const CBioseq& seq)
{
    if (gap.IsSetLinkage_evidence()) {
        int linkcount = 0;
        int linkevarray[13];
        for (int i = 0; i < 13; i++) {
            linkevarray[i] = 0;
        }
        bool is_unspec = false;
        ITERATE(CSeq_gap::TLinkage_evidence, ev_itr, gap.GetLinkage_evidence()) {
            const CLinkage_evidence & evidence = **ev_itr;
            if (!evidence.CanGetType()) continue;
            int linktype = evidence.GetType();
            if (linktype == 8) {
                is_unspec = true;
            }
            linkcount++;
            if (linktype == 255) {
                (linkevarray[11])++;
            }
            else if (linktype < 0 || linktype > 10) {
                (linkevarray[12])++;
            }
            else {
                (linkevarray[linktype])++;
            }
        }
        if (linkevarray[8] > 0 && linkcount > linkevarray[8]) {
            PostErr(eDiag_Error, eErr_SEQ_INST_SeqGapBadLinkage,
                "Seq-gap type has unspecified and additional linkage evidence", seq);
        }
        for (int i = 0; i < 13; i++) {
            if (linkevarray[i] > 1) {
                PostErr(eDiag_Error, eErr_SEQ_INST_SeqGapBadLinkage,
                    "Linkage evidence '" + linkEvStrings[i] + "' appears " +
                    NStr::IntToString(linkevarray[i]) + " times", seq);
            }
        }
        if (!gap.IsSetLinkage() || gap.GetLinkage() != CSeq_gap::eLinkage_linked) {
            PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapBadLinkage,
                "Seq-gap with linkage evidence must have linkage field set to linked", seq);
        }
        if (gap.IsSetType()) {
            int gaptype = gap.GetType();
            if (gaptype != CSeq_gap::eType_fragment &&
                gaptype != CSeq_gap::eType_clone &&
                gaptype != CSeq_gap::eType_repeat &&
                gaptype != CSeq_gap::eType_scaffold) {
                if (gaptype == CSeq_gap::eType_unknown && is_unspec) {
                    /* suppress for legacy records */
                } else if (gaptype == CSeq_gap::eType_contamination) {
                    if (linkevarray[8] > 0 && linkcount == linkevarray[8]) {
                        /* contamination can only have linked unspecified */
                    } else {
                        PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapBadLinkage,
                           "Contamination gaps must have linkage evidence 'unspecified'", seq);
                    }
                } else {
                    PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapBadLinkage,
                       "Seq-gap of type " + NStr::IntToString(gaptype) +
                       " should not have linkage evidence", seq);
                }
            }
        }
    }
    else {
        if (gap.IsSetType()) {
            int gaptype = gap.GetType();
            if (gaptype == CSeq_gap::eType_scaffold) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapProblem,
                    "Seq-gap type == scaffold is missing required linkage evidence", seq);
            }
            if (gaptype == CSeq_gap::eType_repeat && gap.IsSetLinkage() && gap.GetLinkage() == CSeq_gap::eLinkage_linked)
            {
                bool suppress_SEQ_INST_SeqGapProblem = false;
                if (seq.IsSetDescr() && s_HasGI(seq))
                {
                    ITERATE(CBioseq::TDescr::Tdata, it, seq.GetDescr().Get())
                    {
                        if ((**it).IsCreate_date())
                        {
                            CDate threshold_date(CTime(2012, 10, 1));
                            if ((**it).GetCreate_date().Compare(threshold_date) == CDate::eCompare_before)
                                suppress_SEQ_INST_SeqGapProblem = true;
                            break;
                        }
                    }
                }
                if (!suppress_SEQ_INST_SeqGapProblem)
                    PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapProblem,
                    "Seq-gap type == repeat and linkage == linked is missing required linkage evidence", seq);
 
            }
            if (gaptype == CSeq_gap::eType_contamination) {
                PostErr(eDiag_Critical, eErr_SEQ_INST_SeqGapBadLinkage,
                    "Contamination gap-types must be linked and have linkage-evidence of type 'unspecified'", seq);
            }
        }
    }
}
 
 
bool CValidError_bioseq::ValidateRepr
(const CSeq_inst& inst,
 const CBioseq&   seq)
{
    bool rtn = true;
    const CEnumeratedTypeValues* tv = CSeq_inst::GetTypeInfo_enum_ERepr();
    string rpr = tv->FindName(inst.GetRepr(), true);
    if (NStr::Equal(rpr, "ref")) {
        rpr = "reference";
    } else if (NStr::Equal(rpr, "const")) {
        rpr = "constructed";
    }
    const string err0 = "Bioseq-ext not allowed on " + rpr + " Bioseq";
    const string err1 = "Missing or incorrect Bioseq-ext on " + rpr + " Bioseq";
    const string err2 = "Missing Seq-data on " + rpr + " Bioseq";
    const string err3 = "Seq-data not allowed on " + rpr + " Bioseq";
    switch (inst.GetRepr()) {
    case CSeq_inst::eRepr_virtual:
        if (inst.IsSetExt()) {
            PostErr(eDiag_Critical, eErr_SEQ_INST_ExtNotAllowed, err0, seq);
            rtn = false;
        }
        if (inst.IsSetSeq_data()) {
            PostErr(eDiag_Error, eErr_SEQ_INST_SeqDataNotAllowed, err3, seq);
            rtn = false;
        }
        break;
    case CSeq_inst::eRepr_map:
        if (!inst.IsSetExt() || !inst.GetExt().IsMap()) {
            PostErr(