feat_ci.hpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: feat_ci.hpp,v $
 * PRODUCTION Revision 1000.3  2004/06/01 19:21:22  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.41
 * PRODUCTION
 * ===========================================================================
 */

#ifndef FEAT_CI__HPP
#define FEAT_CI__HPP

/*  $Id: feat_ci.hpp,v 1000.3 2004/06/01 19:21:22 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Aleksey Grichenko, Michael Kimelman, Eugene Vasilchenko
*
* File Description:
*   Object manager iterators
*
*/

#include <corelib/ncbistd.hpp>
#include <objmgr/annot_types_ci.hpp>
#include <objmgr/seq_annot_handle.hpp>
#include <objmgr/seq_entry_handle.hpp>
#include <objects/seqfeat/Seq_feat.hpp>
#include <objects/seqloc/Seq_loc.hpp>
#include <objmgr/seq_feat_handle.hpp>

BEGIN_NCBI_SCOPE
BEGIN_SCOPE(objects)


class NCBI_XOBJMGR_EXPORT CMappedFeat
{
public:
    CMappedFeat(void);
    CMappedFeat(const CMappedFeat& feat);
    CMappedFeat& operator=(const CMappedFeat& feat);
    ~CMappedFeat(void);

    // Original feature with unmapped location/product
    const CSeq_feat& GetOriginalFeature(void) const;
    // Original feature handle
    CSeq_feat_Handle GetSeq_feat_Handle(void) const;

    // Feature mapped to the master sequence.
    // WARNING! The function is rather slow and should be used with care.
    const CSeq_feat& GetMappedFeature(void) const;

    bool IsSetId(void) const
        { return GetOriginalFeature().IsSetId(); }
    const CFeat_id& GetId(void) const
        { return GetOriginalFeature().GetId(); }

    const CSeqFeatData& GetData(void) const
        { return GetOriginalFeature().GetData(); }

    bool IsSetPartial(void) const
        { return m_FeatRef->IsPartial(); }
    bool GetPartial(void) const
        { return m_FeatRef->IsPartial(); }

    bool IsSetExcept(void) const
        { return GetOriginalFeature().IsSetExcept(); }
    bool GetExcept(void) const
        { return GetOriginalFeature().GetExcept(); }

    bool IsSetComment(void) const
        { return GetOriginalFeature().IsSetComment(); }
    const string& GetComment(void) const
        { return GetOriginalFeature().GetComment(); }

    bool IsSetProduct(void) const
        { return GetOriginalFeature().IsSetProduct(); }
    const CSeq_loc& GetProduct(void) const
        {
            return m_FeatRef->IsMappedProduct()?
                GetMappedLocation(): GetOriginalFeature().GetProduct();
        }

    const CSeq_loc& GetLocation(void) const
        {
            return m_FeatRef->IsMappedLocation()?
                GetMappedLocation(): GetOriginalFeature().GetLocation();
        }

    bool IsSetQual(void) const
        { return GetOriginalFeature().IsSetQual(); }
    const CSeq_feat::TQual& GetQual(void) const
        { return GetOriginalFeature().GetQual(); }

    bool IsSetTitle(void) const
        { return GetOriginalFeature().IsSetTitle(); }
    const string& GetTitle(void) const
        { return GetOriginalFeature().GetTitle(); }

    bool IsSetExt(void) const
        { return GetOriginalFeature().IsSetExt(); }
    const CUser_object& GetExt(void) const
        { return GetOriginalFeature().GetExt(); }

    bool IsSetCit(void) const
        { return GetOriginalFeature().IsSetCit(); }
    const CPub_set& GetCit(void) const
        { return GetOriginalFeature().GetCit(); }

    bool IsSetExp_ev(void) const
        { return GetOriginalFeature().IsSetExp_ev(); }
    CSeq_feat::EExp_ev GetExp_ev(void) const
        { return GetOriginalFeature().GetExp_ev(); }

    bool IsSetXref(void) const
        { return GetOriginalFeature().IsSetXref(); }
    const CSeq_feat::TXref& GetXref(void) const
        { return GetOriginalFeature().GetXref(); }

    bool IsSetDbxref(void) const
        { return GetOriginalFeature().IsSetDbxref(); }
    const CSeq_feat::TDbxref& GetDbxref(void) const
        { return GetOriginalFeature().GetDbxref(); }

    bool IsSetPseudo(void) const
        { return GetOriginalFeature().IsSetPseudo(); }
    bool GetPseudo(void) const
        { return GetOriginalFeature().GetPseudo(); }

    bool IsSetExcept_text(void) const
        { return GetOriginalFeature().IsSetExcept_text(); }
    const string& GetExcept_text(void) const
        { return GetOriginalFeature().GetExcept_text(); }

    CSeq_annot_Handle GetAnnot(void) const;
    const CSeq_annot& GetSeq_annot(void) const;

private:
    friend class CFeat_CI;
    friend class CAnnot_CI;

    typedef CAnnot_Collector::TAnnotSet TAnnotSet;
    typedef TAnnotSet::const_iterator   TIterator;

    CMappedFeat& Set(CAnnot_Collector& collector,
                     const TIterator& annot);
    void Reset(void);

    const CSeq_feat& x_MakeOriginalFeature(void) const;
    const CSeq_feat& x_MakeMappedFeature(void) const;
    const CSeq_loc& x_MakeMappedLocation(void) const;

    const CSeq_loc& GetMappedLocation(void) const;

    mutable CRef<CAnnot_Collector> m_Collector;
    TIterator                      m_FeatRef;

    mutable CConstRef<CSeq_feat> m_OriginalSeq_feat;
    mutable CConstRef<CSeq_feat> m_MappedSeq_feat;
    mutable CConstRef<CSeq_loc>  m_MappedSeq_loc;
};


class CSeq_annot_Handle;


class NCBI_XOBJMGR_EXPORT CFeat_CI : public CAnnotTypes_CI
{
public:
    enum EFeat_Location {
        e_Location,
        e_Product
    };
    CFeat_CI(void);

    CFeat_CI(CScope& scope,
             const CSeq_loc& loc);
    CFeat_CI(const CBioseq_Handle& bioseq,
             TSeqPos start, TSeqPos stop);
    CFeat_CI(CScope& scope,
             const CSeq_loc& loc,
             const SAnnotSelector& sel);
    CFeat_CI(const CBioseq_Handle& bioseq,
             TSeqPos start, TSeqPos stop,
             const SAnnotSelector& sel);

    // Iterate all features from the object regardless of their location
    CFeat_CI(CScope& scope, const CSeq_annot& annot);
    CFeat_CI(CScope& scope, const CSeq_annot& annot,
             const SAnnotSelector& sel);
    CFeat_CI(const CSeq_annot_Handle& annot);
    CFeat_CI(const CSeq_annot_Handle& annot,
             const SAnnotSelector& sel);

    CFeat_CI(CScope& scope, const CSeq_entry& entry);
    CFeat_CI(CScope& scope, const CSeq_entry& entry,
             const SAnnotSelector& sel);
    CFeat_CI(const CSeq_entry_Handle& entry);
    CFeat_CI(const CSeq_entry_Handle& entry,
             const SAnnotSelector& sel);

    typedef SAnnotSelector::TFeatType TFeatType;

    // Search all TSEs in all datasources. By default search sequence segments
    // (for constructed sequences) only if the referenced sequence is in the
    // same TSE as the master one. Use CFeat_CI::eResolve_All flag to search
    // features on all referenced sequences or CFeat_CI::eResolve_None to
    // disable references resolving.
    CFeat_CI(CScope& scope,
             const CSeq_loc& loc,
             TFeatType feat_type,
             SAnnotSelector::EOverlapType overlap_type
             = SAnnotSelector::eOverlap_Intervals,
             SAnnotSelector::EResolveMethod resolve
             = SAnnotSelector::eResolve_TSE,
             EFeat_Location loc_type = e_Location);
    // Search only in TSE, containing the bioseq. If both start & stop are 0,
    // the whole bioseq is searched. References are resolved depending on the
    // "resolve" flag (see above).
    // If "entry" is set, search only features from the seq-entry specified
    // (but no its sub-entries or parent entry).
    CFeat_CI(const CBioseq_Handle& bioseq,
             TSeqPos start, TSeqPos stop,
             TFeatType feat_type,
             SAnnotSelector::EOverlapType overlap_type
             = SAnnotSelector::eOverlap_Intervals,
             SAnnotSelector::EResolveMethod resolve
             = SAnnotSelector::eResolve_TSE,
             EFeat_Location loc_type = e_Location);
    CFeat_CI(const CBioseq_Handle& bioseq,
             TSeqPos start, TSeqPos stop,
             TFeatType feat_type,
             SAnnotSelector::EOverlapType overlap_type,
             SAnnotSelector::EResolveMethod resolve,
             EFeat_Location loc_type,
             const CSeq_entry_Handle& limitEntry);
    CFeat_CI(const CBioseq_Handle& bioseq,
             TSeqPos start, TSeqPos stop,
             TFeatType feat_type,
             SAnnotSelector::EOverlapType overlap_type,
             SAnnotSelector::EResolveMethod resolve,
             EFeat_Location loc_type,
             const CSeq_entry* limitEntry);
    CFeat_CI(const CFeat_CI& iter);
    virtual ~CFeat_CI(void);
    CFeat_CI& operator= (const CFeat_CI& iter);