PathResolver Class Reference

#include <PathResolver.h>

Public Types
enum	SearchPathStatus { Ok , EnvironmentVariableUndefined , UnknownDirectory }
enum	SearchType { LocalSearch , RecursiveSearch }

Static Public Member Functions
static std::string	find_file (const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
static std::string	find_file_from_list (const std::string &logical_file_name, const std::string &search_list, SearchType search_type=LocalSearch)
static std::string	find_directory (const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
static std::string	find_directory_from_list (const std::string &logical_file_name, const std::string &search_list, SearchType search_type=LocalSearch)
static SearchPathStatus	check_search_path (const std::string &search_path)

Detailed Description

Definition at line 6 of file PathResolver.h.

Member Enumeration Documentation

SearchPathStatus

enum PathResolver::SearchPathStatus

Enumerator
Ok
EnvironmentVariableUndefined
UnknownDirectory

Definition at line 8 of file PathResolver.h.

{ Ok, EnvironmentVariableUndefined, UnknownDirectory } SearchPathStatus;

SearchType

enum PathResolver::SearchType

Enumerator
LocalSearch
RecursiveSearch

Definition at line 10 of file PathResolver.h.

{ LocalSearch, RecursiveSearch } SearchType;

Member Function Documentation

check_search_path()

PathResolver::SearchPathStatus PathResolver::check_search_path ( const std::string & search_path )

static

• search_path the name of a path-like environment variable

Returns

the result of the verification. Can be one of Ok, EnvironmentVariableUndefined, UnknownDirectory

Definition at line 512 of file PathResolver.cxx.

                                                              {
  const char* path_env = ::getenv( search_path.c_str() );
 
  if ( path_env == 0 ) return ( EnvironmentVariableUndefined );
 
#ifdef WIN32
  static const char path_separator = ';';
#else
  static const char path_separator = ':';
#endif
 
  std::string path_list( path_env );
 
  std::string::size_type pos = 0;
 
  for ( int i = 0;; i++ )
  {
    bool ending = false;
 
    std::string::size_type next = path_list.find( path_separator, pos );
 
    std::string path = path_list.substr( pos, next - pos );
 
    if ( next == std::string::npos )
    {
      path   = path_list.substr( pos );
      ending = true;
    }
    else
    {
      path = path_list.substr( pos, next - pos );
      pos  = next + 1;
    }
 
    std::string real_name = "";
 
    if ( !PR_test_exist( path, real_name, PR_directory ) ) { return ( UnknownDirectory ); }
 
    if ( ending ) break;
  }
 
  return ( Ok );
}

Referenced by PathResolverCheckSearchPath().

find_directory()

std::string PathResolver::find_directory ( const std::string & logical_file_name, const std::string & search_path, SearchType search_type = LocalSearch )

static

• logical_file_name the name of the directory to locate in the search path
• search_path the name of a path-like environment variable
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located directory or empty string if not found

Definition at line 487 of file PathResolver.cxx.

                                                                           {
  const char* path_env = ::getenv( search_path.c_str() );
 
  std::string path_list;
 
  if ( path_env != 0 ) { path_list = path_env; }
 
  return ( find_directory_from_list( logical_file_name, path_list, search_type ) );
}

Referenced by PathResolverFindDirectory().

find_directory_from_list()

std::string PathResolver::find_directory_from_list ( const std::string & logical_file_name, const std::string & search_list, SearchType search_type = LocalSearch )

static

• logical_file_name the name of the directory to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located directory or empty string if not found

Definition at line 499 of file PathResolver.cxx.

                                                                                     {
  std::string result;
 
  if ( !PR_find_from_list( logical_file_name, search_list, PR_directory, search_type,
                           result ) )
  { result = ""; }
 
  return ( result );
}

Referenced by find_directory(), and PathResolverFindDirectoryFromList().

find_file()

std::string PathResolver::find_file ( const std::string & logical_file_name, const std::string & search_path, SearchType search_type = LocalSearch )

static

• logical_file_name the name of the file to locate in the search path
• search_path the name of a path-like environment variable
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located file or empty string if not found

Definition at line 464 of file PathResolver.cxx.

                                                                                            {
  const char* path_env = ::getenv( search_path.c_str() );
 
  std::string path_list;
 
  if ( path_env != 0 ) { path_list = path_env; }
 
  return ( find_file_from_list( logical_file_name, path_list, search_type ) );
}

Referenced by main(), PathResolverFindDataFile(), PathResolverFindFile(), and PathResolverFindXMLFile().

find_file_from_list()

std::string PathResolver::find_file_from_list ( const std::string & logical_file_name, const std::string & search_list, SearchType search_type = LocalSearch )

static

• logical_file_name the name of the file to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located file or empty string if not found

Definition at line 475 of file PathResolver.cxx.

                                                                                {
  std::string result;
 
  if ( !PR_find_from_list( logical_file_name, search_list, PR_regular_file, search_type,
                           result ) )
  { result = ""; }
 
  return ( result );
}

Referenced by find_file(), and PathResolverFindFileFromList().

---

The documentation for this class was generated from the following files:

• PathResolver.h
• PathResolver.cxx