Run clang-tidy's performance-* checks on vates folder.

Framework/API/inc/MantidAPI/ImplicitFunctionParameter.h

@@ -66,7 +66,7 @@ public:
 protected:
   bool m_isValid;
 
-  std::string parameterXMLTemplate(std::string valueXMLtext) const {
+  std::string parameterXMLTemplate(const std::string &valueXMLtext) const {
     using namespace Poco::XML;
     AutoPtr<Document> pDoc = new Document;
     AutoPtr<Element> paramElement = pDoc->createElement("Parameter");

Framework/API/src/LogFilterGenerator.cpp

@@ -69,7 +69,7 @@ LogFilterGenerator::generateFilter(const std::string &logName) const {
     break;
   }
 
-  return std::move(flt);
+  return flt;
 }
 
 /**

Framework/Geometry/inc/MantidGeometry/MDGeometry/MDGeometryXMLBuilder.h

@@ -108,7 +108,7 @@ private:
   mutable IMDDimension_const_sptr m_spTDimension;
 
   /// Instantiate and apply the checking policy.
-  void applyPolicyChecking(IMDDimension_const_sptr dimensionToAdd) const;
+  void applyPolicyChecking(const IMDDimension &dimensionToAdd) const;
 
   /// Flag indicating that some change in the inputs has occured. Triggers full
   /// recreation.
@@ -125,17 +125,16 @@ private:
  @date May 2011
  @version 1.0
 */
-struct MANTID_GEOMETRY_DLL StrictDimensionPolicy
-    : public std::unary_function<IMDDimension_const_sptr, void> {
+struct MANTID_GEOMETRY_DLL StrictDimensionPolicy {
 public:
   StrictDimensionPolicy() {}
-  void operator()(IMDDimension_const_sptr item) {
-    if (true == item->getIsIntegrated()) {
+  void operator()(const IMDDimension &item) {
+    if (true == item.getIsIntegrated()) {
       std::string message = "StrictDimensionPolicy bans the use of integrated "
                             "IMDDimensions mapped to x, y, z or t in a "
-                            "IMDWorkspace.";
-      message +=
-          "Attempted to do so with IMDDimension: " + item->getDimensionId();
+                            "IMDWorkspace."
+                            "Attempted to do so with IMDDimension: " +
+                            item.getDimensionId();
       throw std::invalid_argument(message);
     }
   }
@@ -147,9 +146,8 @@ public:
  @author Owen Arnold
  @date May 2011
 */
-struct MANTID_GEOMETRY_DLL NoDimensionPolicy
-    : public std::unary_function<IMDDimension_const_sptr, void> {
-  void operator()(IMDDimension_const_sptr) {
+struct MANTID_GEOMETRY_DLL NoDimensionPolicy {
+  void operator()(const IMDDimension &) {
     // Do nothing.
   }
 };

Framework/Geometry/src/MDGeometry/MDGeometryXMLBuilder.cpp

@@ -23,14 +23,13 @@ namespace Geometry {
  @author Owen Arnold
  @date May 2011
 */
-struct CompareIMDDimension_const_sptr
-    : public std::unary_function<IMDDimension_const_sptr, bool> {
+struct CompareIMDDimension_const_sptr {
 private:
   IMDDimension_const_sptr _a;
-
 public:
-  explicit CompareIMDDimension_const_sptr(IMDDimension_const_sptr a) : _a(a) {}
-  bool operator()(IMDDimension_const_sptr b) {
+  explicit CompareIMDDimension_const_sptr(IMDDimension_const_sptr a)
+      : _a(std::move(a)) {}
+  bool operator()(const IMDDimension_const_sptr &b) {
     return _a->getDimensionId() == b->getDimensionId();
   }
 };
@@ -44,12 +43,12 @@ template <typename CheckDimensionPolicy>
 bool MDGeometryBuilderXML<CheckDimensionPolicy>::addOrdinaryDimension(
     IMDDimension_const_sptr dimensionToAdd) const {
   bool bAdded = false; // Addition fails by default.
-  if (dimensionToAdd.get() != nullptr) {
+  if (dimensionToAdd) {
     CompareIMDDimension_const_sptr comparitor(dimensionToAdd);
     auto location = std::find_if(m_vecDimensions.begin(), m_vecDimensions.end(),
                                  comparitor);
     if (location == m_vecDimensions.end()) {
-      m_vecDimensions.push_back(dimensionToAdd);
+      m_vecDimensions.push_back(std::move(dimensionToAdd));
       bAdded = true;
       m_changed = true;
     }
@@ -104,7 +103,7 @@ MDGeometryBuilderXML<CheckDimensionPolicy> &
  */
 template <typename CheckDimensionPolicy>
 void MDGeometryBuilderXML<CheckDimensionPolicy>::applyPolicyChecking(
-    IMDDimension_const_sptr dimensionToAdd) const {
+    const IMDDimension &dimensionToAdd) const {
   CheckDimensionPolicy policy;
   policy(dimensionToAdd);
 }
@@ -119,10 +118,10 @@ bool MDGeometryBuilderXML<CheckDimensionPolicy>::addXDimension(
     IMDDimension_const_sptr dimension) const {
 
   bool bAdded = false;
-  if (dimension.get() != nullptr) {
-    applyPolicyChecking(dimension);
+  if (dimension) {
+    applyPolicyChecking(*dimension);
     addOrdinaryDimension(dimension);
-    m_spXDimension = dimension;
+    m_spXDimension = std::move(dimension);
     m_changed = true;
     bAdded = true;
   }
@@ -139,10 +138,10 @@ bool MDGeometryBuilderXML<CheckDimensionPolicy>::addYDimension(
     IMDDimension_const_sptr dimension) const {
 
   bool bAdded = false;
-  if (dimension.get() != nullptr) {
-    applyPolicyChecking(dimension);
+  if (dimension) {
+    applyPolicyChecking(*dimension);
     addOrdinaryDimension(dimension);
-    m_spYDimension = dimension;
+    m_spYDimension = std::move(dimension);
     m_changed = true;
     bAdded = true;
   }
@@ -158,10 +157,10 @@ template <typename CheckDimensionPolicy>
 bool MDGeometryBuilderXML<CheckDimensionPolicy>::addZDimension(
     IMDDimension_const_sptr dimension) const {
   bool bAdded = false;
-  if (dimension.get() != nullptr) {
-    applyPolicyChecking(dimension);
+  if (dimension) {
+    applyPolicyChecking(*dimension);
     addOrdinaryDimension(dimension);
-    m_spZDimension = dimension;
+    m_spZDimension = std::move(dimension);
     m_changed = true;
     bAdded = true;
   }
@@ -178,10 +177,10 @@ bool MDGeometryBuilderXML<CheckDimensionPolicy>::addTDimension(
     IMDDimension_const_sptr dimension) const {
 
   bool bAdded = false;
-  if (dimension.get() != nullptr) {
-    applyPolicyChecking(dimension);
+  if (dimension) {
+    applyPolicyChecking(*dimension);
     addOrdinaryDimension(dimension);
-    m_spTDimension = dimension;
+    m_spTDimension = std::move(dimension);
     m_changed = true;
     bAdded = true;
   }

Framework/Kernel/inc/MantidKernel/IPropertyManager.h

@@ -10,8 +10,9 @@
 #include <boost/type_traits.hpp>
 #endif
 
-#include <vector>
 #include <unordered_set>
+#include <utility>
+#include <vector>
 
 namespace Json {
 class Value;
@@ -296,11 +297,12 @@ protected:
   */
   void declareProperty(
       const std::string &name, const char *value,
-      IValidator_sptr validator = IValidator_sptr(new NullValidator),
-      const std::string &doc = "",
+      IValidator_sptr validator = boost::make_shared<NullValidator>(),
+      const std::string &doc = std::string(),
       const unsigned int direction = Direction::Input) {
     // Simply call templated method, converting character array to a string
-    declareProperty(name, std::string(value), validator, doc, direction);
+    declareProperty(name, std::string(value), std::move(validator), doc,
+                    direction);
   }
 
   /** Specialised version of declareProperty template method to prevent the
@@ -325,7 +327,8 @@ protected:
       IValidator_sptr validator = IValidator_sptr(new NullValidator),
       const unsigned int direction = Direction::Input) {
     // Simply call templated method, converting character array to a string
-    declareProperty(name, std::string(value), validator, doc, direction);
+    declareProperty(name, std::string(value), std::move(validator), doc,
+                    direction);
   }
 
   /** Add a property of string type to the list of managed properties

Framework/Kernel/inc/MantidKernel/Strings.h

@@ -57,7 +57,7 @@ namespace Strings {
  */
 template <typename ITERATOR_TYPE>
 DLLExport std::string join(ITERATOR_TYPE begin, ITERATOR_TYPE end,
-                           const std::string separator) {
+                           const std::string &separator) {
   std::ostringstream output;
   ITERATOR_TYPE it;
   for (it = begin; it != end;) {

Vates/ParaviewPlugins/ParaViewSources/MDEWSource/vtkMDEWSource.cxx

@@ -3,26 +3,26 @@
 #include "vtkBox.h"
 #include "vtkInformation.h"
 #include "vtkInformationVector.h"
+#include "vtkNew.h"
 #include "vtkObjectFactory.h"
 #include "vtkPVClipDataSet.h"
 #include "vtkPVInformationKeys.h"
-#include "vtkUnstructuredGridAlgorithm.h"
-#include "vtkUnstructuredGrid.h"
 #include "vtkStreamingDemandDrivenPipeline.h"
-#include "vtkNew.h"
+#include "vtkUnstructuredGrid.h"
+#include "vtkUnstructuredGridAlgorithm.h"
 
-#include "MantidVatesAPI/BoxInfo.h"
-#include "MantidAPI/IMDWorkspace.h"
 #include "MantidAPI/IMDEventWorkspace.h"
+#include "MantidAPI/IMDWorkspace.h"
+#include "MantidKernel/WarningSuppressions.h"
+#include "MantidVatesAPI/ADSWorkspaceProvider.h"
+#include "MantidVatesAPI/BoxInfo.h"
+#include "MantidVatesAPI/FilteringUpdateProgressAction.h"
 #include "MantidVatesAPI/MDEWInMemoryLoadingPresenter.h"
 #include "MantidVatesAPI/MDLoadingViewAdapter.h"
-#include "MantidVatesAPI/ADSWorkspaceProvider.h"
+#include "MantidVatesAPI/vtkMD0DFactory.h"
 #include "MantidVatesAPI/vtkMDHexFactory.h"
-#include "MantidVatesAPI/vtkMDQuadFactory.h"
 #include "MantidVatesAPI/vtkMDLineFactory.h"
-#include "MantidVatesAPI/vtkMD0DFactory.h"
-#include "MantidVatesAPI/FilteringUpdateProgressAction.h"
-#include "MantidKernel/WarningSuppressions.h"
+#include "MantidVatesAPI/vtkMDQuadFactory.h"
 
 #include <boost/optional.hpp>
 
@@ -44,13 +44,11 @@ vtkMDEWSource::~vtkMDEWSource() {}
  Setter for the recursion depth
  @param depth : recursion depth to use
 */
-void vtkMDEWSource::SetDepth(int depth)
-{
+void vtkMDEWSource::SetDepth(int depth) {
   size_t temp = depth;
-  if(m_depth != temp)
-  {
-   this->m_depth = temp;
-   this->Modified();
+  if (m_depth != temp) {
+    this->m_depth = temp;
+    this->Modified();
   }
 }
 
@@ -58,10 +56,8 @@ void vtkMDEWSource::SetDepth(int depth)
   Setter for the workspace name.
   @param name : workspace name to extract from ADS.
 */
-void vtkMDEWSource::SetWsName(std::string name)
-{
-  if(m_wsName != name && name != "")
-  {
+void vtkMDEWSource::SetWsName(const std::string &name) {
+  if (m_wsName != name && name != "") {
     m_wsName = name;
     this->Modified();
   }
@@ -147,32 +143,32 @@ std::string vtkMDEWSource::GetInstrument() {
 }
 
 /**
-Set the normalization option. This is how the signal data will be normalized before viewing.
+Set the normalization option. This is how the signal data will be normalized
+before viewing.
 @param option : Normalization option
 */
-void vtkMDEWSource::SetNormalization(int option)
-{
+void vtkMDEWSource::SetNormalization(int option) {
   m_normalization = static_cast<Mantid::VATES::VisualNormalization>(option);
   this->Modified();
 }
 
-
-int vtkMDEWSource::RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *outputVector)
-{
-  if(m_presenter->canReadFile())
-  {
+int vtkMDEWSource::RequestData(vtkInformation *, vtkInformationVector **,
+                               vtkInformationVector *outputVector) {
+  if (m_presenter->canReadFile()) {
     using namespace Mantid::VATES;
-    //get the info objects
+    // get the info objects
     vtkInformation *outInfo = outputVector->GetInformationObject(0);
 
-    if (outInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP()))
-    {
+    if (outInfo->Has(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP())) {
       // usually only one actual step requested
-      m_time =outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP());
+      m_time =
+          outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEP());
     }
 
-    FilterUpdateProgressAction<vtkMDEWSource> loadingProgressUpdate(this, "Loading...");
-    FilterUpdateProgressAction<vtkMDEWSource> drawingProgressUpdate(this, "Drawing...");
+    FilterUpdateProgressAction<vtkMDEWSource> loadingProgressUpdate(
+        this, "Loading...");
+    FilterUpdateProgressAction<vtkMDEWSource> drawingProgressUpdate(
+        this, "Drawing...");
 
     auto hexahedronFactory =
         Mantid::Kernel::make_unique<vtkMDHexFactory>(m_normalization);
@@ -189,7 +185,8 @@ int vtkMDEWSource::RequestData(vtkInformation *, vtkInformationVector **, vtkInf
     product = m_presenter->execute(
         hexahedronFactory.get(), loadingProgressUpdate, drawingProgressUpdate);
 
-    //-------------------------------------------------------- Corrects problem whereby boundaries not set propertly in PV.
+    //-------------------------------------------------------- Corrects problem
+    // whereby boundaries not set propertly in PV.
     auto box = vtkSmartPointer<vtkBox>::New();
     box->SetBounds(product->GetBounds());
     auto clipper = vtkSmartPointer<vtkPVClipDataSet>::New();
@@ -201,18 +198,16 @@ int vtkMDEWSource::RequestData(vtkInformation *, vtkInformationVector **, vtkInf
     //--------------------------------------------------------
 
     vtkUnstructuredGrid *output = vtkUnstructuredGrid::SafeDownCast(
-      outInfo->Get(vtkDataObject::DATA_OBJECT()));
+        outInfo->Get(vtkDataObject::DATA_OBJECT()));
     output->ShallowCopy(clipperOutput);
 
-    try
-    {
-      auto workspaceProvider = Mantid::Kernel::make_unique<ADSWorkspaceProvider<Mantid::API::IMDWorkspace>>();
+    try {
+      auto workspaceProvider = Mantid::Kernel::make_unique<
+          ADSWorkspaceProvider<Mantid::API::IMDWorkspace>>();
       m_presenter->makeNonOrthogonal(output, std::move(workspaceProvider),
                                      &drawingProgressUpdate);
-    }
-    catch (std::invalid_argument &e)
-    {
-    std::string error = e.what();
+    } catch (std::invalid_argument &e) {
+      std::string error = e.what();
       vtkDebugMacro(<< "Workspace does not have correct information to "
                     << "plot non-orthogonal axes. " << error);
       // Add the standard change of basis matrix and set the boundaries
@@ -239,9 +234,10 @@ int vtkMDEWSource::RequestInformation(
     if (m_presenter->canReadFile()) {
       // If the MDEvent workspace has had top level splitting applied to it,
       // then use the a deptgit stah of 1
-      auto workspaceProvider = Mantid::Kernel::make_unique<ADSWorkspaceProvider<Mantid::API::IMDEventWorkspace>>();
-      if (auto split =
-              Mantid::VATES::findRecursionDepthForTopLevelSplitting(m_wsName, std::move(workspaceProvider))) {
+      auto workspaceProvider = Mantid::Kernel::make_unique<
+          ADSWorkspaceProvider<Mantid::API::IMDEventWorkspace>>();
+      if (auto split = Mantid::VATES::findRecursionDepthForTopLevelSplitting(
+              m_wsName, *workspaceProvider)) {
         SetDepth(split.get());
       }
 
@@ -254,24 +250,21 @@ int vtkMDEWSource::RequestInformation(
   return 1;
 }
 
-void vtkMDEWSource::PrintSelf(ostream& os, vtkIndent indent)
-{
+void vtkMDEWSource::PrintSelf(ostream &os, vtkIndent indent) {
   this->Superclass::PrintSelf(os, indent);
 }
 
 /** Helper function to setup the time range.
 @param outputVector : vector onto which the time range will be set.
 */
-void vtkMDEWSource::setTimeRange(vtkInformationVector* outputVector)
-{
-  if(m_presenter->hasTDimensionAvailable())
-  {
+void vtkMDEWSource::setTimeRange(vtkInformationVector *outputVector) {
+  if (m_presenter->hasTDimensionAvailable()) {
     vtkInformation *outInfo = outputVector->GetInformationObject(0);
     outInfo->Set(vtkPVInformationKeys::TIME_LABEL_ANNOTATION(),
                  m_presenter->getTimeStepLabel().c_str());
     std::vector<double> timeStepValues = m_presenter->getTimeStepValues();
-    outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_STEPS(), &timeStepValues[0],
-      static_cast<int> (timeStepValues.size()));
+    outInfo->Set(vtkStreamingDemandDrivenPipeline::TIME_STEPS(),
+                 &timeStepValues[0], static_cast<int>(timeStepValues.size()));
     double timeRange[2];
     timeRange[0] = timeStepValues.front();
     timeRange[1] = timeStepValues.back();
@@ -284,35 +277,26 @@ void vtkMDEWSource::setTimeRange(vtkInformationVector* outputVector)
 Getter for the recursion depth.
 @return depth
 */
-size_t vtkMDEWSource::getRecursionDepth() const
-{
-  return this->m_depth;
-}
+size_t vtkMDEWSource::getRecursionDepth() const { return this->m_depth; }
 
 /*
 Getter for the load in memory status
 @return true.
 */
-bool vtkMDEWSource::getLoadInMemory() const
-{
-  return true;
-}
+bool vtkMDEWSource::getLoadInMemory() const { return true; }
 
 /*Getter for the time
 @return the time.
 */
-double vtkMDEWSource::getTime() const
-{
-  return m_time;
-}
+double vtkMDEWSource::getTime() const { return m_time; }
 
 /*
 Setter for the algorithm progress.
 @param progress : progress increment
 @param message : progress message
 */
-void vtkMDEWSource::updateAlgorithmProgress(double progress, const std::string& message)
-{
+void vtkMDEWSource::updateAlgorithmProgress(double progress,
+                                            const std::string &message) {
   this->SetProgressText(message.c_str());
   this->UpdateProgress(progress);
 }

Vates/ParaviewPlugins/ParaViewSources/MDEWSource/vtkMDEWSource.h

@@ -50,7 +50,7 @@ public:
   vtkTypeMacro(vtkMDEWSource, vtkUnstructuredGridAlgorithm) void PrintSelf(
       ostream &os, vtkIndent indent) override;
 
-  void SetWsName(std::string wsName);
+  void SetWsName(const std::string &wsName);
   void SetDepth(int depth);
   void SetNormalization(int option);
 

Vates/ParaviewPlugins/ParaViewSources/PeaksSource/vtkPeaksSource.cxx

@@ -40,8 +40,7 @@ vtkPeaksSource::~vtkPeaksSource()
   Setter for the workspace name.
   @param name : workspace name to extract from ADS.
 */
-void vtkPeaksSource::SetWsName(std::string name)
-{
+void vtkPeaksSource::SetWsName(const std::string &name) {
   if (!name.empty())
   {
     m_wsName = name;

Vates/ParaviewPlugins/ParaViewSources/PeaksSource/vtkPeaksSource.h

@@ -45,7 +45,7 @@ public:
                vtkPolyDataAlgorithm) void PrintSelf(ostream &os,
                                                     vtkIndent indent) override;
 
-  void SetWsName(std::string wsName);
+  void SetWsName(const std::string &wsName);
   void SetPeakDimension(int dim);
   /// Setter for the unitegrated peak marker size
   void SetUnintPeakMarkerSize(double mSize);

Vates/VatesAPI/inc/MantidVatesAPI/BoxInfo.h

@@ -42,7 +42,7 @@ Code Documentation is available at: <http://doxygen.mantidproject.org>
  */
 boost::optional<int> DLLExport findRecursionDepthForTopLevelSplitting(
     const std::string &workspaceName,
-    std::unique_ptr<WorkspaceProvider> workspaceProvider);
+    const WorkspaceProvider &workspaceProvider);
 }
 }
 

Vates/VatesAPI/inc/MantidVatesAPI/CompositePeaksPresenterVsi.h

@@ -37,9 +37,9 @@ public:
   void removePresenter(const std::string &peaksWorkspaceName);
   void updateWorkspaces(const std::vector<std::string> &peaksWorkspaceNames);
   void sortPeaksWorkspace(const std::string &, const bool) override {}
-  void sortPeaksWorkspace(
-      const std::string &columnToSortBy, const bool sortedAscending,
-      boost::shared_ptr<const Mantid::API::IPeaksWorkspace> peaksWS);
+  void sortPeaksWorkspace(const std::string &columnToSortBy,
+                          const bool sortedAscending,
+                          const Mantid::API::IPeaksWorkspace *peaksWS);
   bool hasPeaks();
 
 private:
@@ -48,4 +48,4 @@ private:
 };
 }
 }
-#endif
+#endif
\ No newline at end of file

Vates/VatesAPI/inc/MantidVatesAPI/ConcretePeaksPresenterVsi.h

@@ -32,7 +32,7 @@ public:
 
 private:
   /// Get the max radius.
-  double getMaxRadius(Mantid::Geometry::PeakShape_sptr shape) const;
+  double getMaxRadius(const Mantid::Geometry::PeakShape &shape) const;
   /// Viewable Peaks
   mutable std::vector<bool> m_viewablePeaks;
   /// The viewable region
@@ -44,4 +44,4 @@ private:
 };
 }
 }
-#endif
+#endif
\ No newline at end of file

Vates/VatesAPI/inc/MantidVatesAPI/EventNexusLoadingPresenter.h

@@ -37,7 +37,7 @@ class MDLoadingView;
 class DLLExport EventNexusLoadingPresenter : public MDEWLoadingPresenter {
 public:
   EventNexusLoadingPresenter(std::unique_ptr<MDLoadingView> view,
-                             const std::string fileName);
+                             const std::string &fileName);
   vtkSmartPointer<vtkDataSet>
   execute(vtkDataSetFactory *factory, ProgressAction &loadingProgressUpdate,
           ProgressAction &drawingProgressUpdate) override;

Vates/VatesAPI/inc/MantidVatesAPI/FactoryChains.h

@@ -33,8 +33,8 @@ void DLLExport applyCOBMatrixSettingsToVtkDataSet(
     std::unique_ptr<Mantid::VATES::WorkspaceProvider> workspaceProvider);
 
 /// Function to get clipped data sets.
-vtkSmartPointer<vtkPVClipDataSet> DLLExport
-getClippedDataSet(vtkSmartPointer<vtkDataSet> dataSet);
+vtkSmartPointer<vtkPVClipDataSet>
+    DLLExport getClippedDataSet(const vtkSmartPointer<vtkDataSet> &dataSet);
 
 /// Create name with timestamp attached.
 std::string DLLExport createTimeStampedName(const std::string &name);

Vates/VatesAPI/inc/MantidVatesAPI/FieldDataToMetadata.h

@@ -41,7 +41,7 @@ class DLLExport FieldDataToMetadata
     : public std::binary_function<vtkFieldData *, std::string, std::string> {
 public:
   /// Act as Functor.
-  std::string operator()(vtkFieldData *fieldData, std::string id) const;
+  std::string operator()(vtkFieldData *fieldData, const std::string &id) const;
 
   /// Explicit call to Functor execution.
   std::string execute(vtkFieldData *fieldData, const std::string &id) const;

Vates/VatesAPI/inc/MantidVatesAPI/IMDDimensionComparitor.h

@@ -45,13 +45,13 @@ public:
   /// Destructor
   ~IMDDimensionComparitor();
 
-  bool isXDimension(Mantid::Geometry::IMDDimension_const_sptr queryDimension);
+  bool isXDimension(const Mantid::Geometry::IMDDimension &queryDimension);
 
-  bool isYDimension(Mantid::Geometry::IMDDimension_const_sptr queryDimension);
+  bool isYDimension(const Mantid::Geometry::IMDDimension &queryDimension);
 
-  bool isZDimension(Mantid::Geometry::IMDDimension_const_sptr queryDimension);
+  bool isZDimension(const Mantid::Geometry::IMDDimension &queryDimension);
 
-  bool istDimension(Mantid::Geometry::IMDDimension_const_sptr queryDimension);
+  bool istDimension(const Mantid::Geometry::IMDDimension &queryDimension);
 
 private:
   /// imd workspace shared ptr.

Vates/VatesAPI/inc/MantidVatesAPI/MDHWNexusLoadingPresenter.h

@@ -38,7 +38,7 @@ class MDLoadingView;
 class DLLExport MDHWNexusLoadingPresenter : public MDHWLoadingPresenter {
 public:
   MDHWNexusLoadingPresenter(std::unique_ptr<MDLoadingView> view,
-                            const std::string fileName);
+                            const std::string &fileName);
   vtkSmartPointer<vtkDataSet>
   execute(vtkDataSetFactory *factory, ProgressAction &rebinningProgressUpdate,
           ProgressAction &drawingProgressUpdate) override;

Vates/VatesAPI/inc/MantidVatesAPI/MetaDataExtractorUtils.h

@@ -47,14 +47,14 @@ public:
     * @param workspace A pointer to the workspace
     * @returns A pair of minimum and maximum values.
     */
-  QwtDoubleInterval getMinAndMax(Mantid::API::IMDWorkspace_sptr workspace);
+  QwtDoubleInterval getMinAndMax(const Mantid::API::IMDWorkspace *workspace);
 
   /**
     * Extracts the instrument from the workspace.
     * @param workspace A pointer to a workspace.
     * @returns The instrument.
     */
-  std::string extractInstrument(Mantid::API::IMDWorkspace_sptr workspace);
+  std::string extractInstrument(const Mantid::API::IMDWorkspace *workspace);
 
 private:
   /**
@@ -69,4 +69,4 @@ private:
 };
 }
 }
-#endif
+#endif
\ No newline at end of file

Vates/VatesAPI/inc/MantidVatesAPI/MetadataJsonManager.h

@@ -43,9 +43,9 @@ public:
 
   std::string getSerializedJson();
 
-  void readInSerializedJson(std::string serializedJson);
+  void readInSerializedJson(const std::string &serializedJson);
 
-  void setInstrument(std::string instrument);
+  void setInstrument(const std::string &instrument);
   std::string &getInstrument();
 
   void setMinValue(double minValue);