FileLoaderRegistry.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 "MantidAPI/FileLoaderRegistry.h"
#include "MantidAPI/IFileLoader.h"
#include "MantidAPI/NexusFileLoader.h"
 
#include <H5Cpp.h>
#include <Poco/File.h>
#include <algorithm>
 
namespace Mantid::API {
namespace {
//----------------------------------------------------------------------------------------------
// Anonymous namespace helpers
//----------------------------------------------------------------------------------------------
template <typename T> struct DescriptorCallback {
  void apply(std::shared_ptr<T> & /*unused*/) {} // general one does nothing
};
template <> struct DescriptorCallback<Kernel::FileDescriptor> {
  void apply(std::shared_ptr<Kernel::FileDescriptor> &descriptor) { descriptor->resetStreamToStart(); }
};
 
template <typename T> struct DescriptorSetter {
  // general one does nothing
  void apply(std::shared_ptr<NexusFileLoader> & /*unused*/, std::shared_ptr<T> & /*unused*/) {}
};
template <> struct DescriptorSetter<Nexus::NexusDescriptor> {
  void apply(std::shared_ptr<NexusFileLoader> &loader, const std::shared_ptr<Nexus::NexusDescriptor> &descriptor) {
    loader->setFileInfo(descriptor);
  }
};
 
template <typename DescriptorType, typename FileLoaderType>
std::pair<IAlgorithm_sptr, int> searchForLoader(const std::string &filename,
                                                const std::multimap<std::string, int> &names, Kernel::Logger &logger) {
  const auto &factory = AlgorithmFactory::Instance();
  IAlgorithm_sptr bestLoader;
  int maxConfidence(0);
  auto descriptor = std::make_shared<DescriptorType>(filename);
  DescriptorCallback<DescriptorType> callback;
  DescriptorSetter<DescriptorType> setdescriptor;
 
  auto iend = names.end();
  for (auto it = names.begin(); it != iend; ++it) {
    const std::string &name = it->first;
    const int version = it->second;
    logger.debug() << "Checking " << name << " version " << version << '\n';
 
    // Use static cast for speed. Checks have been done at registration to check
    // the types
    auto alg = std::static_pointer_cast<FileLoaderType>(factory.create(name, version)); // highest version
    try {
      const int confidence = alg->confidence(*(descriptor.get()));
      logger.debug() << name << " returned with confidence=" << confidence << '\n';
      if (confidence > maxConfidence) // strictly greater
      {
        bestLoader = alg;
        maxConfidence = confidence;
      }
    } catch (std::exception &exc) {
      logger.warning() << "Checking loader '" << name << "' raised an error: '" << exc.what() << "'. Loader skipped.\n";
    }
    callback.apply(descriptor);
  }
 
  auto nxsLoader = std::dynamic_pointer_cast<NexusFileLoader>(bestLoader);
  if (nxsLoader)
    setdescriptor.apply(nxsLoader, descriptor);
 
  return {bestLoader, maxConfidence};
}
 
bool isHDF4(std::string const &filename) {
  // the HDF4 file signature, as per HDF's documentation
  std::array<char, 4> constexpr hdf4_sig{0x0E, 0x03, 0x13, 0x01};
  // read the signature in the first four bytes of this file
  std::array<char, 4> signature;
  std::ifstream file(filename, std::ios::binary);
  if (!file.read(signature.data(), 4)) {
    return false;
  }
  return signature == hdf4_sig;
}
} // namespace
 
//----------------------------------------------------------------------------------------------
// Public members
//----------------------------------------------------------------------------------------------
 
void FileLoaderRegistryImpl::unsubscribe(const std::string &name, const int version) {
  auto iend = m_names.end();
  for (auto it = m_names.begin(); it != iend; ++it) {
    removeAlgorithm(name, version, *it);
  }
}
 
const std::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std::string &filename) const {
  using Kernel::FileDescriptor;
  using Kernel::LegacyNexusDescriptor;
  using Nexus::NexusDescriptorLazy;
  m_log.debug() << "Trying to find loader for '" << filename << "'\n";
 
  IAlgorithm_sptr bestLoader;
 
  if (H5::H5File::isHdf5(filename)) {
 
    // first, try search with Nexus loaders
    std::pair<IAlgorithm_sptr, int> NexusResult =
        searchForLoader<NexusDescriptorLazy, IFileLoader<NexusDescriptorLazy>>(filename, m_names[Nexus], m_log);
    if (NexusResult.second < 80) {
      // must also try LegacyNexusDescriptor algorithms because LoadMuonNexus can load both HDF4 and HDF5 files
      // but only need to do this if confidence is less than 80, i.e. not loaded by LoadEventNexus,
      // LoadNexusProcessed, LoadMuonNexusV2 or LoadMD
      std::pair<IAlgorithm_sptr, int> LegacyNexusResult =
          searchForLoader<LegacyNexusDescriptor, IFileLoader<LegacyNexusDescriptor>>(filename, m_names[LegacyNexus],
                                                                                     m_log);
      // select best loader of Nexus and Legacy
      bestLoader = std::max({NexusResult, LegacyNexusResult}, [](const auto &a, const auto &b) {
                     return a.second < b.second;
                   }).first;
    } else {
      bestLoader = NexusResult.first;
    }
  } else if (isHDF4(filename)) {
    // If the file is HDF4, then it can only be loaded by the legacy nexus loaders
    try {
      bestLoader = searchForLoader<LegacyNexusDescriptor, IFileLoader<LegacyNexusDescriptor>>(
                       filename, m_names[LegacyNexus], m_log)
                       .first;
    } catch (std::exception const &e) {
      m_log.debug() << "Error in looking for NeXus files: " << e.what() << '\n';
    }
  }
 
  if (!bestLoader)
    bestLoader = searchForLoader<FileDescriptor, IFileLoader<FileDescriptor>>(filename, m_names[Generic], m_log).first;
 
  if (!bestLoader) {
    throw Kernel::Exception::NotFoundError(filename, "Unable to find loader");
  }
  m_log.debug() << "Found loader " << bestLoader->name() << " for file '" << filename << "'\n";
  return bestLoader;
}
 
bool FileLoaderRegistryImpl::canLoad(const std::string &algorithmName, const std::string &filename) const {
  using Kernel::FileDescriptor;
  using Kernel::LegacyNexusDescriptor;
  using Nexus::NexusDescriptorLazy;
 
  // Check if it is in one of our lists
  const bool legacynexus = (m_names[LegacyNexus].find(algorithmName) != m_names[LegacyNexus].end());
  const bool nexus = (m_names[Nexus].find(algorithmName) != m_names[Nexus].end());
  const bool nonHDF = (m_names[Generic].find(algorithmName) != m_names[Generic].end());
 
  if (!(legacynexus || nexus || nonHDF))
    throw std::invalid_argument("FileLoaderRegistryImpl::canLoad - Algorithm '" + algorithmName +
                                "' is not registered as a loader.");
 
  std::multimap<std::string, int> names{{algorithmName, -1}};
  IAlgorithm_sptr loader;
  if (legacynexus) {
    try {
      loader = searchForLoader<LegacyNexusDescriptor, IFileLoader<LegacyNexusDescriptor>>(filename, names, m_log).first;
    } catch (std::exception const &e) {
      m_log.debug() << "Error in looking for NeXus files: " << e.what() << '\n';
    }
  } else if (nexus) {
    if (H5::H5File::isHdf5(filename)) {
      try {
        loader = searchForLoader<NexusDescriptorLazy, IFileLoader<NexusDescriptorLazy>>(filename, names, m_log).first;
      } catch (const std::invalid_argument &e) {
        m_log.debug() << "Error in looking for HDF5 based NeXus files: " << e.what() << '\n';
      }
    }
  } else if (nonHDF) {
    loader = searchForLoader<FileDescriptor, IFileLoader<FileDescriptor>>(filename, names, m_log).first;
  }
  return static_cast<bool>(loader);
}
 
//----------------------------------------------------------------------------------------------
// Private members
//----------------------------------------------------------------------------------------------
FileLoaderRegistryImpl::FileLoaderRegistryImpl() : m_totalSize(0), m_log("FileLoaderRegistry") {}
 
FileLoaderRegistryImpl::~FileLoaderRegistryImpl() = default;
 
void FileLoaderRegistryImpl::removeAlgorithm(const std::string &name, const int version,
                                             std::multimap<std::string, int> &typedLoaders) {
  if (version == -1) // remove all
  {
    typedLoaders.erase(name);
  } else // find the right version
  {
    auto range = typedLoaders.equal_range(name);
    for (auto ritr = range.first; ritr != range.second; ++ritr) {
      if (ritr->second == version) {
        typedLoaders.erase(ritr);
        break;
      }
    }
  }
}
 
} // namespace Mantid::API