LibraryManager.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/LibraryManager.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/DllOpen.h"
#include "MantidKernel/LibraryWrapper.h"
#include "MantidKernel/Logger.h"
 
#include <filesystem>
 
namespace Mantid::Kernel {
namespace {
Logger g_log("LibraryManager");
} // namespace
 
LibraryManagerImpl::LibraryManagerImpl() : m_openedLibs() { g_log.debug("LibraryManager created."); }
 
int LibraryManagerImpl::openLibraries(const std::string &filepath, LoadLibraries loadingBehaviour,
                                      const std::vector<std::string> &excludes) {
  g_log.debug("Opening all libraries in " + filepath + "\n");
  try {
    return openLibraries(std::filesystem::path(filepath), loadingBehaviour, excludes);
  } catch (std::exception &exc) {
    g_log.debug() << "Error occurred while opening libraries: " << exc.what() << "\n";
    return 0;
  } catch (...) {
    g_log.error("An unknown error occurred while opening libraries.");
    return 0;
  }
}
 
//-------------------------------------------------------------------------
// Private members
//-------------------------------------------------------------------------
int LibraryManagerImpl::openLibraries(const std::filesystem::path &libpath,
                                      LibraryManagerImpl::LoadLibraries loadingBehaviour,
                                      const std::vector<std::string> &excludes) {
  int libCount(0);
  if (std::filesystem::exists(libpath) && std::filesystem::is_directory(libpath)) {
    // Iterate over the available files
    for (const auto &file : std::filesystem::directory_iterator(libpath)) {
      const auto &path = file.path();
      if (std::filesystem::is_regular_file(path)) {
        if (shouldBeLoaded(path.filename().string(), excludes))
          libCount += openLibrary(path.string(), path.filename().string());
        else
          continue;
      } else if (loadingBehaviour == LoadLibraries::Recursive) {
        // it must be a directory
        libCount += openLibraries(path, LoadLibraries::Recursive, excludes);
      }
    }
  } else {
    g_log.error("In OpenAllLibraries: " + libpath.string() + " must be a directory.");
  }
  return libCount;
}
 
bool LibraryManagerImpl::shouldBeLoaded(const std::string &filename, const std::vector<std::string> &excludes) const {
  return !isLoaded(filename) && DllOpen::isValidFilename(filename) && !isExcluded(filename, excludes);
}
 
bool LibraryManagerImpl::isLoaded(const std::string &filename) const {
  return m_openedLibs.find(filename) != m_openedLibs.cend();
}
 
bool LibraryManagerImpl::isExcluded(const std::string &filename, const std::vector<std::string> &excludes) const {
  return std::any_of(excludes.cbegin(), excludes.cend(),
                     [&filename](const auto exclude) { return filename.find(exclude) != std::string::npos; });
}
 
int LibraryManagerImpl::openLibrary(const std::filesystem::path &filepath, const std::string &cacheKey) {
  // Try to open the library. The wrapper will unload the library when it
  // is deleted
  LibraryWrapper dlwrap;
  if (dlwrap.openLibrary(filepath.string())) {
    // Successfully opened, so add to map
    if (g_log.is(Poco::Message::PRIO_DEBUG)) {
      g_log.debug("Opened library: " + filepath.string() + ".\n");
    }
    m_openedLibs.emplace(cacheKey, std::move(dlwrap));
    return 1;
  } else
    return 0;
}
 
} // namespace Mantid::Kernel