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 <Poco/DirectoryIterator.h>
#include <Poco/File.h>
#include <Poco/Path.h>
#include <boost/algorithm/string.hpp>
 
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(Poco::File(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 Poco::File &libpath, LibraryManagerImpl::LoadLibraries loadingBehaviour,
                                      const std::vector<std::string> &excludes) {
  int libCount(0);
  if (libpath.exists() && libpath.isDirectory()) {
    // Iterate over the available files
    Poco::DirectoryIterator end_itr;
    for (Poco::DirectoryIterator itr(libpath); itr != end_itr; ++itr) {
      const Poco::File &item = *itr;
      if (item.isFile()) {
        if (shouldBeLoaded(itr.path().getFileName(), excludes))
          libCount += openLibrary(itr.path(), itr.path().getFileName());
        else
          continue;
      } else if (loadingBehaviour == LoadLibraries::Recursive) {
        // it must be a directory
        libCount += openLibraries(item, LoadLibraries::Recursive, excludes);
      }
    }
  } else {
    g_log.error("In OpenAllLibraries: " + libpath.path() + " 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 {
  for (const auto &exclude : excludes) {
    if (filename.find(exclude) != std::string::npos) {
      return true;
    }
  }
  return false;
}
 
int LibraryManagerImpl::openLibrary(const Poco::File &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.path())) {
    // Successfully opened, so add to map
    if (g_log.is(Poco::Message::PRIO_DEBUG)) {
      g_log.debug("Opened library: " + filepath.path() + ".\n");
    }
    m_openedLibs.emplace(cacheKey, std::move(dlwrap));
    return 1;
  } else
    return 0;
}
 
} // namespace Mantid::Kernel