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 << '\n';

    // 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
                     << '\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);
  }
  return bestLoader;
}
} // end anonymous