workspace.cpp

Go to the documentation of this file.

/*  $Id: workspace.cpp 25238 2012-02-14 16:11:43Z ucko $

 * ===========================================================================
 *
 *                            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:  Andrey Yazhuk
 *
 * File Description:
 *
 */

#include <ncbi_pch.hpp>

#include <gui/core/workspace.hpp>

#include <gui/core/project_service.hpp>
#include <gui/core/project_service_types.hpp>

#include <gui/core/document.hpp>

#include <gui/objects/GBWorkspace.hpp>
#include <gui/objects/WorkspaceFolder.hpp>
#include <gui/objects/GBProjectHandle.hpp>
#include <gui/objects/ProjectDescr.hpp>
#include <gui/objects/ProjectItem.hpp>
#include <gui/objects/ProjectFolder.hpp>
#include <gui/objects/FolderInfo.hpp>
#include <gui/objects/GBProject_ver2.hpp>

#include <objects/general/Date.hpp>

#include <serial/iterator.hpp>

#include <corelib/ncbifile.hpp>
#include <corelib/ncbitime.hpp>

#include <gui/widgets/wx/wx_utils.hpp>

#include <wx/filename.h>

BEGIN_NCBI_SCOPE

USING_SCOPE(objects);

///////////////////////////////////////////////////////////////////////////////
/// CWorkspaceConstPrx

CWorkspaceConstPrx::CWorkspaceConstPrx(objects::CGBWorkspace& workspace,
                                       CProjectService& service,
                                       bool get_lock)
:   m_Workspace(&workspace),
    m_Service(&service)
{
    m_Sw.Start();
    m_OrigThreadID = CThread::GetSelf();

    if(get_lock)    {
        m_Service->x_GetWorkspaceLock().ReadLock();
        //LOG_POST(Info << "CWorkspaceConstPrx constructor " << this << " got READ lock");
    }
}


CWorkspaceConstPrx::~CWorkspaceConstPrx()
{
    //LOG_POST(Info << "CWorkspaceConstPrx destructor " << this);

    m_Service->x_GetWorkspaceLock().Unlock();
    m_Sw.Stop();

    //int t = 1000 * m_Sw.Elapsed();
    //LOG_POST(Info << "CWorkspaceConstPrx destructor " << t << " ms");
}


CWorkspaceConstPrx::TId CWorkspaceConstPrx::GetId()
{
    x_ValidateCall();

    return m_Workspace->GetId();
}


string CWorkspaceConstPrx::GetName()
{
    x_ValidateCall();

    return m_Workspace->SetDescr().SetTitle();
}


string CWorkspaceConstPrx::GetDescr()
{
    x_ValidateCall();

    CProjectDescr& descr = m_Workspace->SetDescr();
    if( ! descr.IsSetComment())   {
        descr.SetComment(kEmptyStr);
    }
    return descr.GetComment();
}


CTime CWorkspaceConstPrx::GetCreateTime()
{
    x_ValidateCall();

    CProjectDescr& descr = m_Workspace->SetDescr();
    return descr.GetCreate_date().AsCTime();
}


CTime CWorkspaceConstPrx::GetModifiedTime()
{
    x_ValidateCall();

    CProjectDescr& descr = m_Workspace->SetDescr();
    return descr.GetModified_date().AsCTime();
}


bool CWorkspaceConstPrx::IsDirty() const
{
    x_ValidateCall();

    return m_Workspace->IsDirty();
}


wxString CWorkspaceConstPrx::GetFilename() const
{
    x_ValidateCall();

    return FnToWxString(m_Workspace->GetFilename());
}


CRef<CWorkspaceFolderConstPrx>
    CWorkspaceConstPrx::FindWorkspaceFolderById_C(CWorkspaceFolderConstPrx::TId folder_id)
{
    x_ValidateCall();

    CRef<CWorkspaceFolderConstPrx> root = GetRootFolder_C();
    return root->FindChildFolderById_C(folder_id, true);
}


CRef<CProjectFolderConstPrx>
    CWorkspaceConstPrx::FindProjectFolderById_C(CWorkspaceFolderConstPrx::TId /*folder_id*/)
{
    x_ValidateCall();

    CRef<CProjectFolderConstPrx> folder_prx;
    _ASSERT(false); //TODO
    return folder_prx;
}


CRef<CWorkspaceFolderConstPrx> CWorkspaceConstPrx::GetRootFolder_C()
{
    x_ValidateCall();

    CWorkspaceFolder& folder = m_Workspace->SetWorkspace();
    return CRef<CWorkspaceFolderConstPrx>(new CWorkspaceFolderConstPrx(folder, *this));
}


// converts given absolute path to a relative path using Workspace path as the base.
// If Workspace has not been saved - return absolute path
wxString CWorkspaceConstPrx::ToRelativePath(const wxString& abs_path)
{
    x_ValidateCall();

    if (abs_path.StartsWith(wxT("http://")) || abs_path.StartsWith(wxT("ftp://")))
        return abs_path;

    wxFileName absolute(abs_path);
    if (absolute.IsRelative())
        return abs_path;

    wxString ws_path  = GetFilename();
    if (ws_path.size() != 0) {
        wxString ws_dir = wxFileName(ws_path).GetPath();
        wxFileName relative(abs_path);
        relative.MakeRelativeTo(ws_dir);
        return relative.GetFullPath();
    }
    return abs_path;
}

// converts given relative path to an absolute path using Workspace path as the base.
wxString CWorkspaceConstPrx::ToAbsolutePath(const wxString& rel_path)
{
    x_ValidateCall();

    if (rel_path.StartsWith(wxT("http://")) || rel_path.StartsWith(wxT("ftp://")))
        return rel_path;

    wxFileName absolute(rel_path);
    if (absolute.IsAbsolute())
        return rel_path;

    wxString ws_path  = GetFilename();
    if (ws_path.size() != 0) {
        wxString ws_dir = wxFileName(ws_path).GetPath();
        absolute.MakeAbsolute(ws_dir);
        return absolute.GetFullPath();
    }

    return rel_path;
}

/// Visitor that accumulates Project Handles in a container
class CDocumentAccumulator : public CWorkspaceFolder::IProjectVisitor
{
public:
    typedef CWorkspaceConstPrx::EProjectState TState;

    CDocumentAccumulator(TState state)
        : m_State(state)  {}

    virtual bool Visit(objects::CGBProjectHandle& project)
    {
        CGBDocument* doc = dynamic_cast<CGBDocument*>(&project);

        _ASSERT(doc);

        if(doc) {
            bool loaded = doc->IsLoaded();
            bool exclude =
                (m_State == CWorkspaceConstPrx::eLoaded  &&  ! loaded)  ||
                (m_State == CWorkspaceConstPrx::eUnloaded  &&  loaded);
            if( ! exclude)  {
                m_Docs.push_back(CRef<CGBDocument>(doc));
            }
        }
        return true; // continue
    }

public:
    TState m_State;
    vector< CRef<CGBDocument> > m_Docs;
};


void CWorkspaceConstPrx::GetProjects_C(TProjectConstPrxVector& projects,
                                       EProjectState state)
{
    x_ValidateCall();

    CDocumentAccumulator acc(state);
    CRef<CWorkspaceFolderConstPrx> rfolder(GetRootFolder_C());
    rfolder->x_ForEachProject(acc, true);

    for(  size_t i = 0;  i < acc.m_Docs.size();  i++  ) {
        CGBDocument& doc = *acc.m_Docs[i];
        CRef<CProjectConstPrx> prx(new CProjectConstPrx(doc, this));
        projects.push_back(prx);
    }
}


void CWorkspaceConstPrx::GetProjects(TProjectPrxVector& projects,
                                     EProjectState state)
{
    x_ValidateCall();

    CDocumentAccumulator acc(state);
    CRef<CWorkspaceFolderConstPrx> rfolder(GetRootFolder_C());
    rfolder->x_ForEachProject(acc, true);

    for(  size_t i = 0;  i < acc.m_Docs.size();  i++  ) {
        CGBDocument& doc = *acc.m_Docs[i];
        CRef<CProjectPrx> prx(new CProjectPrx(doc, this));
        projects.push_back(prx);
    }
}


void CWorkspaceConstPrx::GetProjectIds(vector<TProjectId>& ids,
                                       EProjectState state)
{
    x_ValidateCall();

    CDocumentAccumulator acc(state);
    CRef<CWorkspaceFolderConstPrx> rfolder(GetRootFolder_C());
    rfolder->x_ForEachProject(acc, true);

    for(  size_t i = 0;  i < acc.m_Docs.size();  i++  ) {
        CGBDocument& doc = *acc.m_Docs[i];
        TProjectId id = doc.GetId();
        ids.push_back(id);
    }
}


CRef<CProjectConstPrx> CWorkspaceConstPrx::FindProjectById_C(TProjectId prj_id)
{
    x_ValidateCall();

    CRef<CProjectConstPrx> res;
    if(m_Workspace->CanGetWorkspace())   {
        CRef<CWorkspaceFolderConstPrx> folder = GetRootFolder_C();
        res = folder->FindProjectById_C(prj_id, true);
    }
    return res;
}


CRef<CProjectPrx> CWorkspaceConstPrx::FindProjectById(TProjectId prj_id)
{
    x_ValidateCall();

    CRef<CProjectPrx> res;
    if(m_Workspace->CanGetWorkspace())   {
        CRef<CWorkspaceFolderConstPrx> folder = GetRootFolder_C();
        res = folder->FindProjectById(prj_id, true);
    }
    return res;
}


CRef<CProjectPrx> CWorkspaceConstPrx::FindProjectByFilename(const wxString& filename)
{
    x_ValidateCall();

    CRef<CWorkspaceFolderConstPrx> root = GetRootFolder_C();
    CRef<CProjectPrx> project = root->FindProjectByFilename(filename, true);
    return project;
}


CRef<CProjectConstPrx> CWorkspaceConstPrx::FindProjectByScope_C(CScope* scope)
{
    x_ValidateCall();

    CRef<CProjectConstPrx> prx;
    if(scope)   {
        CGBProjectHandle* project = m_Workspace->GetProjectFromScope(*scope);
        CGBDocument* doc = dynamic_cast<CGBDocument*>(project);
        if(doc) {
            prx.Reset(new CProjectConstPrx(*doc, this));
        }
    }
    return prx;
}


CRef<CProjectPrx> CWorkspaceConstPrx::FindProjectByScope(CScope* scope)
{
    x_ValidateCall();

    CRef<CProjectPrx> prx;
    if(scope)   {
        CGBProjectHandle* project = m_Workspace->GetProjectFromScope(*scope);
        CGBDocument* doc = dynamic_cast<CGBDocument*>(project);
        if(doc) {
            prx.Reset(new CProjectPrx(*doc, this));
        }
    }
    return prx;
}


void CWorkspaceConstPrx::x_OnProjectChanged(CProjectPrx& project)
{
    x_ValidateCall();

    CProjectPrx::TId prj_id = project.GetId();
    m_Service->x_OnProjectChanged(prj_id);
}


CProjectService* CWorkspaceConstPrx::x_GetProjectService()
{
    return m_Service;
}


CRWLock& CWorkspaceConstPrx::x_GetProjectsLock()
{
    return m_Service->x_GetProjectsLock();
}


void CWorkspaceConstPrx::x_ValidateCall() const
{
    CThread::TID id = CThread::GetSelf();

    if(id != m_OrigThreadID)    {
        _ASSERT(false);
        NCBI_THROW(CProjectServiceException, eThreadAffinityError,
                   "Workspace Proxy can only be used on the thread on which\
                   it was created.");
    }
}


///////////////////////////////////////////////////////////////////////////////
/// CWorkspacePrx
static const char* kNotSerialMsg = "Cannot create a project - input objects is not a CSerialObject";
static const char* kProjectExistsMsg = "Cannot create a project - a project with the given id already exists";

CWorkspacePrx::CWorkspacePrx(CGBWorkspace& workspace, CProjectService& service)
:   CWorkspaceConstPrx(workspace, service, false) // do not get read lock
{
    m_Service->x_GetWorkspaceLock().WriteLock();
    // LOG_POST(Info << "CWorkspacePrx constructor " << this << " got WRITE lock");
}


CWorkspacePrx::~CWorkspacePrx()
{
    //LOG_POST(Info << "CWorkspacePrx destructor " << this);
    // do not unlock here, ~CWorkspaceConstPrx will do it for us
}


void CWorkspacePrx::SetName(const string& title)
{
    x_ValidateCall();

    m_Workspace->SetDescr().SetTitle(title);
    x_OnWorkspaceChanged();
}


void CWorkspacePrx::SetDescr(const string& descr)
{
    x_ValidateCall();

    m_Workspace->SetDescr().SetComment(descr);
    x_OnWorkspaceChanged();
}


void CWorkspacePrx::SetCreateTime(const CTime& time)
{
    x_ValidateCall();

    CDate date(time);
    m_Workspace->SetDescr().SetCreate_date(date);

    x_OnWorkspaceChanged();
}


void CWorkspacePrx::SetModifiedTime(const CTime& time)
{
    x_ValidateCall();

    CDate date(time);
    m_Workspace->SetDescr().SetModified_date().Assign(date);

    x_OnWorkspaceChanged();
}


void CWorkspacePrx::SetFilename(const wxString& filename)
{
    x_ValidateCall();

    // update all project paths so that they remain correct
    for (CTypeIterator<CGBProjectHandle> it(*m_Workspace);  it;  ++it)   {
        CGBProjectHandle& handle = *it;
        CGBDocument* doc = dynamic_cast<CGBDocument*>(&handle);
        doc->SetFileName(ToAbsolutePath(doc->GetFileName()));
    }

    m_Workspace->SetFilename(FnToStdString(filename));

    for (CTypeIterator<CGBProjectHandle> it(*m_Workspace);  it;  ++it)   {
        CGBProjectHandle& handle = *it;
        CGBDocument* doc = dynamic_cast<CGBDocument*>(&handle);
        doc->SetFileName(ToRelativePath(doc->GetFileName()));
    }

    x_OnWorkspaceChanged();
}


CRef<CWorkspaceFolderPrx> CWorkspacePrx::GetRootFolder()
{
    x_ValidateCall();

    CWorkspaceFolder& folder = m_Workspace->SetWorkspace();
    return CRef<CWorkspaceFolderPrx>(new CWorkspaceFolderPrx(folder, *this));
}


CRef<CWorkspaceFolderPrx>
CWorkspacePrx::FindWorkspaceFolderById(CWorkspaceFolderPrx::TId folder_id)
{
    x_ValidateCall();

    CRef<CWorkspaceFolderPrx> root = GetRootFolder();
    return root->FindChildFolderById(folder_id, true);
}


CRef<CProjectFolderPrx>
CWorkspacePrx::FindProjectFolderById(CProjectFolderPrx::TId /*folder_id*/)
{
    x_ValidateCall();

    CRef<CProjectFolderPrx> folder_prx;
    _ASSERT(false); //TODO
    return folder_prx;
}


CRef<CProjectPrx> CWorkspacePrx::CreateNewProject()
{
    x_ValidateCall();

    TProjectId id = CGBDocument::GetNextId();
    TObjectsSet objs;
    return CreateNewProject(id, objs);
}


CRef<CProjectPrx> CWorkspacePrx::CreateNewProject(TProjectId id)
{
    x_ValidateCall();

    TObjectsSet objs;
    return CreateNewProject(id, objs);
}


CRef<CProjectPrx> CWorkspacePrx::CreateNewProject(TProjectId id, TObjectsSet& objs)
{
    x_ValidateCall();

    //LOG_POST(Info << "CWorkspacePrx::CreateNewProject()  project id " << id);
    // make sure all objects are Serial Objects

    vector<CSerialObject*> ser_objects;
    NON_CONST_ITERATE(TObjectsSet, obj, objs) {
        CSerialObject* ser_obj = const_cast<CSerialObject*>(obj->GetPointer());

        if(ser_obj) {
            ser_objects.push_back(ser_obj);
        } else {
            NCBI_THROW(CException, eUnknown, kNotSerialMsg); // TODO throw special exception here
        }
    }

    /// make sure Project with the given id does not exist
    CRef<CProjectPrx> project = FindProjectById(id);

    if(project)  {  // TODO throw special exception here
        NCBI_THROW(CException, eUnknown, kProjectExistsMsg);
    }

    CGBProject_ver2* prj_obj = new CGBProject_ver2();
    CRef<CGBDocument> doc(new CGBDocument(m_Service, id, *prj_obj));
    doc->CreateProjectScope();

    // initialize project data
    doc->SetDescr().SetTitle("New Project");
    CTime now(CTime::eCurrent);

    CDate date(now);
    doc->SetCreateDate(date);
    doc->SetModifiedDate(date);

    project.Reset(new CProjectPrx(*doc, NULL));

    NON_CONST_ITERATE(vector<CSerialObject*>, it, ser_objects) {
        CSerialObject& ser_obj = **it;
        CRef<CProjectFolderPrx> data = project->GetDataFolder();
        data->AddProjectItem("", ser_obj);
    }

    //LOG_POST(Info << "Create CGBDocument " << doc.GetPointer());
    return project;
}


CRef<CProjectPrx> CWorkspacePrx::CreateNewProject(const wxString& abs_path)
{
    x_ValidateCall();

    //LOG_POST(Info << "CWorkspacePrx::CreateNewProject(" << abs_path << ")");
    CRef<CGBDocument> doc(new CGBDocument(m_Service));

    wxString rel_path = ToRelativePath(abs_path);
    doc->SetFileName(rel_path);

    // do not initialize data - we will read it from the file
    //LOG_POST(Info << "Create CGBDocument " << doc.GetPointer());

    CRef<CProjectPrx>  project(new CProjectPrx(*doc, NULL));
    return project;
}


void CWorkspacePrx::AddProject(CGBDocument& doc)
{
    x_ValidateCall();

    CRef<CProjectPrx> project(new CProjectPrx(doc, this));
    AddProject(*project);
}


/// this attached a new fully created project to the workspace
void CWorkspacePrx::AddProject(CProjectPrx& project)

{
    x_ValidateCall();

    CGBDocument* doc = project.x_GetDocument();

    if(project.IsLoaded())  {
        // make sure the project name is set and unique
        project.x_FixProjectTitle();
    }

    x_InsertProjectHandle(*doc);

    if(project.IsLoaded())  {
        m_Workspace->AddScopeToIndex(*doc);
        m_Service->x_ConnectDocument(*doc);
    }

    x_OnProjectChanged(project); //TODO incremental

    // we only send update if this a new project
    if(m_Workspace->IsDirty())  {
        x_OnWorkspaceChanged();
    }
}


void CWorkspacePrx::RemoveProject(TProjectId id, bool reset_hist_async)
{
    x_ValidateCall();

    CRef<CProjectPrx> project = FindProjectById(id);

    if(project->IsLoaded()) {
        UnloadProject(*project, reset_hist_async);
    }
    x_RemoveFromFolder(m_Workspace->SetWorkspace(), id);

    x_OnProjectChanged(*project);

    x_OnWorkspaceChanged();
}


void CWorkspacePrx::UnloadAllProjects()
{
    x_ValidateCall();

    CDocumentAccumulator acc(eLoaded);
    CRef<CWorkspaceFolderConstPrx> rfolder(GetRootFolder_C());
    rfolder->x_ForEachProject(acc, true);

    for(  size_t i = 0;  i < acc.m_Docs.size();  i++  ) {
        CGBDocument& doc = *acc.m_Docs[i];
        CRef<CProjectPrx> prx(new CProjectPrx(doc, this));
        UnloadProject(*prx);
    }
}


void CWorkspacePrx::x_InsertProjectHandle(CGBProjectHandle& project)
{
    x_ValidateCall();

    CRef<CWorkspaceFolderPrx> root = GetRootFolder();

    TProjectId id = project.GetId();
    CRef<CProjectPrx> project_prx = root->FindProjectById(id, true);

    if( ! project_prx) {
        // this project handle is not attached yet
        wxString fname = FnToWxString(project.GetFilename());

        // find the project by its filename
        if ( ! fname.empty() ) {
            project_prx = root->FindProjectByFilename(fname, true);
        }

        if ( ! project_prx)    {
            // this a new project - insert
            if(project.IsLoaded())  {
                // make sure the name is unique
                CProjectDescr& descr = project.SetDescr();
                string name = descr.GetTitle();
                string new_name = m_Workspace->MakeUniqueProjectTitle(name);
                descr.SetTitle(new_name);
            }
            root->x_AddProject(project);

            m_Workspace->SetDirty(true);
        }
    }
}


bool CWorkspacePrx::LoadProject(CProjectPrx& project)
{
    x_ValidateCall();

    if(project.IsLoaded())  {
        NCBI_THROW(CProjectServiceException, eInvalidOperation,
                   "Cannot load project - it is already loaded.");
    }
    if(project.x_LoadData())    {
        m_Workspace->AddScopeToIndex(*project.x_GetDocument());

        CGBDocument* doc = project.x_GetDocument();
        m_Service->x_ConnectDocument(*doc);

        x_OnProjectChanged(project);
        return true;
    }
    return false;
}


void CWorkspacePrx::UnloadProject(CProjectPrx& project, bool reset_hist_async)
{
    x_ValidateCall();

    if( ! project.IsLoaded())  {
        NCBI_THROW(CProjectServiceException, eInvalidOperation,
            "Cannot unload project - it is not loaded.");
    }

    CGBDocument* doc = project.x_GetDocument();
    m_Service->x_DisconnectDocument(project, reset_hist_async);

    m_Workspace->RemoveScopeFromIndex(*doc);

    project.x_UnloadData();

    x_OnProjectChanged(project);
}


// TODO
bool CWorkspacePrx::x_RemoveFromFolder(CWorkspaceFolder& folder, TProjectId prj_id)
{
    x_ValidateCall();

    if (folder.IsSetFolders()) {
        NON_CONST_ITERATE(CWorkspaceFolder::TFolders, iter, folder.SetFolders()) {
            if (x_RemoveFromFolder(**iter, prj_id)) {
                return true;
            }
        }
    }

    if (folder.IsSetProjects()) {
        NON_CONST_ITERATE(CWorkspaceFolder::TProjects, it, folder.SetProjects())    {
            if ((*it)->GetId() == prj_id) {
                folder.SetProjects().erase(it);
                return true;
            }
        }
    }
    return false;
}


void CWorkspacePrx::x_OnWorkspaceChanged()
{
    x_ValidateCall();

    m_Workspace->SetDirty(true);
    TId id = m_Workspace->GetId();
    m_Service->x_OnWorkspaceChanged(id);
}


void CWorkspacePrx::x_OnWorkspaceFolderChanged(CWorkspaceFolderPrx& /*folder*/)
{
    x_ValidateCall();

    m_Workspace->SetDirty(true);

    // TODO - on folder changed
    TId id = m_Workspace->GetId();
    m_Service->x_OnWorkspaceChanged(id);
}


END_NCBI_SCOPE