Rename NexusDescriptor to LegacyNexusDescriptor

Author: peterfpeterson

Framework/API/inc/MantidAPI/FileLoaderRegistry.h

@@ -9,7 +9,7 @@
 #include "MantidAPI/AlgorithmFactory.h"
 #include "MantidAPI/IFileLoader.h"
 #include "MantidKernel/FileDescriptor.h"
-#include "MantidKernel/NexusDescriptor.h"
+#include "MantidKernel/LegacyNexusDescriptor.h"
 #include "MantidKernel/NexusHDF5Descriptor.h"
 #include "MantidKernel/SingletonHolder.h"
 
@@ -90,7 +90,7 @@ class MANTID_API_DLL FileLoaderRegistryImpl {
     static void check(LoaderFormat format) {
       switch (format) {
       case Nexus:
-        if (!std::is_base_of<IFileLoader<Kernel::NexusDescriptor>, T>::value) {
+        if (!std::is_base_of<IFileLoader<Kernel::LegacyNexusDescriptor>, T>::value) {
           throw std::runtime_error(std::string("FileLoaderRegistryImpl::subscribe - Class '") + typeid(T).name() +
                                    "' registered as Nexus loader but it does not "
                                    "inherit from "

Framework/API/src/FileLoaderRegistry.cpp

@@ -113,7 +113,7 @@ void FileLoaderRegistryImpl::unsubscribe(const std::string &name, const int vers
  */
 const std::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std::string &filename) const {
   using Kernel::FileDescriptor;
-  using Kernel::NexusDescriptor;
+  using Kernel::LegacyNexusDescriptor;
   using Kernel::NexusHDF5Descriptor;
   m_log.debug() << "Trying to find loader for '" << filename << "'\n";
 
@@ -125,7 +125,7 @@ const std::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std
 
     // must also try NexusDescriptor algorithms because LoadMuonNexus can load both HDF4 and HDF5 files
     std::pair<IAlgorithm_sptr, int> HDF4result =
-        searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(filename, m_names[Nexus], m_log);
+        searchForLoader<LegacyNexusDescriptor, IFileLoader<LegacyNexusDescriptor>>(filename, m_names[Nexus], m_log);
 
     if (HDF5result.second > HDF4result.second)
       bestLoader = HDF5result.first;
@@ -134,7 +134,8 @@ const std::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std
   } else {
     try {
       bestLoader =
-          searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(filename, m_names[Nexus], m_log).first;
+          searchForLoader<LegacyNexusDescriptor, IFileLoader<LegacyNexusDescriptor>>(filename, m_names[Nexus], m_log)
+              .first;
     } catch (std::exception const &e) {
       m_log.debug() << "Error in looking for NeXus files: " << e.what() << '\n';
     }
@@ -159,7 +160,7 @@ const std::shared_ptr<IAlgorithm> FileLoaderRegistryImpl::chooseLoader(const std
  */
 bool FileLoaderRegistryImpl::canLoad(const std::string &algorithmName, const std::string &filename) const {
   using Kernel::FileDescriptor;
-  using Kernel::NexusDescriptor;
+  using Kernel::LegacyNexusDescriptor;
   using Kernel::NexusHDF5Descriptor;
 
   // Check if it is in one of our lists
@@ -175,7 +176,7 @@ bool FileLoaderRegistryImpl::canLoad(const std::string &algorithmName, const std
   IAlgorithm_sptr loader;
   if (nexus) {
     try {
-      loader = searchForLoader<NexusDescriptor, IFileLoader<NexusDescriptor>>(filename, names, m_log).first;
+      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';
     }

Framework/Kernel/CMakeLists.txt

@@ -74,7 +74,7 @@ set(SRC_FILES
     src/MultiFileValidator.cpp
     src/NDRandomNumberGenerator.cpp
     src/NeutronAtom.cpp
-    src/NexusDescriptor.cpp
+    src/LegacyNexusDescriptor.cpp
     src/NexusHDF5Descriptor.cpp
     src/NullValidator.cpp
     src/OptionalBool.cpp
@@ -232,7 +232,7 @@ set(INC_FILES
     inc/MantidKernel/NearestNeighbours.h
     inc/MantidKernel/NetworkProxy.h
     inc/MantidKernel/NeutronAtom.h
-    inc/MantidKernel/NexusDescriptor.h
+    inc/MantidKernel/LegacyNexusDescriptor.h
     inc/MantidKernel/NexusHDF5Descriptor.h
     inc/MantidKernel/NullValidator.h
     inc/MantidKernel/OptionalBool.h
@@ -388,7 +388,7 @@ set(TEST_FILES
     NDRandomNumberGeneratorTest.h
     NearestNeighboursTest.h
     NeutronAtomTest.h
-    NexusDescriptorTest.h
+    LegacyNexusDescriptorTest.h
     NexusHDF5DescriptorTest.h
     NullValidatorTest.h
     OptionalBoolTest.h

Framework/Kernel/inc/MantidKernel/NexusDescriptor.h renamed to Framework/Kernel/inc/MantidKernel/LegacyNexusDescriptor.h

@@ -29,22 +29,22 @@ namespace Kernel {
     On construction the simple details about the layout of the file are cached
    for faster querying later.
  */
-class MANTID_KERNEL_DLL NexusDescriptor {
+class MANTID_KERNEL_DLL LegacyNexusDescriptor {
 
 public:
   /// Constructor accepting a filename
-  NexusDescriptor(const std::string &filename);
+  LegacyNexusDescriptor(const std::string &filename);
   /// Destructor
-  ~NexusDescriptor();
+  ~LegacyNexusDescriptor();
 
   /// Disable default constructor
-  NexusDescriptor() = delete;
+  LegacyNexusDescriptor() = delete;
 
   /// Disable copy operator
-  NexusDescriptor(const NexusDescriptor &) = delete;
+  LegacyNexusDescriptor(const LegacyNexusDescriptor &) = delete;
 
   /// Disable assignment operator
-  NexusDescriptor &operator=(const NexusDescriptor &) = delete;
+  LegacyNexusDescriptor &operator=(const LegacyNexusDescriptor &) = delete;
 
   /**
    * Access the filename

Framework/Kernel/src/NexusDescriptor.cpp renamed to Framework/Kernel/src/LegacyNexusDescriptor.cpp

@@ -4,7 +4,7 @@
 //   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 "MantidKernel/NexusDescriptor.h"
+#include "MantidKernel/LegacyNexusDescriptor.h"
 #include "MantidLegacyNexus/NeXusException.hpp"
 #include "MantidLegacyNexus/NeXusFile.hpp"
 
@@ -26,7 +26,7 @@ namespace Mantid::Kernel {
  * involves simply checking for the signature if a HDF file at the start of the
  * file
  */
-NexusDescriptor::NexusDescriptor(const std::string &filename)
+LegacyNexusDescriptor::LegacyNexusDescriptor(const std::string &filename)
     : m_filename(), m_extension(), m_firstEntryNameType(), m_rootAttrs(), m_pathsToTypes(), m_file(nullptr) {
   if (filename.empty()) {
     throw std::invalid_argument("NexusDescriptor() - Empty filename '" + filename + "'");
@@ -43,17 +43,19 @@ NexusDescriptor::NexusDescriptor(const std::string &filename)
   }
 }
 
-NexusDescriptor::~NexusDescriptor() = default;
+LegacyNexusDescriptor::~LegacyNexusDescriptor() = default;
 
 /// Returns the name & type of the first entry in the file
-const std::pair<std::string, std::string> &NexusDescriptor::firstEntryNameType() const { return m_firstEntryNameType; }
+const std::pair<std::string, std::string> &LegacyNexusDescriptor::firstEntryNameType() const {
+  return m_firstEntryNameType;
+}
 
 /**
  * @param path A string giving a path using UNIX-style path separators (/), e.g.
  * /raw_data_1, /entry/bank1
  * @return True if the path exists in the file, false otherwise
  */
-bool NexusDescriptor::pathExists(const std::string &path) const {
+bool LegacyNexusDescriptor::pathExists(const std::string &path) const {
   return (m_pathsToTypes.find(path) != m_pathsToTypes.end());
 }
 
@@ -64,7 +66,7 @@ bool NexusDescriptor::pathExists(const std::string &path) const {
 /**
  * Creates the internal cached structure of the file as a tree of nodes
  */
-void NexusDescriptor::initialize(const std::string &filename) {
+void LegacyNexusDescriptor::initialize(const std::string &filename) {
   m_filename = filename;
   m_extension = std::filesystem::path(filename).extension().string();
 
@@ -84,8 +86,9 @@ void NexusDescriptor::initialize(const std::string &filename) {
  * @param pmap [Out] An output map filled with mappings of path->type
  * @param level An integer defining the current level in the file
  */
-void NexusDescriptor::walkFile(Mantid::LegacyNexus::File &file, const std::string &rootPath,
-                               const std::string &className, std::map<std::string, std::string> &pmap, int level) {
+void LegacyNexusDescriptor::walkFile(Mantid::LegacyNexus::File &file, const std::string &rootPath,
+                                     const std::string &className, std::map<std::string, std::string> &pmap,
+                                     int level) {
   if (!rootPath.empty()) {
     pmap.emplace(rootPath, className);
   }

Framework/Kernel/test/NexusDescriptorTest.h renamed to Framework/Kernel/test/LegacyNexusDescriptorTest.h

@@ -7,7 +7,7 @@
 #pragma once
 
 #include "MantidKernel/ConfigService.h"
-#include "MantidKernel/NexusDescriptor.h"
+#include "MantidKernel/LegacyNexusDescriptor.h"
 #include "MantidNexusCpp/NeXusFile.hpp"
 #include <cxxtest/TestSuite.h>
 
@@ -16,16 +16,16 @@
 
 #include <cstdio>
 
-using Mantid::Kernel::NexusDescriptor;
+using Mantid::Kernel::LegacyNexusDescriptor;
 
-class NexusDescriptorTest : public CxxTest::TestSuite {
+class LegacyNexusDescriptorTest : public CxxTest::TestSuite {
 public:
   // This pair of boilerplate methods prevent the suite being created statically
   // This means the constructor isn't called when running other tests
-  static NexusDescriptorTest *createSuite() { return new NexusDescriptorTest(); }
-  static void destroySuite(NexusDescriptorTest *suite) { delete suite; }
+  static LegacyNexusDescriptorTest *createSuite() { return new LegacyNexusDescriptorTest(); }
+  static void destroySuite(LegacyNexusDescriptorTest *suite) { delete suite; }
 
-  NexusDescriptorTest() {
+  LegacyNexusDescriptorTest() {
     using Mantid::Kernel::ConfigService;
     auto dataPaths = ConfigService::Instance().getDataSearchDirs();
     for (auto &dataPath : dataPaths) {
@@ -45,10 +45,10 @@ class NexusDescriptorTest : public CxxTest::TestSuite {
                                "The AutoTestData directory needs to be in the search path");
     }
 
-    m_testHDF5 = std::make_shared<NexusDescriptor>(m_testHDF5Path);
+    m_testHDF5 = std::make_shared<LegacyNexusDescriptor>(m_testHDF5Path);
   }
 
-  //=================================== NexusDescriptor methods
+  //=================================== LegacyNexusDescriptor methods
   //==================================
 
   void test_Constructor_Initializes_Object_Correctly_Given_HDF_File() {
@@ -57,15 +57,15 @@ class NexusDescriptorTest : public CxxTest::TestSuite {
   }
 
   void test_Constructor_Throws_With_Empty_filename() {
-    TS_ASSERT_THROWS(NexusDescriptor(""), const std::invalid_argument &);
+    TS_ASSERT_THROWS(LegacyNexusDescriptor(""), const std::invalid_argument &);
   }
 
   void test_Constructor_Throws_With_NonExistant_filename() {
-    TS_ASSERT_THROWS(NexusDescriptor("__ThisShouldBeANonExistantFile.txt"), const std::invalid_argument &);
+    TS_ASSERT_THROWS(LegacyNexusDescriptor("__ThisShouldBeANonExistantFile.txt"), const std::invalid_argument &);
   }
 
   void test_Constructor_Throws_When_Given_File_Not_Identified_As_HDF() {
-    TS_ASSERT_THROWS(NexusDescriptor fd(m_testNonHDFPath), const std::invalid_argument &);
+    TS_ASSERT_THROWS(LegacyNexusDescriptor fd(m_testNonHDFPath), const std::invalid_argument &);
   }
 
   void test_File_Handle_Returned_By_Data_Is_Valid() {
@@ -95,5 +95,5 @@ class NexusDescriptorTest : public CxxTest::TestSuite {
 private:
   std::string m_testHDF5Path;
   std::string m_testNonHDFPath;
-  std::shared_ptr<NexusDescriptor> m_testHDF5;
+  std::shared_ptr<LegacyNexusDescriptor> m_testHDF5;
 };

Framework/Muon/inc/MantidMuon/LoadMuonNexus.h

@@ -12,7 +12,7 @@
 #include "MantidAPI/IFileLoader.h"
 #include "MantidDataObjects/Workspace2D_fwd.h"
 #include "MantidGeometry/IDTypes.h"
-#include "MantidKernel/NexusDescriptor.h"
+#include "MantidKernel/LegacyNexusDescriptor.h"
 #include "MantidMuon/DllConfig.h"
 
 //----------------------------------------------------------------------
@@ -48,7 +48,7 @@ multiperiod file)
 together based on the groupings in the NeXus file. </LI>
 </UL>
 */
-class MANTID_MUON_DLL LoadMuonNexus : public API::IFileLoader<Kernel::NexusDescriptor> {
+class MANTID_MUON_DLL LoadMuonNexus : public API::IFileLoader<Kernel::LegacyNexusDescriptor> {
 public:
   /// Default constructor
   LoadMuonNexus();
@@ -68,7 +68,7 @@ class MANTID_MUON_DLL LoadMuonNexus : public API::IFileLoader<Kernel::NexusDescr
   const std::string category() const override { return "DataHandling\\Nexus;Muon\\DataHandling"; }
 
   /// Returns a confidence value that this algorithm can load a file
-  int confidence(Kernel::NexusDescriptor &descriptor) const override;
+  int confidence(Kernel::LegacyNexusDescriptor &descriptor) const override;
 
 protected:
   virtual void runLoadInstrumentFromNexus(DataObjects::Workspace2D_sptr) {}

Framework/Muon/inc/MantidMuon/LoadMuonNexus1.h

@@ -57,7 +57,7 @@ class MANTID_MUON_DLL LoadMuonNexus1 : public LoadMuonNexus {
   LoadMuonNexus1();
 
   /// Returns a confidence value that this algorithm can load a file
-  int confidence(Kernel::NexusDescriptor &descriptor) const override;
+  int confidence(Kernel::LegacyNexusDescriptor &descriptor) const override;
 
 protected:
   /// Overwrites Algorithm method

Framework/Muon/inc/MantidMuon/LoadMuonNexus2.h

@@ -60,7 +60,7 @@ class MANTID_MUON_DLL LoadMuonNexus2 : public LoadMuonNexus {
   const std::vector<std::string> seeAlso() const override { return {"LoadNexus"}; }
 
   /// Returns a confidence value that this algorithm can load a file
-  int confidence(Kernel::NexusDescriptor &descriptor) const override;
+  int confidence(Kernel::LegacyNexusDescriptor &descriptor) const override;
 
 private:
   void exec() override;

Framework/Muon/src/LoadMuonNexus.cpp

@@ -178,7 +178,7 @@ void LoadMuonNexus::runLoadInstrument(const DataObjects::Workspace2D_sptr &local
  * @returns An integer specifying the confidence level. 0 indicates it will not
  * be used
  */
-int LoadMuonNexus::confidence(Kernel::NexusDescriptor &descriptor) const {
+int LoadMuonNexus::confidence(Kernel::LegacyNexusDescriptor &descriptor) const {
   UNUSED_ARG(descriptor);
   return 0; // Not to be used but LoadMuonNexus2, which inherits from this will
 }