src/gui/objutils/objtype_converters.cpp

Go to the documentation of this file.

/*  $Id: objtype_converters.cpp 14892 2007-08-29 14:14:42Z dicuccio $
 * ===========================================================================
 *
 *                            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.
 *
 * ===========================================================================
 *
 * Authors: Roman Katargin
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>
#include <serial/iterator.hpp>
#include <serial/objectiter.hpp>
#include <util/resize_iter.hpp>
#include <gui/utils/init_registrar.hpp>
#include <gui/objutils/object_factory.hpp>
#include <gui/objutils/objects_interface.hpp>

#include <objects/general/Dbtag.hpp>
#include <objects/general/Date_std.hpp>
#include <objects/general/Dbtag.hpp>
#include <objects/seqfeat/Genetic_code.hpp>
#include <objects/seqfeat/Genetic_code_table.hpp>
#include <objects/seqfeat/Seq_feat.hpp>
#include <objects/seqfeat/SeqFeatXref.hpp>
#include <objmgr/util/seq_loc_util.hpp>
#include <objmgr/feat_ci.hpp>

#include "conv_seq_loc.cpp"


BEGIN_NCBI_SCOPE
USING_SCOPE(objects);

// CDefaultTypeConverter

class CDefaultTypeConverter : public CObject, public IObjTypeConverter
{
public:
    virtual CObjectInfo ConvertFromString (IObjTypeConverterContext* context,
                                           const string& value);

    virtual string ConvertToString (IObjTypeConverterContext* context,
                                    CConstObjectInfo& value);
private:
    string ClassToString    (IObjTypeConverterContext* context,
                             CConstObjectInfo& info);
    string PrimitiveToString(IObjTypeConverterContext* context,
                             CConstObjectInfo& info);
    string ContainerToString(IObjTypeConverterContext* context,
                             CConstObjectInfo& info);
};

CObjectInfo CDefaultTypeConverter::ConvertFromString (
    IObjTypeConverterContext* context, const string& value)
{
    CObjectInfo info;
    return info;
}

string CDefaultTypeConverter::ConvertToString (
    IObjTypeConverterContext* context, CConstObjectInfo& value)
{
    if (!value)
        return "N/A";

    switch(value.GetTypeFamily()) {
    case eTypeFamilyClass:
        return "[" + value.GetTypeInfo()->GetName() + "]";
    case eTypeFamilyPrimitive :
        return PrimitiveToString(context, value);
    case eTypeFamilyChoice :
        {
            CConstObjectInfo var = *value.GetCurrentChoiceVariant();
            if (var.GetTypeFamily() == eTypeFamilyClass)
                return ClassToString(context, var);
            return ConvertToString(context, var);
        }
    case eTypeFamilyContainer:
        return ContainerToString(context, value);
    case eTypeFamilyPointer:
        {
            CConstObjectInfo pointed = value.GetPointedObject();
            if (pointed.GetTypeFamily() == eTypeFamilyClass)
                return ClassToString(context, pointed);
            return ConvertToString(context, pointed);
        }
    }
    return "Invalid object";
}

string CDefaultTypeConverter::PrimitiveToString
    (IObjTypeConverterContext* context, CConstObjectInfo& info)
{
    string value = "N/A";
    switch (info.GetPrimitiveValueType()) {
    case ePrimitiveValueSpecial:        // null, void
        value = "NULL";
        break;
    case ePrimitiveValueBool:           // bool
        value = NStr::BoolToString(info.GetPrimitiveValueBool());
        break;
    case ePrimitiveValueChar:           // char
        value = info.GetPrimitiveValueChar();
        break;
    case ePrimitiveValueInteger:        // (signed|unsigned) (char|short|int|long)
        if ( info.IsPrimitiveValueSigned() ) {
            NStr::Int8ToString(value, info.GetPrimitiveValueInt8());
        } else {
            NStr::UInt8ToString(value, info.GetPrimitiveValueUint8());
        }
        break;
    case ePrimitiveValueReal:           // float|double
        NStr::DoubleToString(value, info.GetPrimitiveValueDouble());
        break;
    case ePrimitiveValueString:         // string|char*|const char*
        info.GetPrimitiveValueString(value);
        break;
    case ePrimitiveValueEnum:           // enum
        try {
            info.GetPrimitiveValueString(value);
        } catch (CSerialException&) {
            NStr::IntToString(value, info.GetPrimitiveValueInt());
        }
        break;
    case ePrimitiveValueOctetString:    // vector<(signed|unsigned)? char>
        {{
            vector<char> octet;
            info.GetPrimitiveValueOctetString(octet);
            CNcbiOstrstream os;
            for (CConstResizingIterator<vector<char> > it(octet.begin(), octet.end(), 4); !it.AtEnd(); ++it) {
                os << hex << *it;
            }
            value = CNcbiOstrstreamToString(os);
        }}
        break;
    default:
        break;
    }
    return value;
}

string CDefaultTypeConverter::ClassToString
    (IObjTypeConverterContext* context, CConstObjectInfo& info)
{
    CIRef<objects::IObjTypeConverter>
        conv(CreateInterface<IObjTypeConverter>(info));
    return conv->ConvertToString(context, info);
}

string CDefaultTypeConverter::ContainerToString
    (IObjTypeConverterContext* context, CConstObjectInfo& info)
{
    vector<string> values;
    for (CConstObjectInfo::CElementIterator it = info.BeginElements(); it; ++it)
    {
        CConstObjectInfo elem_info = *it;
        values.push_back(ConvertToString(context, elem_info));
    }
    return NStr::Join(values, ",");
}

// CDbtagTypeConverter

class CDbtagTypeConverter : public CObject, public IObjTypeConverter
{
public:
    virtual CObjectInfo ConvertFromString (IObjTypeConverterContext* context,
                                           const string& value);

    virtual string ConvertToString (IObjTypeConverterContext* context,
                                    CConstObjectInfo& value);
};

CObjectInfo CDbtagTypeConverter::ConvertFromString (
    IObjTypeConverterContext* context, const string& value)
{
    CObjectInfo info;
    return info;
}

string CDbtagTypeConverter::ConvertToString (
    IObjTypeConverterContext* context, CConstObjectInfo& value)
{
    string str;
    const CDbtag* dbTag = reinterpret_cast<const CDbtag*>(value.GetObjectPtr());
    dbTag->GetLabel(&str);
    return str;
}

// CDateTypeConverter

class CDateTypeConverter : public CObject, public IObjTypeConverter
{
public:
    virtual CObjectInfo ConvertFromString (IObjTypeConverterContext* context,
                                           const string& value);

    virtual string ConvertToString (IObjTypeConverterContext* context,
                                    CConstObjectInfo& value);
};

CObjectInfo CDateTypeConverter::ConvertFromString (
    IObjTypeConverterContext* context, const string& value)
{
    CObjectInfo info;
    return info;
}

string CDateTypeConverter::ConvertToString (
    IObjTypeConverterContext* context, CConstObjectInfo& value)
{
    string str;
    const CDate_std* date = reinterpret_cast<const CDate_std*>(value.GetObjectPtr());
    date->GetDate(&str, "%M/%D/%Y");
    return str;
}

// CSeq_idTypeConverter

class CSeq_idTypeConverter : public CObject, public IObjTypeConverter
{
public:
    virtual CObjectInfo ConvertFromString (IObjTypeConverterContext* context,
                                           const string& value);

    virtual string ConvertToString (IObjTypeConverterContext* context,
                                    CConstObjectInfo& value);
};

CObjectInfo CSeq_idTypeConverter::ConvertFromString (
    IObjTypeConverterContext* context, const string& value)
{
    CObjectInfo info;
    return info;
}

string CSeq_idTypeConverter::ConvertToString (
    IObjTypeConverterContext* context, CConstObjectInfo& value)
{
    string str;
    const CSeq_id* id = reinterpret_cast<const CSeq_id*>(value.GetObjectPtr());
    return id->AsFastaString();
}

// CGenetic_code

class CGenetic_codeTypeConverter : public CObject, public IObjTypeConverter
{
public:
    virtual CObjectInfo ConvertFromString (IObjTypeConverterContext* context,
                                           const string& value);

    virtual string ConvertToString (IObjTypeConverterContext* context,
                                    CConstObjectInfo& value);
};

CObjectInfo CGenetic_codeTypeConverter::ConvertFromString (
    IObjTypeConverterContext* context, const string& value)
{
    CObjectInfo info;
    return info;
}

string CGenetic_codeTypeConverter::ConvertToString (
    IObjTypeConverterContext* context, CConstObjectInfo& value)
{
    string str;

    const CGenetic_code* code = reinterpret_cast<const CGenetic_code*>(value.GetObjectPtr());
    str = code->GetName();
    int id = code->GetId();

    const CGenetic_code_table& code_table = CGen_code_table::GetCodeTable();
    const CGenetic_code_table::Tdata& codes = code_table.Get();

    bool idFound = false;
    int idByName = 0;
    ITERATE (CGenetic_code_table::Tdata, it, codes) {
        if ((*it)->GetId() == id)
            idFound = true;

        if (!str.empty() && (*it)->GetName() == str)
            idByName = (*it)->GetId();
    }

    if (!idFound)
        id = (idByName != 0) ? idByName : 1;

    ITERATE (CGenetic_code_table::Tdata, it, codes) {
        if ((*it)->GetId() == id) {
            str = (*it)->GetName();
            break;
        }
    }

    return str;
}

// CSeq_feat IExtProperty

class CSeq_feat_ExtProperty : public CObject, public IExtProperty
{
public:
    virtual CConstObjectInfo GetProperty (
        const char* propName, const CObject* obj, CScope& scope);
};

CConstObjectInfo CSeq_feat_ExtProperty::GetProperty (
            const char* propName, const CObject* obj, CScope& scope)
{
    CConstObjectInfo info;
    const CSeq_feat* feat = dynamic_cast<const CSeq_feat*>(obj);
    if (!feat)
        return info;

    if (strcmp(propName, "@protein") == 0) {
        const CProt_ref* protRef = feat->GetProtXref();

        if (feat->IsSetProduct()) {
            const CSeq_loc& product = feat->GetProduct();
            int dist = numeric_limits<int>::max();
            CFeat_CI it(scope, product, SAnnotSelector(CSeqFeatData::e_Prot));
            for (; it; ++it) {
                const CSeq_loc& loc = it->GetLocation();
                sequence::ECompare comp = sequence::Compare(product, loc, &scope);
                if (comp == sequence::eSame) {
                    protRef = &it->GetOriginalFeature().GetData().GetProt();
                    break;
                }
                else if (comp == sequence::eContains) {
                    int tmp = sequence::GetLength(product, &scope) -
                        sequence::GetLength(loc, &scope);
                    if (tmp < dist) {
                        dist = tmp;
                        protRef = &it->GetOriginalFeature().GetData().GetProt();
                    }
                }

            }
        }

        info = ConstObjectInfo(*protRef);
    }

    return info;
}

// CSeq_loc IExtProperty

class CSeq_loc_ExtProperty : public CObject, public IExtProperty
{
public:
    virtual CConstObjectInfo GetProperty (
        const char* propName, const CObject* obj, CScope& scope);
};

CConstObjectInfo CSeq_loc_ExtProperty::GetProperty (
            const char* propName, const CObject* obj, CScope& scope)
{
    CConstObjectInfo info;
    const CSeq_loc* loc = dynamic_cast<const CSeq_loc*>(obj);
    if (!loc)
        return info;

    if (strcmp(propName, "@id") == 0) {
        const CSeq_id& id = sequence::GetId(*loc, &scope);
        CBioseq_Handle hnd = scope.GetBioseqHandle(id);
        if (hnd)  return ConstObjectInfo(id);
    }

    return info;
}

static void init()
{
    CObjectFactory::RegisterDefaultFactory(
            typeid(IObjTypeConverter).name(),
            new CFactory<CDefaultTypeConverter>());

    CObjectFactory::RegisterMultiFactory(
            CDbtag::GetTypeInfo(),
            typeid(IObjTypeConverter).name(),
            new CFactory<CDbtagTypeConverter>());

    CObjectFactory::RegisterMultiFactory(
            CDate_std::GetTypeInfo(),
            typeid(IObjTypeConverter).name(),
            new CFactory<CDateTypeConverter>());

    CObjectFactory::RegisterMultiFactory(
            CSeq_id::GetTypeInfo(),
            typeid(IObjTypeConverter).name(),
            new CFactory<CSeq_idTypeConverter>());

    CObjectFactory::RegisterMultiFactory(
            CGenetic_code::GetTypeInfo(),
            typeid(IObjTypeConverter).name(),
            new CFactory<CGenetic_codeTypeConverter>());

    CObjectFactory::RegisterMultiFactory(
            CSeq_feat::GetTypeInfo(),
            typeid(IExtProperty).name(),
            new CFactory<CSeq_feat_ExtProperty>());

    CObjectFactory::RegisterMultiFactory(
            CSeq_loc::GetTypeInfo(),
            typeid(IExtProperty).name(),
            new CFactory<CSeq_loc_ExtProperty>());
}

ADD_INIT_FUNC(init)

END_NCBI_SCOPE

---