feature_panel_ds.cpp

Go to the documentation of this file.

/*  $Id: feature_panel_ds.cpp 25159 2012-01-27 17:17:16Z wuliangs $
 * ===========================================================================
 *
 *                            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:  Liangshou Wu
 *
 */

#include <ncbi_pch.hpp>
#include <gui/widgets/seq_graphic/feature_panel_ds.hpp>
#include <gui/widgets/seq_graphic/track_config_manager.hpp>

#include <gui/utils/app_job.hpp>
#include <gui/utils/app_job_impl.hpp>
#include <gui/objutils/utils.hpp>
#include <objtools/data_loaders/genbank/gbloader.hpp>
#include <corelib/ncbitime.hpp>

BEGIN_NCBI_SCOPE
USING_SCOPE(objects);

///////////////////////////////////////////////////////////////////////////////
/// CTrackInitializationJob
///////////////////////////////////////////////////////////////////////////////
class NCBI_GUIWIDGETS_SEQGRAPHIC_EXPORT CTrackInitializationJob :
        public CJobCancelable
{
public:
    typedef CAnnotMetaData::TAnnotMetaDataList TAnnotMetaDataList;

    CTrackInitializationJob(const string& desc, const ILayoutTrackFactory* factory,
        CTrackContainer* parent, CTempTrackProxy* params,
        const CObject& obj, objects::CScope& scope,
        ISGDataSourceContext* ds_context, CRenderingContext* r_cntx,
        const ILayoutTrackFactory::SExtraParams& extra_param,
        const TAnnotMetaDataList& src_annots);

    virtual ~CTrackInitializationJob(){};

    /// @name IAppJob implementation
    /// @{
    virtual EJobState                   Run();
    virtual CConstIRef<IAppJobProgress> GetProgress();
    virtual CRef<CObject>               GetResult();
    virtual CConstIRef<IAppJobError>    GetError();
    virtual string                      GetDescr() const;
    /// @}

private:
    /// @name Job results and status.
    /// @{
    CRef<CAppJobError>          m_Error;
    CRef<CTrackInitJobResult>   m_Result;
    string                      m_Desc;
    /// @}

    CConstIRef<ILayoutTrackFactory>  m_Factory;
    SConstScopedObject          m_ScopedObj;         
    CIRef<ISGDataSourceContext> m_DSContext;
    CRenderingContext*          m_RenderingCntx;
    ILayoutTrackFactory::SExtraParams m_ExtraParam;
    TAnnotMetaDataList          m_SrcAnnots;
};


///////////////////////////////////////////////////////////////////////////////
/// CAnnotMetaDataJob
///////////////////////////////////////////////////////////////////////////////
class NCBI_GUIWIDGETS_SEQGRAPHIC_EXPORT CAnnotMetaDataJob : public CJobCancelable
{
public:
    CAnnotMetaDataJob(const string& desc, CBioseq_Handle handle,
                      const string& ctx);

    virtual ~CAnnotMetaDataJob(){};

    /// @name IAppJob implementation
    /// @{
    virtual EJobState                   Run();
    virtual void                        RequestCancel();
    virtual CConstIRef<IAppJobProgress> GetProgress();
    virtual CRef<CObject>               GetResult();
    virtual CConstIRef<IAppJobError>    GetError();
    virtual string                      GetDescr() const;
    /// @}

private:
    /// @name Job results and status.
    /// @{
    CRef<CAppJobError>              m_Error;
    CRef<CAnnotMetaDataJobResult>   m_Result;
    string                          m_Desc;
    /// @}

    objects::CBioseq_Handle m_Handle;           ///< target sequence
    string                  m_ViewerCtx;
};


///////////////////////////////////////////////////////////////////////////////
/// CSeqGraphicJob implementation
///////////////////////////////////////////////////////////////////////////////
CTrackInitializationJob::CTrackInitializationJob(const string& desc,
    const ILayoutTrackFactory* factory, CTrackContainer* parent,
    CTempTrackProxy* params, const CObject& obj, objects::CScope& scope,
    ISGDataSourceContext* ds_context, CRenderingContext* r_cntx,
    const ILayoutTrackFactory::SExtraParams& extra_param,
    const TAnnotMetaDataList& src_annots)
    : m_Desc(desc)
    , m_Factory(factory)
    , m_ScopedObj(obj, scope)
    , m_DSContext(ds_context)
    , m_RenderingCntx(r_cntx)
    , m_ExtraParam(extra_param)
{
    m_SrcAnnots = src_annots;
    m_Result.Reset(new CTrackInitJobResult);
    m_Result->m_ParentTrack = parent;
    m_Result->m_TrackParams.Reset(params);
    m_Result->m_Desc = desc;
}

IAppJob::EJobState CTrackInitializationJob::Run()
{
    m_StopRequested = false;
    m_Error.Reset();
    try {
        m_Result->m_Tracks =
            m_Factory->CreateTracks(m_ScopedObj, m_DSContext,
            m_RenderingCntx, m_ExtraParam, m_SrcAnnots);
    } catch (std::exception& e) {
        m_Error.Reset(new CAppJobError("failed on initializing " +
            m_Factory->GetThisTypeInfo().GetDescr()));
        LOG_POST( Info << "CTrackInitializationJob::Run() failed job"
            << e.what());
        return eFailed;
    }

    //LOG_POST( Info << "CTrackInitializationJob::Run() completed job" );

    return eCompleted;
}

CConstIRef<IAppJobProgress> CTrackInitializationJob::GetProgress()
{
    return CConstIRef<IAppJobProgress>(NULL);
}

CRef<CObject> CTrackInitializationJob::GetResult()
{
    return CRef<CObject>(m_Result.GetPointer());
}

CConstIRef<IAppJobError> CTrackInitializationJob::GetError()
{
    return CConstIRef<IAppJobError>(m_Error.GetPointer());
}

string CTrackInitializationJob::GetDescr() const
{
    return m_Desc;
}



///////////////////////////////////////////////////////////////////////////////
/// CAnnotMetaDataJob implementation
///////////////////////////////////////////////////////////////////////////////
CAnnotMetaDataJob::CAnnotMetaDataJob(const string& desc,
                                     CBioseq_Handle handle,
                                     const string& ctx)
    : m_Desc(desc)
    , m_Handle(handle)
    , m_ViewerCtx(ctx)
{
    m_Result.Reset(new CAnnotMetaDataJobResult);
}


void CAnnotMetaDataJob::RequestCancel()
{
    m_StopRequested = true;
}


IAppJob::EJobState CAnnotMetaDataJob::Run()
{
    m_StopRequested = false;
    m_Error.Reset();
    try {
        CStopWatch sw;
        sw.Start();

        /*
        // Get complete list of NAAs using the currently fastest way.
        // We may be able to avoid this step if there is a guarrantee 
        // that each NAA comes with meta-data
        set<string> na_all;
        CGBLoaderParams param;
        string loader_name =
            CGBDataLoader::GetLoaderNameFromArgs(param);
        CDataLoader* d_loader =
            CObjectManager::GetInstance()->FindDataLoader(loader_name);
        CGBDataLoader* loader = dynamic_cast<CGBDataLoader*>(d_loader);
        _ASSERT(loader);
        if (loader) {
            na_all = loader->GetNamedAnnotAccessions(m_Handle.GetSeq_id_Handle());
        }
        */

        // Get all NAAs having meta-data
        CSeqUtils::TNAA_MetaDataMap meta_data;
        CConstRef<CSeq_id> seq_id = m_Handle.GetSeqId(); 
        CSeqUtils::GetNAAMetaData(*seq_id, meta_data,
                                  m_Handle.GetScope(), m_ViewerCtx);

        // extract the required info
        bool stop_requested = false;
        CTrackConfigManager::ParseAnnotInfo(meta_data, m_Result->m_Annots, stop_requested);

        LOG_POST(Info << "Time for retrieving NA meta-data: "
            << sw.Elapsed() << " seconds");

    } catch (std::exception& e) {
        string id_str;
        m_Handle.GetSeqId()->GetLabel(&id_str);
        LOG_POST( Info << "CAnnotMetaDataJob::Run() failed to get meta data for "
            <<  id_str << ", Details: "
            << e.what());

        // maybe there is no such thing as named annotation for
        // the given sequence type, such as a local sequence.
        // So we won't consider it as failed
    }

    return eCompleted;
}


CConstIRef<IAppJobProgress> CAnnotMetaDataJob::GetProgress()
{
    return CConstIRef<IAppJobProgress>(NULL);
}


CRef<CObject> CAnnotMetaDataJob::GetResult()
{
    return CRef<CObject>(m_Result.GetPointer());
}


CConstIRef<IAppJobError> CAnnotMetaDataJob::GetError()
{
    return CConstIRef<IAppJobError>(m_Error.GetPointer());
}


string CAnnotMetaDataJob::GetDescr() const
{
    return m_Desc;
}


///////////////////////////////////////////////////////////////////////////////
/// CFeaturePanelDS
///////////////////////////////////////////////////////////////////////////////

CFeaturePanelDS::CFeaturePanelDS(CScope& scope, const CSeq_id& id)
    : CSGGenBankDS(scope, id)
    , m_RenderingCntx(NULL)
    , m_MetaDataJob(-1)
{}


CFeaturePanelDS::~CFeaturePanelDS()
{
    DeleteMetaDataJob();
}


void CFeaturePanelDS::DeleteMetaDataJob()
{
    if (m_MetaDataJob > -1) {
        CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
        try {
            disp.DeleteJob(m_MetaDataJob);
        } catch(CAppJobException& e)  {
            switch(e.GetErrCode())  {
                case CAppJobException::eUnknownJob:
                case CAppJobException::eEngine_UnknownJob:
                    /// this is fine - job probably already finished
                    break;
                default:
                    // something wrong
                    LOG_POST(Error << "CSGGenBankDS::DeleteAllJobs() "
                        << "Error canceling job");
                    LOG_POST(e.ReportAll());
            }
        }
        m_MetaDataJob = -1;
    }
}


void CFeaturePanelDS::ClearMetaDataJobId()
{
    m_MetaDataJob = -1;
}


void CFeaturePanelDS::CreateTrack(const string& desc,
                                  const ILayoutTrackFactory* factory,
                                  CTrackContainer* parent,
                                  CTempTrackProxy* params,
                                  const ILayoutTrackFactory::SExtraParams& extra_param,
                                  const TAnnotMetaDataList& src_annots)
{
    CConstRef<CSeq_id> seq_id = m_Handle.GetSeqId();

    CRef<CTrackInitializationJob> job(
        new CTrackInitializationJob(desc, factory, parent, params,
        *seq_id, GetScope(), m_DSContext, m_RenderingCntx,
        extra_param, src_annots));
    x_LaunchJob(*job, -1);
}


void CFeaturePanelDS::GetAnnotMetaData(const string& desc, const string& context)
{
    CRef<CAnnotMetaDataJob> job(new CAnnotMetaDataJob(desc, m_Handle, context));
    if (m_Background) {
        TJobID job_id = x_BackgroundJob(*job, -1, "ObjManagerEngine");
        if (job_id > -1) {
            m_MetaDataJob = job_id;
        }
    } else {
        x_ForegroundJob(*job);
    }
}


///////////////////////////////////////////////////////////////////////////////
/// CSGFeatureDSType
///////////////////////////////////////////////////////////////////////////////

ISGDataSource*
CFeaturePanelDSType::CreateDS(SConstScopedObject& object) const
{
    const CSeq_id& id = dynamic_cast<const CSeq_id&>(object.object.GetObject());
    return new CFeaturePanelDS(object.scope.GetObject(), id);
}

string CFeaturePanelDSType::GetExtensionIdentifier() const
{
    static string sid("seqgraphic_feature_panel_ds_type");
    return sid;
}

string CFeaturePanelDSType::GetExtensionLabel() const
{
    static string slabel("Graphical View Feature Panel Data Source Type");
    return slabel;
}

bool CFeaturePanelDSType::IsSharable() const
{
    return false;
}


END_NCBI_SCOPE