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};
}
} // 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::NexusDescriptor;
  m_log.debug() << "Trying to find loader for '" << filename << "'\n";
 
  IAlgorithm_sptr bestLoader;
 
  if (H5::H5File::isHdf5(filename)) {
 
    // first, try search with lazy descriptor
    std::pair<IAlgorithm_sptr, int> NexusLazyResult =
        searchForLoader<Nexus::NexusDescriptorLazy, IFileLoader<Nexus::NexusDescriptorLazy>>(filename,
                                                                                             m_names[NexusLazy], m_log);
    // if not found with lazy descriptor, try normal descriptor
    if (NexusLazyResult.second < 80) {
      std::pair<IAlgorithm_sptr, int> NexusResult =
          searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(filename, m_names[Nexus], m_log);
 
      // and if not found with normal HDF5 descriptor, try legacy nexus descriptor
      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 loaded of three
        bestLoader = std::max({NexusResult, NexusLazyResult, LegacyNexusResult}, [](const auto &a, const auto &b) {
                       return a.second < b.second;
                     }).first;
      } else {
        bestLoader = std::max({NexusResult, NexusLazyResult}, [](const auto &a, const auto &b) {
                       return a.second < b.second;
                     }).first;
      }
    } else {
      bestLoader = NexusLazyResult.first;
    }
  } else {
    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::NexusDescriptor;
 
  // Check if it is in one of our lists
  const bool legacynexus = (m_names[LegacyNexus].find(algorithmName) != m_names[LegacyNexus].end());
  const bool lazyNexus = (m_names[NexusLazy].find(algorithmName) != m_names[NexusLazy].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 || lazyNexus))
    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<NexusDescriptor, IFileLoader<NexusDescriptor>>(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 (lazyNexus) {
    if (H5::H5File::isHdf5(filename)) {
      try {
        loader =
            searchForLoader<Nexus::NexusDescriptorLazy, IFileLoader<Nexus::NexusDescriptorLazy>>(filename, names, m_log)
                .first;
      } catch (const std::invalid_argument &e) {
        m_log.debug() << "Error in looking for lazy 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