FileLoaderRegistry.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2013 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 +
#pragma once
 
#include "MantidAPI/AlgorithmFactory.h"
#include "MantidAPI/IFileLoader.h"
#include "MantidKernel/FileDescriptor.h"
#include "MantidKernel/LegacyNexusDescriptor.h"
#include "MantidKernel/SingletonHolder.h"
#include "MantidNexus/NexusDescriptor.h"
 
#ifndef Q_MOC_RUN
#include <type_traits>
#endif
 
#include <array>
#include <map>
#include <string>
 
namespace Mantid {
namespace Kernel {
 
class Logger;
}
namespace API {
 
class IAlgorithm;
 
class MANTID_API_DLL FileLoaderRegistryImpl {
public:
  enum LoaderFormat { LegacyNexus, Generic, Nexus };
 
public:
  inline size_t size() const { return m_totalSize; }
 
  template <typename Type> void subscribe(LoaderFormat format) {
    SubscriptionValidator<Type>::check(format);
    const auto nameVersion = AlgorithmFactory::Instance().subscribe<Type>();
    // If the factory didn't throw then the name is valid
    m_names[format].insert(nameVersion);
    m_totalSize += 1;
    m_log.debug() << "Registered '" << nameVersion.first << "' version '" << nameVersion.second << "' as file loader\n";
  }
 
  void unsubscribe(const std::string &name, const int version = -1);
 
  const std::shared_ptr<IAlgorithm> chooseLoader(const std::string &filename) const;
  bool canLoad(const std::string &algorithmName, const std::string &filename) const;
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<FileLoaderRegistryImpl>;
 
  FileLoaderRegistryImpl();
  ~FileLoaderRegistryImpl();
 
  template <typename T> struct SubscriptionValidator {
    static void check(LoaderFormat format) {
      switch (format) {
      case LegacyNexus:
        if (!std::is_base_of<IFileLoader<Kernel::LegacyNexusDescriptor>, T>::value) {
          throw std::runtime_error(std::string("FileLoaderRegistryImpl::subscribe - Class '") + typeid(T).name() +
                                   "' registered as LegacyNexus loader but it does not inherit from "
                                   "API::IFileLoader<Kernel::LegacyNexusDescriptor>");
        }
        break;
      case Nexus:
        if (!std::is_base_of<IFileLoader<Nexus::NexusDescriptor>, T>::value) {
          throw std::runtime_error(
              std::string("FileLoaderRegistryImpl::subscribe - Class '") + typeid(T).name() +
              "' registered as Nexus loader but it does not inherit from API::IFileLoader<Kernel::NexusDescriptor>");
        }
        break;
      case Generic:
        if (!std::is_base_of<IFileLoader<Kernel::FileDescriptor>, T>::value) {
          throw std::runtime_error(
              std::string("FileLoaderRegistryImpl::subscribe - Class '") + typeid(T).name() +
              "' registered as Generic loader but it does not inherit from API::IFileLoader<Kernel::FileDescriptor>");
        }
        break;
      default:
        throw std::runtime_error("Invalid LoaderFormat given");
      }
    }
  };
 
  void removeAlgorithm(const std::string &name, const int version, std::multimap<std::string, int> &typedLoaders);
 
  std::array<std::multimap<std::string, int>, 3> m_names;
  size_t m_totalSize;
 
  mutable Kernel::Logger m_log;
};
 
using FileLoaderRegistry = Mantid::Kernel::SingletonHolder<FileLoaderRegistryImpl>;
 
} // namespace API
} // namespace Mantid
 
namespace Mantid {
namespace Kernel {
EXTERN_MANTID_API template class MANTID_API_DLL Mantid::Kernel::SingletonHolder<Mantid::API::FileLoaderRegistryImpl>;
}
} // namespace Mantid