obj_convert.cpp

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

};



//////////////////////////////////////////////////////////////////////////
//
// seq-submit conversions
//

class CSeq_submitConverter : public CObjConverter
{
public:

    // seq-submit -> seq-submit
    // identity conversion
    void ToSeqSubmit(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_submit* sub = dynamic_cast<const CSeq_submit*> (&obj);
        if (sub) {
            objs.push_back(CConstRef<CObject>(sub));
        }
    }


    // seq-submit -> seq-entry
    void ToSeqEntry(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_submit* sub = dynamic_cast<const CSeq_submit*> (&obj);
        if (sub  &&  sub->GetData().IsEntrys()) {
            ITERATE (CSeq_submit::TData::TEntrys, iter,
                     sub->GetData().GetEntrys()) {
                CConstRef<CObject> obj(iter->GetPointer());
                objs.push_back(obj);
            }
        }
    }


    // seq-submit -> bioseq
    // identity operation
    void ToBioseq(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        TObjList ents;
        ToSeqEntry(scope, obj, ents);
        ITERATE (TObjList, ent_iter, ents) {
            CObjectConverter::Convert(scope, **ent_iter,
                                      CBioseq::GetTypeInfo()->GetName(), objs);
        }
    }


    // seq-submit -> seq-id
    // we return only one of the seq-ids for this seq-submit
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        TObjList ents;
        ToSeqEntry(scope, obj, ents);
        ITERATE (TObjList, ent_iter, ents) {
            CObjectConverter::Convert(scope, **ent_iter,
                                      CSeq_id::GetTypeInfo()->GetName(), objs);
        }
    }

};



//////////////////////////////////////////////////////////////////////////
//
// seq-id conversions
//

class CSeq_idConverter : public CObjConverter
{
public:

    // seq-id -> seq-entry
    // retrieve the seq-entry from the scope
    void ToSeqEntry(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
        if (id) {
            // retrieve our handle from the scope and proceed
            CBioseq_Handle handle = scope.GetBioseqHandle(*id);
            if (handle) {
                const CSeq_entry& entry = handle.GetTopLevelSeqEntry();
                CConstRef<CObject> obj(&entry);
                objs.push_back(obj);
            }
        }
    }


    // seq-id -> bioseq-set
    // retrieve the seq-entry from the scope and return its bioseq-set
    void ToBioseqSet(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
        if (id) {
            // retrieve our handle from the scope and proceed
            CBioseq_Handle handle = scope.GetBioseqHandle(*id);
            if (handle) {
                const CSeq_entry& entry = handle.GetTopLevelSeqEntry();
                if (entry.IsSet()) {
                    objs.push_back(CConstRef<CObject>(&entry.GetSet()));
                }
            }
        }
    }


    // seq-id -> bioseq
    // retrieve the bioseq from the scope
    void ToBioseq(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
        if (id) {
            // retrieve our handle from the scope and proceed
            CBioseq_Handle handle = scope.GetBioseqHandle(*id);
            if (handle) {
                const CBioseq& bs = *handle.GetCompleteBioseq();
                objs.push_back(CConstRef<CObject>(&bs));
            }
        }
    }


    // seq-id -> seq-id
    // we return only one of the seq-ids for each bioseq
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
        if (id) {
            objs.push_back(CConstRef<CObject>(id));
        }
    }


    // seq-id -> seq-loc
    // this is a very simple conversion; we create a new CSeq_loc
    // of type whole
    void ToSeqLoc(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_id* id = dynamic_cast<const CSeq_id*>(&obj);
        if (id) {
            CRef<CSeq_loc> loc(new CSeq_loc());
            loc->SetWhole(const_cast<CSeq_id&>(*id));
            objs.push_back(CConstRef<CObject>(loc.GetPointer()));
        }
    }

};



//////////////////////////////////////////////////////////////////////////
//
// seq-loc conversions
//

class CSeq_locConverter : public CObjConverter
{
public:


    // seq-loc -> seq-id
    // we return a set of unique seq-ids for each location
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*> (&obj);
        if (loc) {
            CTypeConstIterator<CSeq_id> id_iter(*loc);
            for ( ;  id_iter;  ++id_iter) {
                const CSeq_id& id = *id_iter;

                bool add = true;
                ITERATE(TObjList, obj_iter, objs) {
                    const CSeq_id* other_id =
                        dynamic_cast<const CSeq_id*> (obj_iter->GetPointer());
                    if ( !other_id ) {
                        continue;
                    }

                    CSeq_id::E_SIC cmp = other_id->Compare(id);
                    if (cmp == CSeq_id::e_YES) {
                        add = false;
                        break;
                    }
                    if (cmp == CSeq_id::e_DIFF) {
                        _TRACE("Warning: seq-id compare ineffective");
                    }
                }
                if (add) {
                    objs.push_back(CConstRef<CObject>(&id));
                }
            }
        }
    }


    // seq-loc -> seq-loc
    // identity conversion
    void ToSeqLoc(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
        if (loc) {
            objs.push_back(CConstRef<CObject>(loc));
        }
    }


    // seq-loc -> seq-feat
    // we use CFeat_CI
    void ToSeqFeat(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
        if (loc) {
            SAnnotSelector sel = CSeqUtils::GetAnnotSelector();
            CFeat_CI iter(scope, *loc, sel);
            for (;  iter;  ++iter) {
                const CSeq_feat& feat = iter->GetOriginalFeature();
                objs.push_back(CConstRef<CObject>(&feat));
            }
        }
    }

    // seq-loc -> seq-align
    // we use CAlign_CI
    void ToSeqAlign(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
        if (loc) {
            SAnnotSelector sel = CSeqUtils::GetAnnotSelector();
            CAlign_CI iter(scope, *loc, sel);
            for (;  iter;  ++iter) {
                objs.push_back(CConstRef<CObject>(&(*iter)));
            }
        }
    }

    // seq-loc --> seq-annot
    // we use CAnnot_CI here
    void ToSeqAnnot(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(&obj);
        if (loc) {
            SAnnotSelector sel = CSeqUtils::GetAnnotSelector();
            CAnnot_CI iter(scope, *loc, sel);
            for (;  iter;  ++iter) {
                const CSeq_annot& annot = iter->GetSeq_annot();
                objs.push_back(CConstRef<CObject>(&annot));
            }
        }
    }
};



//////////////////////////////////////////////////////////////////////////
//
// seq-annot conversions
//

class CSeq_annotConverter : public CObjConverter
{
public:

    // seq-annot -> seq-entry: we create a dummy CSeq_entry to hold our object
    void ToSeqEntry(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_annot* annot = dynamic_cast<const CSeq_annot*> (&obj);
        if (annot) {
            CRef<CSeq_entry> entry(new CSeq_entry());
            entry->SetSet().SetSeq_set();
            entry->SetSet().SetAnnot()
                .push_back(CRef<CSeq_annot>(const_cast<CSeq_annot*>(annot)));
            objs.push_back( CConstRef<CObject> (entry.GetPointer()) );
        }
    }

    // seq-annot -> seq-id: use CTypeConstIterator<>
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_annot* annot = dynamic_cast<const CSeq_annot*> (&obj);
        if (annot) {
            CTypeConstIterator<CSeq_id> id_iter(*annot);
            for ( ;  id_iter;  ++id_iter) {
                objs.push_back( CConstRef<CObject> (&*id_iter) );
            }
        }
    }

    // seq-annot -> seq-align
    void ToSeqAlign(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_annot* annot = dynamic_cast<const CSeq_annot*>(&obj);
        if (annot  &&  annot->GetData().IsAlign()) {
            ITERATE (CSeq_annot::TData::TAlign, iter,
                     annot->GetData().GetAlign()) {
                objs.push_back(CConstRef<CObject>(&**iter));
            }
        }
    }

};


//////////////////////////////////////////////////////////////////////////
//
// seq-align conversions
//

class CSeq_alignConverter : public CObjConverter
{
public:

    // functor for evaluating whether a seq-id matches that inside
    // of a seq-interval
    struct SSortByIdRef {
        bool operator() (const CConstRef<CSeq_id>& id1,
                         const CConstRef<CSeq_id>& id2) const
        {
            return (*id1 < *id2);
        }
    };


    // seq-align -> seq-id
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align* align = dynamic_cast<const CSeq_align*> (&obj);
        if (align) {
            typedef set<CConstRef<CSeq_id>, SSortByIdRef> TIdSet;
            TIdSet id_set;
            CTypeConstIterator<CSeq_id> id_iter(*align);
            for ( ;  id_iter;  ++id_iter) {
                id_set.insert( CConstRef<CSeq_id>(&*id_iter) );
            }

            ITERATE (TIdSet, iter, id_set) {
                objs.push_back( CConstRef<CObject>(iter->GetPointer()) );
            }
        }
    }

    // seq-align -> seq-align
    // identity conversion
    void ToSeqAlign(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align* align = dynamic_cast<const CSeq_align*>(&obj);
        if (align) {
            objs.push_back(CConstRef<CObject>(align));
        }
    }

    // seq-align -> seq-annot
    void ToSeqAnnot(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align* align = dynamic_cast<const CSeq_align*>(&obj);
        if (align) {
            CRef<CSeq_annot> annot(new CSeq_annot());
            annot->SetData().SetAlign()
                .push_back(CRef<CSeq_align>(const_cast<CSeq_align*>(align)));
            objs.push_back(CConstRef<CObject>(annot.GetPointer()));
        }
    }
};


//////////////////////////////////////////////////////////////////////////
//
// seq-align-set conversions
//

class CSeq_align_setConverter : public CObjConverter
{
public:

    // functor for evaluating whether a seq-id matches that inside
    // of a seq-interval
    struct SSortByIdRef {
        bool operator() (const CConstRef<CSeq_id>& id1,
                         const CConstRef<CSeq_id>& id2) const
        {
            return (*id1 < *id2);
        }
    };


    // seq-align-set -> seq-id
    void ToSeqId(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align_set* align =
            dynamic_cast<const CSeq_align_set*> (&obj);
        if (align) {
            typedef set<CConstRef<CSeq_id>, SSortByIdRef> TIdSet;
            TIdSet id_set;
            CTypeConstIterator<CSeq_id> id_iter(*align);
            for ( ;  id_iter;  ++id_iter) {
                id_set.insert( CConstRef<CSeq_id>(&*id_iter) );
            }

            ITERATE (TIdSet, iter, id_set) {
                objs.push_back( CConstRef<CObject>(iter->GetPointer()) );
            }
        }
    }

    // seq-align-set -> seq-align
    // identity conversion
    void ToSeqAlign(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align_set* align =
            dynamic_cast<const CSeq_align_set*>(&obj);
        if (align) {
            ITERATE (CSeq_align_set::Tdata, iter, align->Get()) {
                objs.push_back(CConstRef<CObject>(iter->GetPointer()));
            }
        }
    }

    // seq-align-set -> seq-annot
    void ToSeqAnnot(CScope& scope, const CObject& obj, TObjList& objs) const
    {
        const CSeq_align_set* align =
            dynamic_cast<const CSeq_align_set*>(&obj);
        if (align) {
            CRef<CSeq_annot> annot(new CSeq_annot());
            ITERATE (CSeq_align_set::Tdata, iter, align->Get()) {
                CRef<CSeq_align> ref
                    (const_cast<CSeq_align*>(iter->GetPointer()));
                annot->SetData().SetAlign().push_back(ref);
            }
            objs.push_back(CConstRef<CObject>(annot.GetPointer()));
        }