src/gui/utils/system_path.cpp

Go to the documentation of this file.

/*  $Id: system_path.cpp 17696 2008-09-04 00:04:03Z 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:  Robert G. Smith
 *
 * File Description:
 *    CSystemPath -- System dependent functions needed by CGBenchApp, the main
 *                         application class for GBENCH
 */

#include <ncbi_pch.hpp>
#include <gui/utils/system_path.hpp>

#include <corelib/ncbiapp.hpp>
#include <corelib/ncbienv.hpp>
#include <corelib/ncbifile.hpp>

#if defined(NCBI_OS_DARWIN)
#   ifdef NCBI_COMPILER_METROWERKS
#   define __NOEXTENSIONS__
#   endif
#   include <Carbon/Carbon.h>
#endif

BEGIN_NCBI_SCOPE

CSystemPath::TAliasMap CSystemPath::sm_AliasMap;

void CSystemPath::BindAlias(const string& alias, const string& path)
{
    sm_AliasMap[alias] = path;
}


//
// ResolvePath()
// this function performs any standard app-specific directory mapping
// so that we can use a series of standard aliases for directory names
//
string CSystemPath::ResolvePath(const string& path)
{
    string  path1, path2;
    string  path_delim("\\/");
    NStr::SplitInTwo(path, path_delim, path1, path2);
    if ( !path1.empty() ) {
        return ResolvePath(path1, path2);
    }

    return path;
}


string CSystemPath::ResolvePath(const string& path,
                                const string& subdir)
{
    string ret_val(path);
    TAliasMap::const_iterator it = sm_AliasMap.find(path);
    if (it != sm_AliasMap.end()) {
        ret_val = it->second;
    } else {
        if (ret_val == "<std>") {
            ret_val = GetStdPath();
        } else if (ret_val == "<home>") {
            ret_val = GetHomePath();
        } else if (ret_val == "<pkgdir>") {
            ret_val = GetStdPath();
            ret_val += CDir::GetPathSeparator();
            ret_val += "packages";
        } else if (ret_val == "<res>") {
            ret_val = GetResourcePath();
        }
    }

    if ( !subdir.empty() ) {
        ret_val += CDirEntry::GetPathSeparator();
        ret_val += subdir;
    }
    return ret_val;
}


//
// ResolvePathExisting ensures that a named file exists
//

template <class iterator>
string x_ResolveExisting(iterator begin, iterator end)
{
    for ( ;  begin != end;  ++begin) {
        string p(*begin);
        p = NStr::TruncateSpaces(p);
        string tmp = CSystemPath::ResolvePath(p);

        // check for existence
        CDirEntry entry(tmp);
        if (entry.Exists()) {
            return tmp;
        }
    }
    return string();
}

string CSystemPath::ResolvePathExisting(const string& path,
                                        const string& delim)
{
    list<string> toks;
    NStr::Split(path, delim, toks);
    return x_ResolveExisting(toks.begin(), toks.end());
}


string CSystemPath::ResolvePathExisting(const vector<string>& paths)
{
    return x_ResolveExisting(paths.begin(), paths.end());
}


string CSystemPath::ResolvePathExisting(const list<string>& paths)
{
    return x_ResolveExisting(paths.begin(), paths.end());
}


// the GBench installation directory. Usually the parent of the App Path.
// corresponds to the <std> alias in ResolvePath().
string CSystemPath::GetStdPath(void)
{
    string ret_val;
    CNcbiApplication  *myApp = CNcbiApplication::Instance();
    _ASSERT(myApp);

    // First, was the value set in the environment variable $NCBI_GBENCH_HOME
    ret_val = myApp->GetEnvironment().Get(string("NCBI_GBENCH_HOME"));

    if (ret_val.empty()) {

        // Next, look at the application's own location.
        ret_val = myApp->GetArguments().GetProgramDirname();

        if (!ret_val.empty()) {
            // strip off the bin directory, if it is there.
            string::size_type pos = ret_val.rfind("bin");
            if (pos != string::npos  &&  pos == ret_val.length() - 4) {
                ret_val.erase(pos);
            }

            // Remove trailing "/"
            while ( (pos = ret_val.find_last_of("\\/")) ==
                     ret_val.length() - 1) {
                ret_val.erase(pos);
            }
        }

        // Hmmm... We aren't where we should be.
        if (ret_val.empty()) {
            LOG_POST(Warning
                     << "Can't identify the application's execution path.  "
                     "Some components may be unavailable.");
        }
    }
    return ret_val;
}


string CSystemPath::GetResourcePath()
{
    string path = GetStdPath();
    path += CDirEntry::GetPathSeparator();
    path += "share";
    path += CDirEntry::GetPathSeparator();
    path += "gbench";
    return path;
}


string CSystemPath::GetUserPath(void)
{
    return CDir::GetHome();
}


// The place gbench keeps stuff.
// corresponds to the <home> alias in ResolvePath().
//   Is NOT the same as the user's home directory.
//   That is returned by CDir::GetHome()
string CSystemPath::GetHomePath(void)
{
    string ret_val(GetUserPath());
#if defined(NCBI_OS_UNIX)   &&  ! defined(NCBI_OS_DARWIN)
    ret_val += ".gbench2";
#elif defined(NCBI_OS_DARWIN)
    OSErr       err;
    FSRef       appsuppFSRef;
    char        appsuppPath[1024];


    // Get the path to the Application Support folder for this user.
    //
    err = FSFindFolder(kUserDomain, kApplicationSupportFolderType, kCreateFolder,
                     &appsuppFSRef);
    if (err == noErr) {
        err = FSRefMakePath(&appsuppFSRef, (UInt8 *) appsuppPath, 1024);
    }
    if (err == noErr) {
        ret_val = appsuppPath;
        // not a hidden folder
        ret_val = CDirEntry::MakePath(ret_val, "gbench2");
    } else {
        // Problems getting the Mac Application Support folder?
        // use ~/.gbench/ just like on other Unixes.
        ret_val = CDirEntry::MakePath(ret_val, ".gbench2");
    }

#elif defined(NCBI_OS_MSWIN)
    ret_val += "GenomeWorkbench2";
#else
#error "platform unrecognized"
#endif
    return ret_val;
}


///
/// PATH variable manipulators
///
void CSystemPath::AddToPath(const string& path, EPathMode mode)
{
    CNcbiApplication* app = CNcbiApplication::Instance();
    string base_path;
    if (app) {
        base_path = app->GetEnvironment().Get("PATH");
    } else {
        const char* p = getenv("PATH");
        if (p) {
            base_path = p;
        }
    }

    const char path_sep =
#ifdef NCBI_OS_MSWIN
        ';'
#else
        ':'
#endif
        ;

    string::size_type pos = base_path.find(path);
    if ( (pos == 0  && mode == ePath_Prepend)  ||
         (pos + path.length() == base_path.length()  &&  mode == ePath_Append) ) {
        return;
    }

    while ( (pos = base_path.find(path, pos)) != string::npos) {
        if (pos > 0  &&  base_path[pos - 1] != path_sep) {
            pos += path.length();
            continue;
        }
        if (pos + path.length() < base_path.length()  &&  base_path[pos + 1] != path_sep) {
            pos += path.length();
            continue;
        }

        base_path.erase(pos, path.length());
    }

    switch (mode) {
    case ePath_Prepend:
        {{
            string p(path);
            p += path_sep;
            p += base_path;
            base_path = p;
        }}
        break;

    default:
    case ePath_Append:
        base_path += path_sep;
        base_path += path;
        break;
    }

    if (app) {
        CNcbiEnvironment& env = app->SetEnvironment();
        env.Set("PATH", base_path);
    } else {
        /// this does potentially leak, but the ANSI standard on putenv is unclear
        /// on the handling of the memory passed to putenv, and thus it is safer
        /// to leak a small amount than risk a bad pointer passed to the C runtime
        base_path = "PATH=" + base_path;
        putenv(strdup(base_path.c_str()));
    }
}


END_NCBI_SCOPE

---