path_provider.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__UG__path_provider__
#define __H__UG__path_provider__
 
#include <string>
#include <map>
#include <stack>
 
#include "common/util/file_util.h"
#include "common/util/os_info.h"
 
 
namespace ug
{
 
 
enum PathTypes
{
  BIN_PATH = 0, 
  SCRIPT_PATH,
  ROOT_PATH,
  PLUGIN_PATH,
  APPS_PATH,    
 
//  always last
  MAX_PATH_CONSTANT
};
enum PathTypes {…};
 
 
class PathProvider
{
  public:
 
    static inline void set_path(PathTypes pathType, const std::string& path)
    {inst().m_map[pathType] = path;}
    static inline void set_path(PathTypes pathType, const std::string& path) {…}
 
 
    static inline const std::string& get_path(PathTypes pathType)
    {return inst().m_map[pathType];}
    static inline const std::string& get_path(PathTypes pathType) {…}
 
 
    static inline bool has_path(PathTypes pathType)
    {return inst().m_map.find(pathType) != inst().m_map.end();}
    static inline bool has_path(PathTypes pathType) {…}
 
 
    static inline const std::string& get_current_path(PathTypes defPath = BIN_PATH)
    {
      if(inst().m_curPaths.empty())
        return get_path(defPath);
      return inst().m_curPaths.top();
    }
    static inline const std::string& get_current_path(PathTypes defPath = BIN_PATH) {…}
 
    static inline bool has_current_path()
    {return !inst().m_curPaths.empty();}
    static inline bool has_current_path() {…}
 
    static inline void push_current_path(const std::string& path)
    {inst().m_curPaths.push(path);}
    static inline void push_current_path(const std::string& path) {…}
 
    static inline void pop_current_path()
    {inst().m_curPaths.pop();}
    static inline void pop_current_path() {…}
 
    static inline void clear_current_path_stack()
    {while(has_current_path()) {pop_current_path();}}
    static inline void clear_current_path_stack() {…}
 
    static inline bool get_filename_relative_to_current_path(const std::string &relativeFilename, std::string &absoluteFilename)
    {
      const char* pathSep = GetPathSeparator();
 
      if(inst().has_current_path() == false) return false;
      absoluteFilename = inst().get_current_path() + pathSep + relativeFilename;
      return FileExists(absoluteFilename.c_str());
    }
    static inline bool get_filename_relative_to_current_path(const std::string &relativeFilename, std::string &absoluteFilename) {…}
 
 
    static inline bool get_dirname_relative_to_current_path(const std::string &relativeDirname, std::string &absoluteDirname)
    {
      const char* pathSep = GetPathSeparator();
 
      if (!inst().has_current_path())
        return false;
      absoluteDirname = inst().get_current_path() + pathSep + relativeDirname;
      return DirectoryExists(absoluteDirname.c_str());
    }
    static inline bool get_dirname_relative_to_current_path(const std::string &relativeDirname, std::string &absoluteDirname) {…}
 
    static inline bool get_filename_relative_to_path(PathTypes pathType, const std::string &relativeFilename, std::string &absoluteFilename)
    {
      const char* pathSep = GetPathSeparator();
 
      if(inst().has_path(pathType) == false) return false;
      absoluteFilename = inst().get_path(pathType) + pathSep + relativeFilename;
      return FileExists(absoluteFilename.c_str());
    }
    static inline bool get_filename_relative_to_path(PathTypes pathType, const std::string &relativeFilename, std::string &absoluteFilename) {…}
 
    static inline bool get_dirname_relative_to_path(PathTypes pathType, const std::string &relativeDirname, std::string &absoluteDirname)
    {
      const char* pathSep = GetPathSeparator();
 
      if (!inst().has_path(pathType))
        return false;
      absoluteDirname = inst().get_path(pathType) + pathSep + relativeDirname;
      return DirectoryExists(absoluteDirname.c_str());
    }
    static inline bool get_dirname_relative_to_path(PathTypes pathType, const std::string &relativeDirname, std::string &absoluteDirname) {…}
  private:
    PathProvider()  {}
    PathProvider(const PathProvider&) {}
 
    static PathProvider& inst()
    {
      static PathProvider pp;
      return pp;
    }
    static PathProvider& inst() {…}
 
  private:
    std::map<PathTypes, std::string>  m_map;
    std::stack<std::string>   m_curPaths;
};
class PathProvider {…};
 
// end group ugbase_common_util
 
}// end of namespace
 
#endif