FileLoaderRegistry.cpp

#include "MantidAPI/FileLoaderRegistry.h"
#include "MantidAPI/IFileLoader.h"

#include <Poco/File.h>

namespace Mantid {
namespace API {
namespace {
//----------------------------------------------------------------------------------------------
// Anonymous namespace helpers
//----------------------------------------------------------------------------------------------
/// @cond
template <typename T> struct DescriptorCallback {
  void apply(T &) {} // general one does nothing
};
template <> struct DescriptorCallback<Kernel::FileDescriptor> {
  void apply(Kernel::FileDescriptor &descriptor) {
    descriptor.resetStreamToStart();
  }
};
/// @endcond

/**
 * @param filename A string giving a filename
 * @param names The collection of names to search through
 * @param logger A reference to a Mantid Logger object
 * @return  A string containing the name of an algorithm to load the file, or an
 * empty string if nothing
 * was found
 */
template <typename DescriptorType, typename FileLoaderType>
const IAlgorithm_sptr
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);
  DescriptorType descriptor(filename);
  DescriptorCallback<DescriptorType> callback;

  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
                   << std::endl;

    // Use static cast for speed. Checks have been done at registration to check
    // the types
    auto alg = boost::static_pointer_cast<FileLoaderType>(
        factory.create(name, version)); // highest version
    try {
      const int confidence = alg->confidence(descriptor);
      logger.debug() << name << " returned with confidence=" << confidence
                     << std::endl;
      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." << std::endl;
    }
    callback.apply(descriptor);
  }
  return bestLoader;
}
} // end anonymous

//----------------------------------------------------------------------------------------------
// Public members
//----------------------------------------------------------------------------------------------

/**
 * If the name does not exist then it does nothing
 * @param name Name of the algorithm to remove from the search list
 * @param version An optional version to remove. -1 indicates remove all
 * (Default=-1)
 */
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);
  }
}

/**
 * Queries each registered algorithm and asks it how confident it is that it can
 * load the given file. The name of the one with the highest confidence is
 * returned.
 * @param filename A full file path pointing to an existing file
 * @return A string containing the name of an algorithm to load the file
 * @throws Exception::NotFoundError if an algorithm cannot be found
 */
const boost::shared_ptr<IAlgorithm>
FileLoaderRegistryImpl::chooseLoader(const std::string &filename) const {
  using Kernel::FileDescriptor;
  using Kernel::NexusDescriptor;

  m_log.debug() << "Trying to find loader for '" << filename << "'"
                << std::endl;

  IAlgorithm_sptr bestLoader;
  if (NexusDescriptor::isHDF(filename)) {
    m_log.debug()
        << filename
        << " looks like a Nexus file. Checking registered Nexus loaders\n";
    bestLoader = searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(
        filename, m_names[Nexus], m_log);
  } else {
    m_log.debug() << "Checking registered non-HDF loaders\n";
    bestLoader = searchForLoader<FileDescriptor, IFileLoader<FileDescriptor>>(
        filename, m_names[Generic], m_log);
  }

  if (!bestLoader) {
    throw Kernel::Exception::NotFoundError(filename, "Unable to find loader");
  }
  m_log.debug() << "Found loader " << bestLoader->name() << " for file '"
                << filename << "'" << std::endl;
  return bestLoader;
}

/**
 * Perform a check that that the given algorithm can load the file
 * @param algorithmName The name of the algorithm to check
 * @param filename The name of file to check
 * @returns True if the algorithm can load the file, false otherwise
 * @throws std::invalid_argument if the loader does not exist
 */
bool FileLoaderRegistryImpl::canLoad(const std::string &algorithmName,
                                     const std::string &filename) const {
  using Kernel::FileDescriptor;
  using Kernel::NexusDescriptor;

  // Check if it is in one of our lists
  bool nexus(false), nonHDF(false);
  if (m_names[Nexus].find(algorithmName) != m_names[Nexus].end())
    nexus = true;
  else if (m_names[Generic].find(algorithmName) != m_names[Generic].end())
    nonHDF = true;

  if (!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 (nexus) {
    if (NexusDescriptor::isHDF(filename)) {
      loader = searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(
          filename, names, m_log);
    }
  } else {
    loader = searchForLoader<FileDescriptor, IFileLoader<FileDescriptor>>(
        filename, names, m_log);
  }
  return static_cast<bool>(loader);
}

//----------------------------------------------------------------------------------------------
// Private members
//----------------------------------------------------------------------------------------------
/**
 * Creates an empty registry
 */
FileLoaderRegistryImpl::FileLoaderRegistryImpl()
    : m_names(2, std::multimap<std::string, int>()), m_totalSize(0),
      m_log("FileLoaderRegistry") {}

/**
 */
FileLoaderRegistryImpl::~FileLoaderRegistryImpl() {}

/**
 * @param name A string containing the algorithm name
 * @param version The version to remove. -1 indicates all instances
 * @param typedLoaders A map of names to version numbers
 **/
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 API
} // namespace Mantid