annot_collector.cpp

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

        }
        if (last_bit) {
            // search to the end of annot set
            x_SearchRange(tse, objs, guard, annot_name, id, hr, cvt,
                range.first, objs->m_AnnotSet.size());
        }
    }

    if ( x_NeedSNPs() ) {
        CHandleRange::TRange range = hr.GetOverlappingRange();
        ITERATE ( CTSE_Info::TSNPSet, snp_annot_it, objs->m_SNPSet ) {
            const CSeq_annot_SNP_Info& snp_annot = **snp_annot_it;
            CSeq_annot_SNP_Info::const_iterator snp_it =
                snp_annot.FirstIn(range);
            if ( snp_it != snp_annot.end() ) {
                m_TSE_LockSet.insert(ConstRef(&tse));
                TSeqPos index = snp_it - snp_annot.begin() - 1;
                do {
                    ++index;
                    const SSNP_Info& snp = *snp_it;
                    if ( snp.NoMore(range) ) {
                        break;
                    }
                    if ( snp.NotThis(range) ) {
                        continue;
                    }

                    CAnnotObject_Ref annot_ref(snp_annot, index);
                    annot_ref.SetSNP_Point(snp, cvt);
                    if ( x_AddObject(annot_ref, cvt, 0) ) {
                        return;
                    }
                } while ( ++snp_it != snp_annot.end() );
            }
        }
    }
}


void CAnnot_Collector::x_SearchRange(const CTSE_Info& tse,
                                        const SIdAnnotObjs* objs,
                                        CReadLockGuard& guard,
                                        const CAnnotName& annot_name,
                                        const CSeq_id_Handle& id,
                                        const CHandleRange& hr,
                                        CSeq_loc_Conversion* cvt,
                                        size_t from_idx, size_t to_idx)
{
    _ASSERT(objs);

    CHandleRange::TRange range = hr.GetOverlappingRange();

    m_TSE_LockSet.insert(ConstRef(&tse));

    for ( size_t index = from_idx; index < to_idx; ++index ) {
        size_t start_size = m_AnnotSet.size(); // for rollback
        
        const CTSE_Info::TRangeMap& rmap = objs->m_AnnotSet[index];
        if ( rmap.empty() ) {
            continue;
        }

        for ( CTSE_Info::TRangeMap::const_iterator aoit(rmap.begin(range));
              aoit; ++aoit ) {
            const CAnnotObject_Info& annot_info =
                *aoit->second.m_AnnotObject_Info;

            _ASSERT(m_Selector.MatchType(annot_info));

            if ( annot_info.IsChunkStub() ) {
                const CTSE_Chunk_Info& chunk = annot_info.GetChunk_Info();
                if ( chunk.NotLoaded() ) {
                    // New annot objects are to be loaded,
                    // so we'll need to restart scan of current range.

                    // Forget already found object
                    // as they will be found again:
                    m_AnnotSet.resize(start_size);

                    CAnnotName name(annot_name);

                    // Release lock for tse update:
                    guard.Release();
                        
                    // Load the stub:
                    const_cast<CTSE_Chunk_Info&>(chunk).Load();

                    // Acquire the lock again:
                    guard.Guard(tse.m_AnnotObjsLock);

                    // Reget range map pointer as it may change:
                    objs = tse.x_GetIdObjects(name, id);
                    _ASSERT(objs);

                    // Restart this index again:
                    --index;
                    break;
                }
                else {
                    // Skip chunk stub
                    continue;
                }
            }

            if ( !x_MatchLimitObject(annot_info) ) {
                continue;
            }
                
            if ( !x_MatchRange(hr, aoit->first, aoit->second) ) {
                continue;
            }

            CAnnotObject_Ref annot_ref(annot_info);
            if (!cvt  &&  annot_info.GetMultiIdFlags()) {
                // Create self-conversion, add to conversion set
                CRef<CSeq_loc_Conversion> cvt_ref
                    (new CSeq_loc_Conversion(id, m_Scope));
                if (x_AddObjectMapping(annot_ref,
                    &*cvt_ref, aoit->second.m_AnnotLocationIndex)) {
                    return;
                }
            }
            else {
                if (cvt  &&  !annot_ref.IsAlign() ) {
                    cvt->Convert
                        (annot_ref,
                         m_Selector.m_FeatProduct ?
                         CSeq_loc_Conversion::eProduct :
                         CSeq_loc_Conversion::eLocation);
                }
                else {
                    annot_ref.SetAnnotObjectRange(aoit->first,
                                                  m_Selector.m_FeatProduct);
                }
                if ( x_AddObject(annot_ref, cvt,
                    aoit->second.m_AnnotLocationIndex) ) {
                    return;
                }
            }
        }
    }
}


bool CAnnot_Collector::x_Search(const CHandleRangeMap& loc,
                                   CSeq_loc_Conversion* cvt)
{
    bool found = false;
    ITERATE ( CHandleRangeMap, idit, loc ) {
        if ( idit->second.Empty() ) {
            continue;
        }

        bool have_main = false;
        CConstRef<CSynonymsSet> syns = m_Scope->GetSynonyms(idit->first);
        if ( !syns ) {
            if (m_Selector.m_IdResolving == SAnnotSelector::eFailUnresolved) {
                NCBI_THROW(CAnnotException, eFindFailed,
                           "Cannot find id synonyms");
            }
        }
        else {
            ITERATE ( CSynonymsSet, synit, *syns ) {
                CSeq_id_Handle idh = CSynonymsSet::GetSeq_id_Handle(synit);
                if ( !have_main ) {
                    have_main = idit->first == idh;
                }
                found = x_Search(idh, CSynonymsSet::GetBioseqHandle(synit),
                                 idit->second, cvt)  ||  found;
            }
        }
        if ( !have_main ) {
            found = x_Search(idit->first, CBioseq_Handle(),
                             idit->second, cvt)  ||  found;
        }
    }
    return found;
}


void CAnnot_Collector::x_SearchAll(void)
{
    _ASSERT(m_Selector.m_LimitObjectType != SAnnotSelector::eLimit_None);
    _ASSERT(m_Selector.m_LimitObject);
    _ASSERT(m_MappingCollector->m_LimitObjectInfo);
    if ( m_TSE_LockSet.empty() ) {
        // data source name not matched
        return;
    }
    switch ( m_Selector.m_LimitObjectType ) {
    case SAnnotSelector::eLimit_TSE_Info:
        x_SearchAll(*CTypeConverter<CTSE_Info>::
                    SafeCast(m_MappingCollector->
                    m_LimitObjectInfo.GetPointer()));
        break;
    case SAnnotSelector::eLimit_Seq_entry_Info:
        x_SearchAll(*CTypeConverter<CSeq_entry_Info>::
                    SafeCast(m_MappingCollector->
                    m_LimitObjectInfo.GetPointer()));
        break;
    case SAnnotSelector::eLimit_Seq_annot_Info:
        x_SearchAll(*CTypeConverter<CSeq_annot_Info>::
                    SafeCast(m_MappingCollector->
                    m_LimitObjectInfo.GetPointer()));
        break;
    default:
        // no limit object -> do nothing
        break;
    }
}


void CAnnot_Collector::x_SearchAll(const CSeq_entry_Info& entry_info)
{
    {{
        CConstRef<CBioseq_Base_Info> base = entry_info.m_Contents;
        // Collect all annotations from the entry
        ITERATE( CBioseq_Base_Info::TAnnot, ait, base->GetAnnot() ) {
            x_SearchAll(**ait);
            if ( x_GetAnnotCount() >= m_Selector.m_MaxSize )
                return;
        }
    }}

    if ( entry_info.IsSet() ) {
        CConstRef<CBioseq_set_Info> set(&entry_info.GetSet());
        // Collect annotations from all children
        ITERATE( CBioseq_set_Info::TSeq_set, cit, set->GetSeq_set() ) {
            x_SearchAll(**cit);
            if ( x_GetAnnotCount() >= m_Selector.m_MaxSize )
                return;
        }
    }
}


void CAnnot_Collector::x_SearchAll(const CSeq_annot_Info& annot_info)
{
    // Collect all annotations from the annot
    ITERATE ( SAnnotObjects_Info::TObjectInfos, aoit,
              annot_info.m_ObjectInfos.GetInfos() ) {
        if ( !m_Selector.MatchType(*aoit) ) {
            continue;
        }
        CAnnotObject_Ref annot_ref(*aoit);
        if ( x_AddObject(annot_ref) ) {
            return;
        }
    }

    if ( x_NeedSNPs() && annot_info.x_HasSNP_annot_Info() ) {
        const CSeq_annot_SNP_Info& snp_annot =
            annot_info.x_GetSNP_annot_Info();
        TSeqPos index = 0;
        ITERATE ( CSeq_annot_SNP_Info, snp_it, snp_annot ) {
            const SSNP_Info& snp = *snp_it;
            CAnnotObject_Ref annot_ref(snp_annot, index);
            annot_ref.SetSNP_Point(snp, 0);
            if ( x_AddObject(annot_ref) ) {
                return;
            }
            ++index;
        }
    }
}


bool CAnnot_Collector::x_SearchMapped(const CSeqMap_CI& seg,
                                      CSeq_loc& master_loc_empty,
                                      const CSeq_id_Handle& master_id,
                                      const CHandleRange& master_hr)
{
    CHandleRange::TOpenRange master_seg_range(seg.GetPosition(),
                                              seg.GetEndPosition());
    CHandleRange::TOpenRange ref_seg_range(seg.GetRefPosition(),
                                           seg.GetRefEndPosition());
    bool reversed = seg.GetRefMinusStrand();
    TSignedSeqPos shift;
    if ( !reversed ) {
        shift = ref_seg_range.GetFrom() - master_seg_range.GetFrom();
    }
    else {
        shift = ref_seg_range.GetTo() + master_seg_range.GetFrom();
    }
    CSeq_id_Handle ref_id = seg.GetRefSeqid();
    CHandleRangeMap ref_loc;
    {{ // translate master_loc to ref_loc
        CHandleRange& hr = ref_loc.AddRanges(ref_id);
        ITERATE ( CHandleRange, mlit, master_hr ) {
            CHandleRange::TOpenRange range =
                master_seg_range.IntersectionWith(mlit->first);
            if ( !range.Empty() ) {
                ENa_strand strand = mlit->second;
                if ( !reversed ) {
                    range.SetOpen(range.GetFrom() + shift,
                                  range.GetToOpen() + shift);
                }
                else {
                    strand = Reverse(strand);
                    range.Set(shift - range.GetTo(), shift - range.GetFrom());
                }
                hr.AddRange(range, strand);
            }
        }
        if ( hr.Empty() )
            return false;
    }}

    if (m_Selector.m_NoMapping) {
        return x_Search(ref_loc, 0);
    }
    else {
        CRef<CSeq_loc_Conversion> cvt(new CSeq_loc_Conversion(master_loc_empty,
                                                              master_id,
                                                              seg,
                                                              ref_id,
                                                              m_Scope));
        return x_Search(ref_loc, &*cvt);
    }
}


END_SCOPE(objects)
END_NCBI_SCOPE

/*
* ---------------------------------------------------------------------------
* $Log: annot_collector.cpp,v $
* Revision 1000.3  2004/06/01 19:22:32  gouriano
* PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.7
*
* Revision 1.7  2004/05/26 14:29:20  grichenk
* Redesigned CSeq_align_Mapper: preserve non-mapping intervals,
* fixed strands handling, improved performance.
*
* Revision 1.6  2004/05/21 21:42:12  gorelenk
* Added PCH ncbi_pch.hpp
*
* Revision 1.5  2004/05/10 18:26:37  grichenk
* Fixed 'not used' warnings
*
* Revision 1.4  2004/05/03 17:01:03  grichenk
* Invalidate total range before reusing seq-loc.
*
* Revision 1.3  2004/04/13 21:14:27  vasilche
* Fixed wrong order of object deletion causing "tse is locked" error.
*
* Revision 1.2  2004/04/13 15:59:35  grichenk
* Added CScope::GetBioseqHandle() with id resolving flag.
*
* Revision 1.1  2004/04/05 15:54:26  grichenk
* Initial revision
*
*
* ===========================================================================
*/