marley::FileManager Class Reference

Singleton class that handles file searches. More...

#include <FileManager.hh>

Public Member Functions
	FileManager (const FileManager &)=delete
	Deleted copy constructor.
	FileManager (FileManager &&)=delete
	Deleted move constructor.
std::string	find_file (const std::string &base_name, const std::string &search_path=marley::FileManager::default_search_path_) const
	Searches for a file in the given search path.
std::string	find_file (const std::string &base_name, const std::vector< std::string > &search_dirs) const
	Searches for a file in the given directories.
std::vector< std::string >	list_all_files (const std::string &search_path=FileManager::default_search_path_) const
	Get a vector of full paths for all regular files in the requested search path.
std::vector< std::string >	list_all_files (const std::vector< std::string > &search_dirs) const
	Get a vector of full paths for all regular files in the requested directories.
std::string	marley_dir () const
	Returns the path to the root MARLEY folder.
FileManager &	operator= (const FileManager &)=delete
	Deleted copy assignment operator.
FileManager &	operator= (FileManager &&)=delete
	Deleted move assignment operator.

Static Public Member Functions
static const FileManager &	Instance ()
	Get a const reference to the singleton instance of the FileManager.
static std::vector< std::string >	search_path_to_dir_vector (const std::string &search_path=FileManager::default_search_path_)
	Converts a ':'-delimited search path (given as a single string) into a vector of directory names.

Protected Member Functions
	FileManager ()
	Create the singleton FileManager object.

Static Protected Member Functions
static bool	dir_iterate (const std::string &dir_name, const std::function< bool(const std::string &, const std::string &)> &func)
	Helper function that executes a std::function on the name of each regular file found while scanning through a single directory (non-recursively)

Protected Attributes
std::string	marley_dir_
	Stores the value of the MARLEY environment variable (which points to the root folder of the source code distribution)

Static Protected Attributes
static std::string	default_search_path_
	By default, use this search path when looking for files.

Detailed Description

Singleton class that handles file searches.

Definition at line 25 of file FileManager.hh.

Constructor & Destructor Documentation

FileManager()

marley::FileManager::FileManager ( )

protected

Create the singleton FileManager object.

Definition at line 44 of file FileManager.cc.

                               {
 
  // Check whether the MARLEY environment variable is set
  char* mar = std::getenv("MARLEY");
  if ( !mar ) throw marley::Error("The MARLEY environment variable is not set."
    " Please set it (e.g., by sourcing the setup_marley.sh script) and"
    " try again.");
 
  marley_dir_ = std::string( mar );
 
  // If the MARLEY_SEARCH_PATH environment variable is set, use that
  // instead of the default search path
  char* msp = std::getenv("MARLEY_SEARCH_PATH");
  if ( msp ) default_search_path_ = std::string( msp );
  else {
    default_search_path_ = marley_dir_ + "/data";
    default_search_path_ += ':' + marley_dir_ + "/data/react";
    default_search_path_ += ':' + marley_dir_ + "/data/optical_model";
    default_search_path_ += ':' + marley_dir_ + "/data/structure";
  }
 
  MARLEY_LOG( DEBUG, "io" ) << "MARLEY search path set to \""
    << default_search_path_ << '\"';
}

References default_search_path_, and marley_dir_.

Member Function Documentation

dir_iterate()

bool marley::FileManager::dir_iterate ( const std::string & dir_name, const std::function< bool(const std::string &, const std::string &)> & func )

staticprotected

Helper function that executes a std::function on the name of each regular file found while scanning through a single directory (non-recursively)

Parameters

dir_name	The name of the directory to be scanned
func	The function to execute. The first argument is the full file name (including the path). The second is the base name of the file (no path). The return value should be true if no further iterations are needed (e.g., because a file matching a desired name was found) and false otherwise.

Returns

True if the iterations were stopped early (due to function returning true) or false if they were completed

Definition at line 175 of file FileManager.cc.

{
  std::error_code ec;
  std::filesystem::directory_iterator it(dir_name,
    std::filesystem::directory_options::skip_permission_denied, ec);
 
  if (ec) {
    MARLEY_LOG(WARN, "io") << "Could not read from the directory \""
      << dir_name << '\"';
    return false;
  }
 
  std::filesystem::directory_iterator end;
  bool stop_iterations = false;
  while (!stop_iterations && it != end) {
    const auto& entry = *it;
    std::string full_file_name = entry.path().string();
    std::string base_name = entry.path().filename().string();
 
    MARLEY_LOG(TRACE, "io") << "marley::FileManager found file \""
      << full_file_name << '\"';
 
    if (entry.is_regular_file()) {
      stop_iterations = func(full_file_name, base_name);
    }
 
    it.increment(ec);
    if (ec) {
      MARLEY_LOG(DEBUG, "io") << "Couldn't access a file in directory \""
        << dir_name << '\"';
      ec.clear();
    }
  }
 
  return stop_iterations;
}

Referenced by find_file(), and list_all_files().

find_file() [1/2]

std::string marley::FileManager::find_file	(	const std::string &	base_name,
		const std::string &	search_path = marley::FileManager::default_search_path_ ) const

Searches for a file in the given search path.

The search is non-recursive, i.e., no subdirectories are included in the search

Parameters

base_name	The base name (file name without any path) of the desired file
search_path	A string containing a ':'-delimited list of directories that should be searched for the file

Returns

The full path to the file, or an empty string if no match could be found

Definition at line 88 of file FileManager.cc.

{
  auto search_dirs = search_path_to_dir_vector( search_path );
  return find_file(base_name, search_dirs);
}

References find_file(), and search_path_to_dir_vector().

find_file() [2/2]

std::string marley::FileManager::find_file	(	const std::string &	base_name,
		const std::vector< std::string > &	search_dirs ) const

Searches for a file in the given directories.

The search is non-recursive, i.e., no subdirectories are included in the search. If base_name contains directory separators, it is treated as a relative path and resolved against each search directory.

Parameters

base_name	The base name (file name without any path) of the desired file, or a relative path containing directory separators
search_dirs	A vector of strings specifying the directories that should be searched for the file

Returns

The full path to the file, or an empty string if no match could be found

Definition at line 95 of file FileManager.cc.

{
  std::string full_path_to_file;
 
  // First check if we can find the file just using base_name. We can
  // avoid the search if it's already accessible (e.g., because the
  // full path was supplied instead of the base name)
  if ( file_exists(base_name) ) return base_name;
 
  // If the file name contains directory separators, try resolving
  // the relative path against each search directory
  if ( base_name.find('/') != std::string::npos ) {
    for (const auto& dir : search_dirs) {
      std::string candidate = dir + '/' + base_name;
      if ( file_exists(candidate) ) return candidate;
    }
  }
 
  // Search the directories in the order listed. In each directory,
  // compare all regular file names to the given base name. If a match
  // is found, stop the search and store the result in full_path_to_file.
  // If no match is found, full_path_to_file will remain empty.
  for (const auto& dir : search_dirs) {
    bool file_found = dir_iterate(dir,
      [&full_path_to_file, &base_name](const std::string& other_full_path,
        const std::string& other_base_name) -> bool
      {
        if ( base_name == other_base_name ) {
          // We've found the desired file, so store its full path
          full_path_to_file = other_full_path;
          // Signal that we don't need to continue the search any longer
          return true;
        }
        return false;
      }
    );
 
    if ( file_found ) break;
  }
 
  return full_path_to_file;
}

References dir_iterate().

Referenced by marley::StrengthVariationWeightCalculator::create_instances(), and find_file().

Instance()

const marley::FileManager & marley::FileManager::Instance ( )

static

Get a const reference to the singleton instance of the FileManager.

Definition at line 69 of file FileManager.cc.

                                                     {
 
  // Create the mass table using a static variable. This ensures
  // that the singleton instance is only created once.
  static std::unique_ptr<marley::FileManager>
    the_instance(new marley::FileManager());
 
  // Return a reference to the singleton instance
  return *the_instance;
}

Referenced by marley::MassTable::MassTable(), marley::StrengthVariationWeightCalculator::create_instances(), marley::EventFileReader::deduce_file_format(), marley::StructureDatabase::get_decay_scheme(), and marley::StructureDatabase::load_optical_model_params().

list_all_files() [1/2]

std::vector< std::string > marley::FileManager::list_all_files

(

const std::string &

search_path = FileManager::default_search_path_

)

const

Get a vector of full paths for all regular files in the requested search path.

Files in subdirectories are not included (the search is non-recursive)

Parameters

search_path

A string containing a ':'-delimited list of directories that should be scanned for files

Returns

A vector of strings giving the full path to each regular file that was found

Definition at line 139 of file FileManager.cc.

{
  auto search_dirs = search_path_to_dir_vector( search_path );
  return list_all_files( search_dirs );
}

References list_all_files(), and search_path_to_dir_vector().

list_all_files() [2/2]

std::vector< std::string > marley::FileManager::list_all_files

(

const std::vector< std::string > &

search_dirs

)

const

Get a vector of full paths for all regular files in the requested directories.

Files in subdirectories are not included (the search is non-recursive)

Parameters

search_dirs

A vector of strings specifying the directories that should be scanned

Returns

A vector of strings giving the full path to each regular file that was found

Definition at line 148 of file FileManager.cc.

{
  std::vector<std::string> result;
 
  for (const auto& dir : search_dirs) {
    dir_iterate(dir,
      [&result](const std::string& full_path,
        const std::string& /*base_name*/) -> bool
      {
        // Add the current file to the vector of full paths
        result.push_back( full_path );
        // Signal that the directory scan should continue
        return false;
      }
    );
  }
 
  return result;
}

References dir_iterate().

Referenced by list_all_files().

marley_dir()

std::string marley::FileManager::marley_dir ( ) const

inline

Returns the path to the root MARLEY folder.

Definition at line 106 of file FileManager.hh.

{ return marley_dir_; }

References marley_dir_.

search_path_to_dir_vector()

std::vector< std::string > marley::FileManager::search_path_to_dir_vector ( const std::string & search_path = FileManager::default_search_path_ )

static

Converts a ':'-delimited search path (given as a single string) into a vector of directory names.

Parameters

search_path

The search path to convert that should be searched for the file

Returns

A vector of directory names corresponding to those given in the search path

Definition at line 80 of file FileManager.cc.

{
  std::vector<std::string> dir_names
    = marley_utils::split_string(search_path, SEARCH_PATH_DELIMITER);
  return dir_names;
}

Referenced by find_file(), and list_all_files().

Member Data Documentation

default_search_path_

std::string marley::FileManager::default_search_path_

staticprotected

By default, use this search path when looking for files.

Definition at line 128 of file FileManager.hh.

Referenced by FileManager(), and operator=().

marley_dir_

std::string marley::FileManager::marley_dir_

protected

Stores the value of the MARLEY environment variable (which points to the root folder of the source code distribution)

Definition at line 132 of file FileManager.hh.

Referenced by FileManager(), and marley_dir().

---

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

• /home/sjg/Desktop/marley/include/marley/FileManager.hh
• /home/sjg/Desktop/marley/src/FileManager.cc