gbproject_tool.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: gbproject_tool.cpp 46973 2022-03-24 13:47:42Z asztalos $
 * ===========================================================================
 *
 *                            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:  Mike DiCuccio
 *
 * File Description:
 *     Application for manipulating GBench projects.
 */
 
#include <ncbi_pch.hpp>
#include <corelib/ncbifile.hpp>
#include <corelib/ncbiapp.hpp>
#include <corelib/ncbienv.hpp>
#include <corelib/ncbiargs.hpp>
#include <serial/objistr.hpp>
#include <serial/objostr.hpp>
#include <serial/serial.hpp>
#include <objtools/readers/gff3_reader.hpp>
#include <objects/seq/Annotdesc.hpp>
#include <objects/seq/Annot_descr.hpp>
#include <objects/seq/NCBI_Sequence_module.hpp>
#include <objects/seqtable/NCBI_SeqTable_module.hpp>
#include <gui/objects/GBProjectHandle.hpp>
#include <objects/gbproj/GBProject_ver2.hpp>
#include <objects/gbproj/ProjectDescr.hpp>
#include <objects/gbproj/ProjectFolder.hpp>
#include <objects/gbproj/FolderInfo.hpp>
#include <objects/gbproj/ProjectItem.hpp>
#include <gui/objutils/label.hpp>
#include <objects/general/Date.hpp>
#include <objmgr/scope.hpp>
#include <objtools/simple/simple_om.hpp>
#include <objtools/data_loaders/genbank/gbloader.hpp>
 
#include "fileloader.hpp"
#include "projectfilewriter.hpp"
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
typedef CFormatGuess::EFormat EFormat;
unique_ptr<CProjectFileWriter> Writer;
 
class CGBProjectTool : public CNcbiApplication
{
private:
    void Init();
    int Run();
 
    void x_CreateNewProject(const CArgs& args, ESerialDataFormat fmt);
 
    void x_AddFolder(const CArgs& args, ESerialDataFormat fmt);
 
    void x_ListFolders(const CArgs& args);
 
    void x_AddItem(const CArgs& args, ESerialDataFormat fmt);
    
    void x_AddItem(CGBProjectHandle& project, const CArgs& args, const string& in_folder);
    
    void x_LoadGeneralData(CProjectItem& item, ESerialDataFormat fmt, const string& filename, const string& track_name);
    
    void x_LoadGffData(CProjectItem& item, CNcbiIstream& istr);
 
    void x_Collapse(const CArgs& args, ESerialDataFormat fmt);
 
    void x_Expand(const CArgs& args);
 
    void x_RemoveItem(const CArgs& args, ESerialDataFormat fmt);
    
    void x_RemoveFolder(const CArgs& args, ESerialDataFormat fmt);
 
    CRef<CScope> m_Scope{ nullptr };
};
 
 
void CGBProjectTool::Init()
{
    NCBI_Sequence_RegisterModuleClasses();
    NCBI_SeqTable_RegisterModuleClasses();
 
    //SetDiagPostFlag(eDPF_All);
    //SetDiagPostLevel(eDiag_Info);
 
    unique_ptr<CArgDescriptions> arg_desc(new CArgDescriptions());
    
    arg_desc->SetUsageContext(GetArguments().GetProgramBasename(),
                              "Application for manipulating GBench projects");
 
    arg_desc->AddOptionalKey("i", "InputFile",
                            "Input project file",
                            CArgDescriptions::eInputFile);
 
    arg_desc->AddOptionalKey("o", "OutputFile",
                            "Output project file",
                            CArgDescriptions::eOutputFile);
 
    arg_desc->AddFlag("noid", "disable access to genbank or id and id2");
    
    arg_desc->AddFlag("list", "List the contents of a project file");
    arg_desc->SetDependency("list", CArgDescriptions::eRequires, "i");
    
    arg_desc->AddFlag("create", "Create a new project file");
    arg_desc->SetDependency("create", CArgDescriptions::eRequires, "o");
 
    arg_desc->AddOptionalKey("title", "Title",
        "Title for new project", CArgDescriptions::eString);
 
 
    arg_desc->AddOptionalKey("expand", "expand",
        "Create a subdirectory tree from a project file", CArgDescriptions::eInputFile);
    
    arg_desc->SetDependency("expand", CArgDescriptions::eRequires, "i");
 
    arg_desc->AddDefaultKey("expand-fmt", "expand_format",
        "Format to expand project file parts out in", CArgDescriptions::eString, "asnb");
    
    arg_desc->SetConstraint("expand-fmt", 
        &((*new CArgAllow_Strings(NStr::eNocase)), "asnt", "asnb", "xml", "gtf"));
 
    arg_desc->AddOptionalKey("collapse", "collapse",
                             "Create a project file from a directory tree",
                             CArgDescriptions::eInputFile);
    arg_desc->SetDependency("collapse", CArgDescriptions::eRequires, "o");
    
    {
        arg_desc->AddOptionalKey("add", "ItemToAdd", 
            "Add an item to a project file", CArgDescriptions::eInputFile);
 
        arg_desc->AddOptionalKey("fmt", "ItemFormat",
            "Format of input item", CArgDescriptions::eString);
        
        arg_desc->SetConstraint("fmt", &(*new CArgAllow_Strings, "gff", "asn", "asnb"));
 
        arg_desc->AddOptionalKey("track", "TrackName",
            "Name of the track in GSV", CArgDescriptions::eString);
        
        arg_desc->SetDependency("add", CArgDescriptions::eRequires, "fmt");
        arg_desc->SetDependency("add", CArgDescriptions::eRequires, "i");
        arg_desc->SetDependency("add", CArgDescriptions::eRequires, "o");
        arg_desc->SetDependency("track", CArgDescriptions::eRequires, "add");
 
        arg_desc->AddOptionalKey("proj-folder", "FolderName",
            "Add item into the named folder", CArgDescriptions::eString);
        
    }
 
 
    arg_desc->AddOptionalKey("add-folder", "FolderToAdd",
                             "Create a folder in the existing project",
                             CArgDescriptions::eString);
    arg_desc->SetDependency("add-folder", CArgDescriptions::eRequires, "i");
    arg_desc->SetDependency("add-folder", CArgDescriptions::eRequires, "o");
 
    arg_desc->AddOptionalKey("rm", "RemoveItem",
                             "Remove an item from an existing project",
                             CArgDescriptions::eString);
    arg_desc->SetDependency("rm", CArgDescriptions::eRequires, "i");
    arg_desc->SetDependency("rm", CArgDescriptions::eRequires, "o");
 
    arg_desc->AddOptionalKey("rmdir", "RemoveFolder",
                             "Remove a folder from an existing project",
                             CArgDescriptions::eString);
    arg_desc->SetDependency("rmdir", CArgDescriptions::eRequires, "i");
    arg_desc->SetDependency("rmdir", CArgDescriptions::eRequires, "o");
 
    SetupArgDescriptions(arg_desc.release());
}
 
static void s_ScopeProjectFolder(const CProjectFolder& folder)
{
    if (folder.IsSetFolders()) {
        ITERATE (CProjectFolder::TFolders, iter, folder.GetFolders()) {
            s_ScopeProjectFolder(**iter);
        }
    }
 
    if (folder.IsSetItems()) {
        ITERATE (CProjectFolder::TItems, iter, folder.GetItems()) {
            Writer->AddToScope(CConstRef<CSerialObject>(((*iter)->GetObject())));
        }
    }
}
 
static void s_ExpandProjectFolder(const CProjectFolder& folder,
                                  CDir& parentDir,
                                  EFormat format,
                                  int level = 0)
{
    const string kSpacer(level * 2, ' ');
 
    string currentName = CDirEntry::ConcatPathEx(parentDir.GetPath(),
                                                 folder.GetInfo().GetTitle());
    CDir   currentDir(currentName);
    if(level == 0)  // get rid of the /Data/ dir thats always on the top when expanding
        currentDir = parentDir;
    currentDir.CreatePath();
    cout << kSpacer << "[folder] " << folder.GetInfo().GetTitle()
        << " (created: "
        << folder.GetInfo().GetCreate_date().AsCTime().AsString("M/D/Y h:m:s")
        << ")" << "    " << currentName << endl;
 
    if (folder.IsSetFolders()) {
        ITERATE (CProjectFolder::TFolders, iter, folder.GetFolders()) {
            s_ExpandProjectFolder(**iter, currentDir, format, level + 1);
        }
    }
 
    if (folder.IsSetItems()) {
        ITERATE (CProjectFolder::TItems, iter, folder.GetItems()) {
            string itemTitle;
            CLabel::GetLabel(**iter, &itemTitle);
            string itemFilename = CDirEntry::ConcatPathEx(currentDir.GetPath(), itemTitle);
            cout << kSpacer << "  " << "[item:"
                << (*iter)->GetId() << "] " << itemTitle << "  " << itemFilename << endl;
 
            Writer->WriteFile(itemFilename,
                             CConstRef<CSerialObject>(((*iter)->GetObject())),
                             format);
            //unique_ptr<CObjectOStream> ObjS(CObjectOStream::Open(format, itemFilename));
            //*ObjS << *((*iter)->GetObject());
        }
    }
}
 
bool s_Compare_DirEntry_ModDate(CDirEntry* A, CDirEntry* B)
{
    time_t mod_a, mod_b;
    A->GetTimeT(&mod_a);
    B->GetTimeT(&mod_b);
    return (mod_a < mod_b);
}
 
static string s_GetAlignTitle(const CSeq_align& align, CScope& scope)
{
    CSeq_id_Handle query_idh, subject_idh;
    query_idh = scope.GetAccVer(CSeq_id_Handle::GetHandle(align.GetSeq_id(0)));
    subject_idh = scope.GetAccVer(CSeq_id_Handle::GetHandle(align.GetSeq_id(1)));
 
    string query_label, subject_label;
    if (query_idh.GetSeqIdOrNull().IsNull()) {
        query_label = align.GetSeq_id(0).GetSeqIdString(true);
    }
    else {
        query_label = query_idh.GetSeqId()->GetSeqIdString(true);
    }
 
    if (subject_idh.GetSeqIdOrNull().IsNull()) {
        subject_label = align.GetSeq_id(1).GetSeqIdString(true);
    } 
    else {
        subject_label = subject_idh.GetSeqId()->GetSeqIdString(true);
    }
    return query_label + " x " + subject_label;
}
 
static void s_CollapseProjectFolder(CScope& scope, CGBProjectHandle& project,
    CProjectFolder& folder, CDir& dir)
{
    // when package = true, the seq-aligns will be wrapped by seq-annots.
    auto children = dir.GetEntries(kEmptyStr, CDir::fIgnoreRecursive);
 
    vector<CDirEntry*> children_vec;
    for (const auto& child : children) {
        CDirEntry* new_dir = new CDirEntry(*child);
        children_vec.push_back(new_dir);
    }
 
    sort(children_vec.begin(), children_vec.end(), s_Compare_DirEntry_ModDate);
 
    using TItemMap = multimap<string, CRef<CProjectItem>>;
    TItemMap items;
 
    string CurrLabel;
    NON_CONST_ITERATE(vector<CDirEntry*>, childIter, children_vec) {
 
        // Save the file name early, in case it is actually a symbolic link.
        CurrLabel = (*childIter)->GetName();
 
        // Then if its a link, dereference it
        if( (*childIter)->IsLink() ) {
            (*childIter)->DereferenceLink();
        }
 
        if( (*childIter)->IsDir() ) {
            CRef<CProjectFolder> childFolder(new CProjectFolder);
            childFolder->SetInfo().SetCreateDate(CTime(CTime::eCurrent));
            childFolder->SetInfo().SetTitle(CurrLabel);
            cout << "Dir   " << CurrLabel << endl;
 
            folder.SetFolders().push_back(childFolder);
            CDir childDir(**childIter);
            s_CollapseProjectFolder(scope, project, *childFolder, childDir);
        }
        else if( (*childIter)->IsFile() ) {
            cout << "File  " << CurrLabel << endl;
            CFileLoader::TSerialObjectList Objects;
            CFileLoader::LoadFile( (*childIter)->GetPath(), Objects);
 
            if(Objects.empty())
                continue;
 
            ITERATE(CFileLoader::TSerialObjectList, ObjIter, Objects) {
 
                CRef<CSerialObject> Object = *ObjIter;
                string label = CurrLabel;
 
                if(Object->GetThisTypeInfo() != NULL &&
                   Object->GetThisTypeInfo()->GetName() == "Seq-annot") {
                    CRef<CSeq_annot> Annot(static_cast<CSeq_annot*>(Object.GetPointer()));
                    if (Annot->CanGetDesc()) {
                        CConstRef<CAnnotdesc> name;
                        CConstRef<CAnnotdesc> title;
                        ITERATE(CSeq_annot::TDesc::Tdata, desciter, Annot->GetDesc().Get()) {
                            if((*desciter)->IsName()) {
                                name = *desciter;
                            } else if ((*desciter)->IsTitle()) {
                                title = *desciter;
                            }
                        }
                        if (title) {
                            label = title->GetTitle();
                        } else if (name) {
                            label = name->GetName();
                        }
                    }
                    else{
                        Annot->SetNameDesc(CurrLabel);
                        Annot->SetTitleDesc(CurrLabel);
                    }
                } 
                else if(Object->GetThisTypeInfo() != NULL &&
                          Object->GetThisTypeInfo()->GetName() == "Seq-align") {
                    CRef<CSeq_align> Align(static_cast<CSeq_align*>(Object.GetPointer()));
                    label = s_GetAlignTitle(*Align, scope);
                } 
                else if(Object->GetThisTypeInfo() != NULL &&
                          Object->GetThisTypeInfo()->GetName() == "Project-item") {
                    CRef<CProjectItem> Item(static_cast<CProjectItem*>(Object.GetPointer()));
                    items.insert(TItemMap::value_type(Item->GetLabel(), Item));
                    continue;
                }
 
                CRef<CProjectItem> childItem(new CProjectItem);
                CTime CreateTime;
                (*childIter)->GetTime(&CreateTime);
                childItem->SetCreateDate(CreateTime);
 
                if (Object->GetThisTypeInfo() == CProjectItem::GetTypeInfo()) {
                    childItem.Reset(dynamic_cast<CProjectItem*>(Object.GetPointer()));
                } else {
                    childItem->SetLabel(label);
                    childItem->SetObject(*Object);
                    cout << "    Title: " << label << endl;
                }
                items.insert(TItemMap::value_type(label, childItem));
            }
        }
    
        delete *childIter;
        *childIter = nullptr;
    }
 
    NON_CONST_ITERATE(TItemMap, it, items) {
        project.AddItem(*it->second, folder);
    }
}
 
 
CRef<CProjectFolder> s_GetOrCreateFolder(CGBProjectHandle& project,
                                    CProjectFolder& parent_folder,
                                    const string& folder_name,
                                    bool top = true)
{
    if (parent_folder.IsSetFolders()) {
        NON_CONST_ITERATE(CProjectFolder::TFolders, iter, parent_folder.SetFolders()) {
            if( (*iter)->GetInfo().GetTitle() == folder_name) {
                return (*iter); //    iter = folder.SetFolders().erase(iter);
            }
            else
                s_GetOrCreateFolder(project, **iter, folder_name, false);
        }
    }
 
    if(top) {
        CRef<CProjectFolder> folder(new CProjectFolder);
        folder->SetInfo().SetCreateDate(CTime(CTime::eCurrent));
        folder->SetInfo().SetTitle(folder_name);
        parent_folder.SetFolders().push_back(folder);
        return folder;
    }
    return CRef<CProjectFolder>();
}
 
 
int CGBProjectTool::Run()
{
    const CArgs& args = GetArgs();
 
    bool EnableID = true;
    if(args["noid"].HasValue() && args["noid"].AsBoolean())
        EnableID = false;
 
 
    CRef<CObjectManager> object_manager = CObjectManager::GetInstance();
    m_Scope.Reset(new CScope(*object_manager)); 
    m_Scope->ResetDataAndHistory();  
 
    if(EnableID) {
        CGBDataLoader::RegisterInObjectManager(*object_manager, NULL, CObjectManager::eDefault);  
        m_Scope->AddDataLoader(CGBDataLoader::GetLoaderNameFromArgs());
    }
 
    Writer.reset(new CProjectFileWriter(m_Scope));
    
 
    ESerialDataFormat saveformat = eSerial_AsnBinary;
 
    if (args["create"]) {
        x_CreateNewProject(args, saveformat);
    } 
    else if (args["add-folder"].HasValue()) {
        x_AddFolder(args, saveformat);
    } 
    else if (args["list"]) {
        x_ListFolders(args);
    } 
    else if (args["expand"].HasValue()) {
        x_Expand(args);
    } 
    else if (args["collapse"].HasValue()) {
        x_Collapse(args, saveformat);
    } 
    else if (args["add"].HasValue()) {
        x_AddItem(args, saveformat);
    } 
    else if (args["rm"].HasValue()) {
        x_RemoveItem(args, saveformat);
    } 
    else if (args["rmdir"].HasValue()) {
        x_RemoveFolder(args, saveformat);
    } 
    else {
        NCBI_THROW(CException, eUnknown, "command not yet implemented");
    }
 
    return 0;
}
 
void CGBProjectTool::x_CreateNewProject(const CArgs& args, ESerialDataFormat fmt)
{
    // create a new, 'empty' project
    CGBProject_ver2 projObj;
    CGBProjectHandle project(projObj);
 
    CTime create_time(CTime::eCurrent);
 
    /// set the project's basic descriptors
    CProjectDescr& descr = project.SetProject().SetDescr();
    descr.SetCreate_date().SetToTime(create_time);
    if (args["title"].HasValue()) {
        descr.SetTitle(args["title"].AsString());
    }
    else {
        descr.SetTitle("Default");
    }
 
    /// set the data descriptors
    CProjectFolder& data = project.SetProject().SetData();
    data.SetInfo().SetTitle("Data");
    data.SetInfo().SetCreate_date().SetToTime(create_time);
 
    /// serialize
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
}
 
void CGBProjectTool::x_AddFolder(const CArgs& args, ESerialDataFormat fmt)
{
    // add a folder to an existing project
    CGBProjectHandle project;
    {{
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }}
 
    string folder_name = args["add-folder"].AsString();
 
    CRef<CProjectFolder> folder(new CProjectFolder);
    folder->SetInfo().SetCreateDate(CTime(CTime::eCurrent));
    folder->SetInfo().SetTitle(folder_name);
 
    CProjectFolder& root = project.SetProject().SetData();
    root.SetFolders().push_back(folder);
 
    /// serialize
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
}
 
static void s_ListProjectFolder(const CProjectFolder& folder, CNcbiOstream& ostr, int level = 0)
{
    const string kSpacer(level * 2, ' ');
 
    ostr << kSpacer << "[folder] " << folder.GetInfo().GetTitle()
        << " (created: "
        << folder.GetInfo().GetCreate_date().AsCTime().AsString("M/D/Y h:m:s")
        << ")" << endl;
 
    if (folder.IsSetFolders()) {
        ITERATE(CProjectFolder::TFolders, iter, folder.GetFolders()) {
            s_ListProjectFolder(**iter, ostr, level + 1);
        }
    }
 
    if (folder.IsSetItems()) {
        ITERATE(CProjectFolder::TItems, iter, folder.GetItems()) {
            string s;
            CLabel::GetLabel(**iter, &s);
            ostr << kSpacer << "  " << "[item:"
                << (*iter)->GetId() << "] " << s << endl;
        }
    }
}
 
void CGBProjectTool::x_ListFolders(const CArgs& args)
{
    // lists the folders of an existing project
    CGBProjectHandle project;
    {
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }
 
    const CProjectFolder& folder = project.GetProject().GetData();
    CNcbiOstream& ostr = (args["o"]) ? args["o"].AsOutputFile() : NcbiCout;
    s_ListProjectFolder(folder, ostr);
}
 
void CGBProjectTool::x_AddItem(const CArgs& args, ESerialDataFormat fmt)
{
    // add an item to the project
    CGBProjectHandle project;
    {
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }
 
    string folder;
    if (args["proj-folder"].HasValue()) {
        folder = args["proj-folder"].AsString();
    }
    x_AddItem(project, args, folder);
 
    /// serialize
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
}
 
void CGBProjectTool::x_AddItem(CGBProjectHandle& project, const CArgs& args, const string& in_folder)
{
    CRef<CProjectItem> item(new CProjectItem);
    const string& fmt_str = args["fmt"].AsString();
    CNcbiIstream& istr = args["add"].AsInputFile();
    const string track_name = (args["track"]) ? args["track"].AsString() : kEmptyStr;
 
    if (fmt_str == "gff") {
        x_LoadGffData(*item, istr);
    }
    else if (fmt_str == "asn") {
        x_LoadGeneralData(*item, eSerial_AsnText, args["add"].AsString(), track_name);
    }
    else if (fmt_str == "asnb") {
        x_LoadGeneralData(*item, eSerial_AsnBinary, args["add"].AsString(), track_name);
    }
    else {
        NCBI_THROW(CException, eUnknown, "The file format is not supported!");
    }
 
    // add the new item into the project (under a folder if given)
    if (!in_folder.empty()) {
        CProjectFolder& root = project.SetProject().SetData();
 
        // check if there is a folder named 'in_folder'
        bool folder_found = false;
        if (root.IsSetFolders()) {
            NON_CONST_ITERATE(CProjectFolder::TFolders, iter, root.SetFolders()) {
                if ((*iter)->GetInfo().GetTitle() == in_folder) {
                    project.AddItem(*item, **iter);
                    folder_found = true;
                    break;
                }
            }
        }
 
        // otherwise add a new folder
        if (!folder_found) {
            CRef<CProjectFolder> folder(new CProjectFolder);
            folder->SetInfo().SetCreateDate(CTime(CTime::eCurrent));
            folder->SetInfo().SetTitle(in_folder);
            root.SetFolders().push_back(folder);
            project.AddItem(*item, *folder);
        }
    }
    else {
        project.AddItem(*item, project.SetData());
    }
}
 
void CGBProjectTool::x_LoadGffData(CProjectItem& item, CNcbiIstream& istr)
{
    CReaderBase::TReaderFlags flags = 0;
    CReaderBase::TAnnots annots;
 
    CGff3Reader reader(flags);
    reader.ReadSeqAnnots(annots, istr);
    if (!annots.empty()) {
        item.SetObject(*annots.front());
    }
}
 
void CGBProjectTool::x_LoadGeneralData(CProjectItem& item, ESerialDataFormat fmt, 
    const string& filename, const string& track_name)
{
    CNcbiIfstream instr(filename.c_str(), IOS_BASE::in | IOS_BASE::binary);
    if (!instr.is_open() || !instr.good()) {
        return;
    }
    unique_ptr<CObjectIStream> os(CObjectIStream::Open(fmt, instr));
    string obj_type = os->ReadFileHeader();
    os->SetStreamPos(0);
 
    if (obj_type == "Seq-annot") {
        CRef<CSeq_annot> obj(new CSeq_annot);
        *os >> *obj;
        if (!track_name.empty()) {
            obj->SetNameDesc(track_name);
        }
        item.SetObject(*obj);
    }
    else if (obj_type == "Seq-loc") {
        CRef<CSeq_loc> obj(new CSeq_loc);
        *os >> *obj;
        item.SetObject(*obj);
    }
    else if (obj_type == "Seq-id") {
        CRef<CSeq_id> obj(new CSeq_id);
        *os >> *obj;
        item.SetObject(*obj);
    } 
    else if (obj_type == "Seq-align") {
        // combine all Seq-aligns into a single Seq-annot
 
        CFileLoader::TSerialObjectList objects;
        CFileLoader::LoadFile(filename, objects);
 
        CRef<CSeq_annot> result(new CSeq_annot);
        for (auto& obj_it : objects) {
            auto type_info = obj_it->GetThisTypeInfo();
            if (!type_info) {
                NCBI_THROW(CException, eUnknown, "Data contains non-serializable object");
            }
            if (type_info->GetName() != "Seq-align") {
                NCBI_THROW(CException, eUnknown, "Data should only contain Seq-align objects");
            }
 
            CRef<CSeq_align> align(dynamic_cast<CSeq_align*>(obj_it.GetNCPointer()));
            result->SetData().SetAlign().push_back(align);
        }
 
        if (result->IsSetData() && !result->GetData().GetAlign().empty()) {
            CFile file(filename);
            string name = file.GetName();
            if (!track_name.empty()) {
                result->SetNameDesc(track_name);
            }
            else {
                result->SetNameDesc(name);
            }
            result->SetTitleDesc(name);
            item.SetObject(*result);
        }
    }
    else {
        NCBI_THROW(CException, eUnknown, "The data type is not supported!");
    }
}
 
 
void CGBProjectTool::x_Collapse(const CArgs& args, ESerialDataFormat fmt)
{
    // Reads in all files under the given directory and writes them into a
    // combined Gbench project file to the -o file
    CGBProjectHandle project(*new CGBProject_ver2);
    
    if (args["i"].HasValue()) {
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
        // do nothing
        }
    }
    
    CDir parent(args["collapse"].AsString());
    CRef<CProjectFolder> folder = CRef<CProjectFolder>(&project.SetProject().SetData());
    if (args["proj-folder"].HasValue()) {
        string ProjFolder = args["proj-folder"].AsString();
        folder = s_GetOrCreateFolder(project, *folder, ProjFolder);
    }
 
    if (!args["i"].HasValue())
        project.SetDescr().SetTitle(parent.GetBase());
 
    if (args["title"].HasValue())
        project.SetDescr().SetTitle(args["title"].AsString());
 
    project.SetDescr().SetCreateDate(CTime(CTime::eCurrent));
    project.SetDescr().SetModifiedDate(CTime(CTime::eCurrent));
    s_CollapseProjectFolder(*m_Scope, project, *folder, parent);
 
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
 
}
 
void CGBProjectTool::x_Expand(const CArgs& args)
{
    // Expands (saves the folders to directories and items to files)
    // of an existing project
    CGBProjectHandle project;
    {
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }
 
    EFormat format = CFormatGuess::eBinaryASN;//eSerial_AsnBinary;
    string formatstr = args["expand-fmt"].AsString();
    if (formatstr == "asnb")
        format = CFormatGuess::eBinaryASN;
    else if (formatstr == "asnt")
        format = CFormatGuess::eTextASN;
    else if (formatstr == "xml")
        format = CFormatGuess::eXml;
    //else if(formatstr == "json")
    //    format = eSerial_Json;
    else if (formatstr == "gtf")
        format = CFormatGuess::eGtf;
 
    const CProjectFolder& folder = project.GetProject().GetData();
    CDir parent(args["expand"].AsString());
    s_ScopeProjectFolder(folder);
    s_ExpandProjectFolder(folder, parent, format);
}
 
static void s_RemoveItem(CGBProjectHandle& project,
    CProjectFolder& folder,
    const string& label)
{
    if (folder.IsSetFolders()) {
        NON_CONST_ITERATE(CProjectFolder::TFolders, iter, folder.SetFolders()) {
            s_RemoveItem(project, **iter, label);
        }
    }
 
    if (folder.IsSetItems()) {
        NON_CONST_ITERATE(CProjectFolder::TItems, iter, folder.SetItems()) {
            string s;
            CLabel::GetLabel(**iter, &s);
 
            if (s == label) {
                NCBI_THROW(CException, eUnknown,
                    "FIXME: CGBProjectHandle::RemoveItem() not supported");
                //project.RemoveItem(**iter);
                return;
                //iter = folder.SetItems().erase(iter);
            }
        }
    }
}
 
void CGBProjectTool::x_RemoveItem(const CArgs& args, ESerialDataFormat fmt)
{
    // remove an item from the project
    CGBProjectHandle project;
    { 
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }
 
    CProjectFolder& folder = project.SetProject().SetData();
    string label = args["rm"].AsString();
    s_RemoveItem(project, folder, label);
 
    /// serialize
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
}
 
static void s_RemoveFolder(CGBProjectHandle& project,
    CProjectFolder& folder,
    const string& label)
{
    if (folder.IsSetFolders()) {
        NON_CONST_ITERATE(CProjectFolder::TFolders, iter, folder.SetFolders()) {
            if ((*iter)->GetInfo().GetTitle() == label)
                iter = folder.SetFolders().erase(iter);
            else
                s_RemoveFolder(project, **iter, label);
        }
    }
}
 
void CGBProjectTool::x_RemoveFolder(const CArgs& args, ESerialDataFormat fmt)
{
    // remove a folder from the project
    CGBProjectHandle project;
    {
        CNcbiIstream& istr = args["i"].AsInputFile();
        if (!project.Load(istr, 0)) {
            NCBI_THROW(CException, eUnknown, "failed to read project");
        }
    }
 
    CProjectFolder& folder = project.SetProject().SetData();
    string label = args["rmdir"].AsString();
    s_RemoveFolder(project, folder, label);
 
    /// serialize
    CNcbiOstream& ostr = args["o"].AsOutputFile();
    project.Save(ostr, fmt);
}
 
 
 
END_NCBI_SCOPE
USING_SCOPE(ncbi);
 
 
int NcbiSys_main(int argc, ncbi::TXChar* argv[])
{
    return CGBProjectTool().AppMain(argc, argv);
}