data_manager.cpp

ncbi源码

            cdd->SetFeatures(*structureAlignments);
        if (cddUpdates)
            cdd->SetPending() = *cddUpdates;
        if (bundleImportsFaked.size() > 0)
            cdd->SetPending().splice(cdd->SetPending().end(), bundleImportsFaked);

        cddData.Reset(cdd.GetPointer());
    }

    mimeData.Reset();
    Load();
    return true;
}

ASNDataManager::SeqAnnotList * ASNDataManager::GetOrCreateSequenceAlignments(void)
{
    // if necessary, convert mime data into general type that has a place for alignments
    if (!sequenceAlignments && mimeData.NotEmpty() && !mimeData->IsGeneral())
        ConvertMimeToGeneral();

    if (!sequenceAlignments && mimeData.NotEmpty() && mimeData->IsGeneral() &&
            mimeData->GetGeneral().GetSeq_align_data().IsBundle())
        sequenceAlignments =
            &(mimeData->SetGeneral().SetSeq_align_data().SetBundle().SetSeqaligns());
    return sequenceAlignments;
}

const CCn3d_style_dictionary * ASNDataManager::GetStyleDictionary(void) const
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc() && mimeData->GetAlignstruc().IsSetStyle_dictionary())
            return &(mimeData->GetAlignstruc().GetStyle_dictionary());
        else if (mimeData->IsAlignseq() && mimeData->GetAlignseq().IsSetStyle_dictionary())
            return &(mimeData->GetAlignseq().GetStyle_dictionary());
        else if (mimeData->IsStrucseq() && mimeData->GetStrucseq().IsSetStyle_dictionary())
            return &(mimeData->GetStrucseq().GetStyle_dictionary());
        else if (mimeData->IsStrucseqs() && mimeData->GetStrucseqs().IsSetStyle_dictionary())
            return &(mimeData->GetStrucseqs().GetStyle_dictionary());
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle() &&
                mimeData->GetGeneral().GetSeq_align_data().GetBundle().IsSetStyle_dictionary())
                return &(mimeData->GetGeneral().GetSeq_align_data().GetBundle().GetStyle_dictionary());
            else if (mimeData->GetGeneral().GetSeq_align_data().IsCdd() &&
                     mimeData->GetGeneral().GetSeq_align_data().GetCdd().IsSetStyle_dictionary())
                return &(mimeData->GetGeneral().GetSeq_align_data().GetCdd().GetStyle_dictionary());
        }
    } else if (cddData->IsSetStyle_dictionary())
        return &(cddData->GetStyle_dictionary());

    return NULL;
}

void ASNDataManager::SetStyleDictionary(ncbi::objects::CCn3d_style_dictionary& styles)
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc()) mimeData->SetAlignstruc().SetStyle_dictionary(styles);
        else if (mimeData->IsAlignseq()) mimeData->SetAlignseq().SetStyle_dictionary(styles);
        else if (mimeData->IsStrucseq()) mimeData->SetStrucseq().SetStyle_dictionary(styles);
        else if (mimeData->IsStrucseqs()) mimeData->SetStrucseqs().SetStyle_dictionary(styles);
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle())
                mimeData->SetGeneral().SetSeq_align_data().SetBundle().SetStyle_dictionary(styles);
            else
                mimeData->SetGeneral().SetSeq_align_data().SetCdd().SetStyle_dictionary(styles);
        }
    } else
        cddData->SetStyle_dictionary(styles);
}

void ASNDataManager::RemoveStyleDictionary(void)
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc()) mimeData->SetAlignstruc().ResetStyle_dictionary();
        else if (mimeData->IsAlignseq()) mimeData->SetAlignseq().ResetStyle_dictionary();
        else if (mimeData->IsStrucseq()) mimeData->SetStrucseq().ResetStyle_dictionary();
        else if (mimeData->IsStrucseqs()) mimeData->SetStrucseqs().ResetStyle_dictionary();
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle())
                mimeData->SetGeneral().SetSeq_align_data().SetBundle().ResetStyle_dictionary();
            else
                mimeData->SetGeneral().SetSeq_align_data().SetCdd().ResetStyle_dictionary();
        }
    } else
        cddData->ResetStyle_dictionary();
}

const CCn3d_user_annotations * ASNDataManager::GetUserAnnotations(void) const
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc() && mimeData->GetAlignstruc().IsSetUser_annotations())
            return &(mimeData->GetAlignstruc().GetUser_annotations());
        else if (mimeData->IsAlignseq() && mimeData->GetAlignseq().IsSetUser_annotations())
            return &(mimeData->GetAlignseq().GetUser_annotations());
        else if (mimeData->IsStrucseq() && mimeData->GetStrucseq().IsSetUser_annotations())
            return &(mimeData->GetStrucseq().GetUser_annotations());
        else if (mimeData->IsStrucseqs() && mimeData->GetStrucseqs().IsSetUser_annotations())
            return &(mimeData->GetStrucseqs().GetUser_annotations());
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle() &&
                mimeData->GetGeneral().GetSeq_align_data().GetBundle().IsSetUser_annotations())
                return &(mimeData->GetGeneral().GetSeq_align_data().GetBundle().GetUser_annotations());
            else if (mimeData->GetGeneral().GetSeq_align_data().IsCdd() &&
                     mimeData->GetGeneral().GetSeq_align_data().GetCdd().IsSetUser_annotations())
                return &(mimeData->GetGeneral().GetSeq_align_data().GetCdd().GetUser_annotations());
        }
    } else if (cddData->IsSetUser_annotations())
        return &(cddData->GetUser_annotations());

    return NULL;
}

void ASNDataManager::SetUserAnnotations(ncbi::objects::CCn3d_user_annotations& annots)
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc()) mimeData->SetAlignstruc().SetUser_annotations(annots);
        else if (mimeData->IsAlignseq()) mimeData->SetAlignseq().SetUser_annotations(annots);
        else if (mimeData->IsStrucseq()) mimeData->SetStrucseq().SetUser_annotations(annots);
        else if (mimeData->IsStrucseqs()) mimeData->SetStrucseqs().SetUser_annotations(annots);
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle())
                mimeData->SetGeneral().SetSeq_align_data().SetBundle().SetUser_annotations(annots);
            else
                mimeData->SetGeneral().SetSeq_align_data().SetCdd().SetUser_annotations(annots);
        }
    } else
        cddData->SetUser_annotations(annots);
}

void ASNDataManager::RemoveUserAnnotations(void)
{
    if (mimeData.NotEmpty()) {
        if (mimeData->IsAlignstruc()) mimeData->SetAlignstruc().ResetUser_annotations();
        else if (mimeData->IsAlignseq()) mimeData->SetAlignseq().ResetUser_annotations();
        else if (mimeData->IsStrucseq()) mimeData->SetStrucseq().ResetUser_annotations();
        else if (mimeData->IsStrucseqs()) mimeData->SetStrucseqs().ResetUser_annotations();
        else if (mimeData->IsGeneral()) {
            if (mimeData->GetGeneral().GetSeq_align_data().IsBundle())
                mimeData->SetGeneral().SetSeq_align_data().SetBundle().ResetUser_annotations();
            else
                mimeData->SetGeneral().SetSeq_align_data().SetCdd().ResetUser_annotations();
        }
    } else
        cddData->ResetUser_annotations();
}

void ASNDataManager::SetStructureAlignments(ncbi::objects::CBiostruc_annot_set *strucAligns)
{
    if (mimeData.NotEmpty() && mimeData->IsGeneral() && mimeData->GetGeneral().GetSeq_align_data().IsBundle()) {
        if (strucAligns)
            mimeData->SetGeneral().SetSeq_align_data().SetBundle().SetStrucaligns(*strucAligns);
        else
            mimeData->SetGeneral().SetSeq_align_data().SetBundle().ResetStrucaligns();
    } else if (GetInternalCDDData()) {
        if (strucAligns)
            GetInternalCDDData()->SetFeatures(*strucAligns);
        else
            GetInternalCDDData()->ResetFeatures();
    } else
        ERRORMSG("ASNDataManager::SetStructureAlignments() - can't add to this data type");
    structureAlignments = strucAligns;
}

bool ASNDataManager::AddBiostrucToASN(ncbi::objects::CBiostruc *biostruc)
{
    // if can't store add'l Biostrucs currently, try to convert to general mime if possible
    if (!biostrucList && mimeData.NotEmpty() && !mimeData->IsGeneral())
        ConvertMimeToGeneral();

    // add structure to list if there is one
    if (biostrucList) {
        biostrucList->push_back(CRef<CBiostruc>(biostruc));
        return true;
    }

    // if this is a CDD, we never store Biostrucs; but return true to pretend success
    if (IsCDD()) return true;

    return false;
}

bool ASNDataManager::ConvertMimeToGeneral(void)
{
    if (mimeData.Empty() || mimeData->IsGeneral()) {
        ERRORMSG("ASNDataManager::ConvertMimeToGeneral() - can't convert to general mime type");
        return false;
    }

    CNcbi_mime_asn1 *newMime = new CNcbi_mime_asn1();

    // copy structures
    if (biostrucList)
        newMime->SetGeneral().SetStructures() = *biostrucList; // copy list
    if (masterBiostruc) {
        newMime->SetGeneral().SetStructures().push_front(CRef<CBiostruc>(masterBiostruc));
        masterBiostruc = NULL;
    }
    biostrucList = (newMime->GetGeneral().GetStructures().size() > 0) ?
        &(newMime->SetGeneral().SetStructures()) : NULL;

    // copy alignment data into bundle
    CBundle_seqs_aligns *bundle = new CBundle_seqs_aligns();
    newMime->SetGeneral().SetSeq_align_data().SetBundle(*bundle);
    if (seqEntryList) {
        bundle->SetSequences() = *seqEntryList;
        seqEntryList = &(bundle->SetSequences());
    }
    if (structureAlignments)
        bundle->SetStrucaligns(*structureAlignments);
    if (sequenceAlignments) {
        bundle->SetSeqaligns() = *sequenceAlignments;
        sequenceAlignments = &(bundle->SetSeqaligns());
    }

    // install new root mime structure
    mimeData.Reset(newMime);
    SetDataChanged(StructureSet::eOtherData);
    return true;
}

void ASNDataManager::ReplaceUpdates(UpdateAlignList& newUpdates)
{
    // if necessary, convert mime data into general type that has a place for imports
    if (mimeData.NotEmpty() && !mimeData->IsGeneral() && newUpdates.size() > 0)
        ConvertMimeToGeneral();

    // store new updates in asn data
    if (mimeData.NotEmpty() && mimeData->IsGeneral()) {
        if (mimeData->GetGeneral().GetSeq_align_data().IsCdd()) {
            cddUpdates = &(mimeData->SetGeneral().SetSeq_align_data().SetCdd().SetPending());
            *cddUpdates = newUpdates;
        } else {
            bundleImportsFaked = newUpdates;
            // convert to plain imports to store in mime data (some data loss...)
            bundleImports = &(mimeData->SetGeneral().SetSeq_align_data().SetBundle().SetImports());
            bundleImports->clear();
            UpdateAlignList::iterator u, ue = newUpdates.end();
            for (u=newUpdates.begin(); u!=ue; ++u)
                if ((*u)->IsSetSeqannot())
                    bundleImports->push_back(CRef < CSeq_annot > (&((*u)->SetSeqannot())));
        }
    } else if (cddData.NotEmpty()) {
        cddUpdates = &(cddData->SetPending());
        *cddUpdates = newUpdates;
    } else if (newUpdates.size() > 0)
        ERRORMSG("ASNDataManager::ReplaceUpdates() - can't put updates in this data type");

    SetDataChanged(StructureSet::eUpdateData);
}

void ASNDataManager::RemoveUnusedSequences(const AlignmentSet *alignmentSet,
    const SequenceList& updateSequences)
{
    if (!alignmentSet) return; // don't do this for single structures

    if (!seqEntryList) {
        ERRORMSG("ASNDataManager::RemoveUnusedSequences() - can't find sequence list");
        return;
    }

    // update the asn sequences, keeping only those used in the multiple alignment and updates
    seqEntryList->clear();
    map < const MoleculeIdentifier *, bool > usedSeqs;
    int nStructuredSlaves = 0;

// macro to add the sequence to the list if not already present
#define CONDITIONAL_ADD_SEQENTRY(seq) do { \
    if (usedSeqs.find((seq)->identifier) == usedSeqs.end()) { \
        seqEntryList->resize(seqEntryList->size() + 1); \
        seqEntryList->back().Reset(new CSeq_entry); \
        seqEntryList->back().GetObject().SetSeq((const_cast<Sequence*>(seq))->bioseqASN.GetObject()); \
        usedSeqs[(seq)->identifier] = true; \
    } } while (0)

    // always add master first
    CONDITIONAL_ADD_SEQENTRY(alignmentSet->master);
    // add from alignmentSet slaves
    AlignmentSet::AlignmentList::const_iterator a, ae = alignmentSet->alignments.end();
    for (a=alignmentSet->alignments.begin(); a!=ae; ++a) {
        CONDITIONAL_ADD_SEQENTRY((*a)->slave);
        if ((*a)->slave->molecule) ++nStructuredSlaves;
    }

    // add from updates
    SequenceList::const_iterator s, se = updateSequences.end();
    for (s=updateSequences.begin(); s!=se; ++s)
        CONDITIONAL_ADD_SEQENTRY((*s));

    SetDataChanged(StructureSet::eSequenceData);

    // warn user if # structured slaves != # structure alignments
//    if (structureAlignments && nStructuredSlaves !=
//            structureAlignments->GetFeatures().front().GetObject().GetFeatures().size())
//        ERRORMSG("Warning: Structure alignment list does not contain one alignment per "
//            "structured sequence!\nYou should recompute structure alignments before saving "
//            "in order to sync the lists.");
}

bool ASNDataManager::WriteDataToFile(const char *filename, bool isBinary,
    string *err, ncbi::EFixNonPrint fixNonPrint) const