label.cpp

ncbi源码

//
//
// seq-annots are complicated
//
//

static void s_GetAnnotType(const CSeq_annot& annot, string* label)
{
    const CSeq_annot::TData& annot_data = annot.GetData();
    switch (annot_data.Which()) {
    case CSeq_annot::TData::e_Ftable:
        *label += "Feature Table";
        break;

    case CSeq_annot::TData::e_Align:
        *label += "Alignment";
        break;

    case CSeq_annot::TData::e_Graph:
        *label += "Graph";
        break;

    case CSeq_annot::TData::e_Ids:
        *label += "IDs";
        break;
    case CSeq_annot::TData::e_Locs:
        *label += "Locations";
        break;

    default:
        *label = "Annotation";
        return;
    }
}


static void s_GetAnnotContent(const CSeq_annot& annot, string* label)
{
    //
    // check for formatted comments in descriptors first
    //
    if (annot.IsSetDesc()) {
        ITERATE (CSeq_annot::TDesc::Tdata, iter, annot.GetDesc().Get()) {
            switch ((*iter)->Which()) {
            case CAnnotdesc::e_Title:
                *label = (*iter)->GetTitle();
                return;

            default:
                break;
            }
        }
    }

    //
    // default handling
    //
    string str;
    size_t items = 0;
    const CSeq_annot::TData& annot_data = annot.GetData();
    switch (annot_data.Which()) {
    case CSeq_annot::TData::e_Ftable:
        str = "Feature Table, ";
        items = annot_data.GetFtable().size();
        break;

    case CSeq_annot::TData::e_Align:
        str = "Alignment, ";
        items = annot_data.GetAlign().size();
        break;

    case CSeq_annot::TData::e_Graph:
        str = "Graph, ";
        items = annot_data.GetGraph().size();
        break;

    case CSeq_annot::TData::e_Ids:
        str = "IDs, ";
        items = annot_data.GetIds().size();
        break;
    case CSeq_annot::TData::e_Locs:
        str = "Locations, ";
        items = annot_data.GetLocs().size();
        break;

    default:
        *label = "Annotation";
        return;
    }

    str += NStr::IntToString(items);
    if (items != 1) {
        str += " entries";
    } else {
        str += " entry";
    }

    *label += str;

}


class CSeq_annotHandler : public ILabelHandler
{
public:
    void GetLabel(const CObject& obj, string* label,
                  CLabel::ELabelType type, CScope* scope) const
    {
        const CSeq_annot* annot  = dynamic_cast<const CSeq_annot*> (&obj);
        if ( !annot ) {
            return;
        }

        switch (type) {
        case CLabel::eType:
            s_GetAnnotType(*annot, label);
            return;

        case CLabel::eContent:
            s_GetAnnotContent(*annot, label);
            return;

        case CLabel::eBoth:
            s_GetAnnotType(*annot, label);
            *label += ": ";
            s_GetAnnotContent(*annot, label);
            break;
        }
    }
};


static void s_GetAlignmentType(const CSeq_align& align, string* label)
{
    switch (align.GetSegs().Which()) {
    default:
    case CSeq_align::TSegs::e_not_set:
        *label += "[Unknown]";
        break;
    case CSeq_align::TSegs::e_Denseg:
        *label += "[Dense-seg]";
        break;
    case CSeq_align::TSegs::e_Dendiag:
        *label += "[Dense-diag]";
        break;
    case CSeq_align::TSegs::e_Std:
        *label += "[Standard-seg]";
        break;
    case CSeq_align::TSegs::e_Packed:
        *label += "[Packed-seg]";
        break;
    case CSeq_align::TSegs::e_Disc:
        *label += "[Discontinuous]";
        break;
    }
}

static void s_GetAlignmentContent(const CSeq_align& align, string* label,
                                  CScope* scope)
{
    switch (align.GetSegs().Which()) {
    default:
    case CSeq_align::TSegs::e_not_set:
        *label += "unknown contents";
        break;
    case CSeq_align::TSegs::e_Denseg:
        {{
            string str;
            size_t seqs = align.GetSegs().GetDenseg().GetIds().size();
            if (seqs < 4) {
                ITERATE (CDense_seg::TIds, iter,
                         align.GetSegs().GetDenseg().GetIds()) {
                    const CSeq_id* best_id = *iter;
                    if (scope) {
                        CBioseq_Handle handle =
                            scope->GetBioseqHandle(**iter);
                        if ( !handle ) {
                            continue;
                        }
                        best_id = &sequence::GetId(handle,
                                                   sequence::eGetId_Best);
                    }
                    if ( !str.empty() ) {
                        str += " x ";
                    }
                    best_id->GetLabel(&str, CSeq_id::eContent);
                }
            } else {
                str = NStr::IntToString(seqs) + " sequences.";
            }

            *label += str;
        }}
        break;
    case CSeq_align::TSegs::e_Dendiag:
        *label += "[Dense-diag]";
        break;
    case CSeq_align::TSegs::e_Std:
        *label += "[Standard-seg]";
        break;
    case CSeq_align::TSegs::e_Packed:
        *label += "[Packed-seg]";
        break;
    case CSeq_align::TSegs::e_Disc:
        *label += "[Discontinuous]";
        break;
    }
}


class CSeq_alignHandler : public ILabelHandler
{
public:
    void GetLabel(const CObject& obj, string* label,
                  CLabel::ELabelType type, CScope* scope) const
    {
        const CSeq_align* align  = dynamic_cast<const CSeq_align*> (&obj);
        if ( !align ) {
            return;
        }

        switch (type) {
        case CLabel::eType:
            s_GetAlignmentType(*align, label);
            return;

        case CLabel::eContent:
            s_GetAlignmentContent(*align, label, scope);
            return;

        case CLabel::eBoth:
            s_GetAlignmentType(*align, label);
            *label += ' ';
            s_GetAlignmentContent(*align, label, scope);
            break;
        }
    }
};


#if 0


// retrieve a string label for an abstract object
string CSeqUtils::GetLabel(const CObject& obj, CScope* scope)
{
    {{
        // standard seq-annot label formatting
        const CSeq_annot* annot  = dynamic_cast<const CSeq_annot*> (&obj);
        if (annot) {
            const CSeq_annot::TData& annot_data = annot->GetData();

            string label;
            size_t items = 0;
            switch (annot_data.Which()) {
            case CSeq_annot::TData::e_Ftable:
                label = "Feature Table, ";
                items = annot_data.GetFtable().size();
                break;

            case CSeq_annot::TData::e_Align:
                label = "Alignment, ";
                items = annot_data.GetAlign().size();
                break;

            case CSeq_annot::TData::e_Graph:
                label = "Graph, ";
                items = annot_data.GetGraph().size();
                break;

            case CSeq_annot::TData::e_Ids:
                label = "IDs, ";
                items = annot_data.GetIds().size();
                break;
            case CSeq_annot::TData::e_Locs:
                label = "Locations, ";
                items = annot_data.GetLocs().size();
                break;

            default:
                return "Annotation";
            }

            label += NStr::IntToString(items);
            if (items != 1) {
                label += " entries";
            } else {
                label += " entry";
            }

            return label;
        }

    }}

    {{
        // standard seq-align label formatting
        const CSeq_align* align  = dynamic_cast<const CSeq_align*> (&obj);
        if (align) {
            string label;

            switch (align->GetSegs().Which()) {
            case CSeq_align::TSegs::e_not_set:
                label = "Alignment: unknown type";
                break;

            case CSeq_align::TSegs::e_Denseg:
                {{
                    size_t seqs = align->GetSegs().GetDenseg().GetIds().size();
                    if (seqs < 4) {
                        ITERATE (CDense_seg::TIds, iter,
                                 align->GetSegs().GetDenseg().GetIds()) {
                            const CSeq_id* best_id = *iter;
                            if (scope) {
                                CBioseq_Handle handle =
                                    scope->GetBioseqHandle(**iter);
                                if ( !handle ) {
                                    continue;
                                }
                                best_id =
                                    &sequence::GetId(handle,
                                                     sequence::eGetId_Best);
                            }
                            if ( !label.empty() ) {
                                label += " x ";
                            }
                            best_id->GetLabel(&label,
                                              CSeq_id::eContent);
                        }

                        label = "Alignment: " + label;
                    } else {
                        label = "Alignment: " +
                            NStr::IntToString(seqs) +
                            " sequences.";
                    }
                }}
                break;

            case CSeq_align::TSegs::e_Dendiag:
                label = "Alignment: dense-diagonal";
                break;

            case CSeq_align::TSegs::e_Std:
                label = "Alignment: standard-seg";
                break;

            case CSeq_align::TSegs::e_Packed:
                label = "Alignment: packed-seg";
                break;

            case CSeq_align::TSegs::e_Disc:
                label = "Alignment: discontinuous";
                break;
            }

            return label;
        }

    }}

    {{
        // generic unhandled CSerialObject
        const CSerialObject* ser_obj =
            dynamic_cast<const CSerialObject*> (&obj);
        if (ser_obj) {
            return ser_obj->GetThisTypeInfo()->GetName();
        }
    }}

    /*{{  // should never be called that way: GetLabel(CLayoutObject obj);
        // layout objects
        const CLayoutObject* layout = dynamic_cast<const CLayoutObject*>(&obj);
        if (layout) {
            return GetLabel(layout->GetObject()), scope);
        }
    }}*/

    // generic object handling
    return ("Object");
}


#endif




//
// force registration at load
//

struct SForceRegister
{
    SForceRegister()
    {
        CLabel::RegisterLabelHandler(*CSeq_id::GetTypeInfo(),     *new CSeq_idHandler());
        CLabel::RegisterLabelHandler(*CSeq_loc::GetTypeInfo(),    *new CSeq_locHandler());
        CLabel::RegisterLabelHandler(*CBioseq::GetTypeInfo(),     *new CBioseqHandler());
        CLabel::RegisterLabelHandler(*CBioseq_set::GetTypeInfo(), *new CBioseq_setHandler());
        CLabel::RegisterLabelHandler(*CSeq_feat::GetTypeInfo(),   *new CSeq_featHandler());
        CLabel::RegisterLabelHandler(*CSeq_entry::GetTypeInfo(),  *new CSeq_entryHandler());
        CLabel::RegisterLabelHandler(*CSeq_annot::GetTypeInfo(),  *new CSeq_annotHandler());
        CLabel::RegisterLabelHandler(*CSeq_align::GetTypeInfo(),  *new CSeq_alignHandler());
    }
};

static SForceRegister sm_ForceRegistration;

END_NCBI_SCOPE


/*
 * ===========================================================================
 * $Log: label.cpp,v $
 * Revision 1000.0  2004/06/01 21:20:46  gouriano
 * PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.4
 *
 * Revision 1.4  2004/05/21 22:27:44  gorelenk
 * Added PCH ncbi_pch.hpp
 *
 * Revision 1.3  2004/05/14 14:23:15  dicuccio
 * When determining a label for a seq-id, only try to resolve GI-based seq-ids;
 * all others can be considered "good enough"
 *
 * Revision 1.2  2004/05/07 15:38:54  dicuccio
 * Fixed alignment labels lost in previous commit
 *
 * Revision 1.1  2004/04/30 11:48:16  dicuccio
 * Initial commit - split out from src/gui/utils
 *
 * Revision 1.1  2004/04/20 19:16:33  dicuccio
 * Initial revision
 *
 * ===========================================================================
 */