Commit 11994bc3 authored by Giovanni Di Siena's avatar Giovanni Di Siena Committed by Gigg, Martyn Anthony
Browse files

Replace boost::shared with std::shared

In places other substitutions have been made, e.g
Clang does not yet specialize std::shared_ptr for T[]. Vector
has been used instead. The operator[] methods were incorrectly
marked const but returning a non-const reference - this has been fixed.
Refs #25842
parent 517e363e
......@@ -7,6 +7,7 @@
#pragma once
#include <atomic>
#include <memory>
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/IAlgorithm.h"
......@@ -24,9 +25,6 @@
#include "MantidParallel/ExecutionMode.h"
#include "MantidParallel/StorageMode.h"
namespace boost {
template <class T> class weak_ptr;
}
namespace Poco {
template <class R, class A, class O, class S> class ActiveMethod;
......@@ -182,7 +180,7 @@ public:
template <typename T, typename = typename std::enable_if<std::is_convertible<
T *, MatrixWorkspace *>::value>::type>
std::tuple<boost::shared_ptr<T>, Indexing::SpectrumIndexSet>
std::tuple<std::shared_ptr<T>, Indexing::SpectrumIndexSet>
getWorkspaceAndIndices(const std::string &name) const;
template <typename T1, typename T2,
......@@ -192,7 +190,7 @@ public:
std::is_convertible<T2 *, std::string *>::value ||
std::is_convertible<T2 *, std::vector<int64_t> *>::value>::type>
void setWorkspaceInputProperties(const std::string &name,
const boost::shared_ptr<T1> &wksp,
const std::shared_ptr<T1> &wksp,
IndexType type, const T2 &list);
template <typename T1, typename T2,
......@@ -283,20 +281,20 @@ public:
static IAlgorithm_sptr fromHistory(const AlgorithmHistory &history);
//@}
virtual boost::shared_ptr<Algorithm> createChildAlgorithm(
virtual std::shared_ptr<Algorithm> createChildAlgorithm(
const std::string &name, const double startProgress = -1.,
const double endProgress = -1., const bool enableLogging = true,
const int &version = -1);
void setupAsChildAlgorithm(const boost::shared_ptr<Algorithm> &algorithm,
void setupAsChildAlgorithm(const std::shared_ptr<Algorithm> &algorithm,
const double startProgress = -1.,
const double endProgress = -1.,
const bool enableLogging = true);
/// set whether we wish to track the child algorithm's history and pass it the
/// parent object to fill.
void trackAlgorithmHistory(boost::shared_ptr<AlgorithmHistory> parentHist);
void trackAlgorithmHistory(std::shared_ptr<AlgorithmHistory> parentHist);
using WorkspaceVector = std::vector<boost::shared_ptr<Workspace>>;
using WorkspaceVector = std::vector<std::shared_ptr<Workspace>>;
void findWorkspaces(WorkspaceVector &workspaces, unsigned int direction,
bool checkADS = false) const;
......@@ -385,14 +383,14 @@ protected:
/// All the WorkspaceProperties that are Input or InOut. Set in execute()
std::vector<IWorkspaceProperty *> m_inputWorkspaceProps;
/// Pointer to the history for the algorithm being executed
boost::shared_ptr<AlgorithmHistory> m_history;
std::shared_ptr<AlgorithmHistory> m_history;
/// Logger for this algorithm
Kernel::Logger m_log;
Kernel::Logger &g_log;
/// Pointer to the parent history object (if set)
boost::shared_ptr<AlgorithmHistory> m_parentHistory;
std::shared_ptr<AlgorithmHistory> m_parentHistory;
/// One vector of workspaces for each input workspace property. A group is
/// unrolled to its constituent members
......@@ -473,11 +471,11 @@ private:
mutable double m_endChildProgress; ///< Keeps value for algorithm's progress
/// at Child Algorithm's finish
AlgorithmID m_algorithmID; ///< Algorithm ID for managed algorithms
std::vector<boost::weak_ptr<IAlgorithm>> m_ChildAlgorithms; ///< A list of
/// weak pointers
/// to any child
/// algorithms
/// created
std::vector<std::weak_ptr<IAlgorithm>> m_ChildAlgorithms; ///< A list of
/// weak pointers
/// to any child
/// algorithms
/// created
/// Vector of all the workspaces that have been read-locked
WorkspaceVector m_readLockedWorkspaces;
......@@ -490,7 +488,7 @@ private:
std::vector<IWorkspaceProperty *> m_pureOutputWorkspaceProps;
/// Pointer to the WorkspaceGroup (if any) for each input workspace property
std::vector<boost::shared_ptr<WorkspaceGroup>> m_groupWorkspaces;
std::vector<std::shared_ptr<WorkspaceGroup>> m_groupWorkspaces;
/// If only one input is a group, this is its index. -1 if they are all groups
int m_singleGroup;
/// All the groups have similar names (group_1, group_2 etc.)
......@@ -507,7 +505,7 @@ private:
};
/// Typedef for a shared pointer to an Algorithm
using Algorithm_sptr = boost::shared_ptr<Algorithm>;
using Algorithm_sptr = std::shared_ptr<Algorithm>;
} // namespace API
} // namespace Mantid
......
......@@ -11,16 +11,19 @@
#include "MantidAPI/WorkspaceProperty.h"
#include "MantidIndexing/SpectrumIndexSet.h"
#include <memory>
#include <type_traits>
namespace {
template <typename T1, typename T2>
void setWorkspaceProperty(Mantid::API::WorkspaceProperty<T1> *wsProp,
const T2 &wksp, const boost::true_type &) {
const T2 &wksp, const std::true_type &) {
*wsProp = wksp;
}
template <typename T1, typename T2>
void setWorkspaceProperty(Mantid::API::WorkspaceProperty<T1> *wsProp,
const T2 &wksp, const boost::false_type &) {
const T2 &wksp, const std::false_type &) {
wsProp->setValue(wksp);
}
} // namespace
......@@ -90,7 +93,7 @@ void Algorithm::doSetInputProperties(const std::string &name, const T1 &wksp,
getPointerToProperty(IndexProperty::generatePropertyName(name)));
setWorkspaceProperty<WsType, T1>(
wsProp, wksp, boost::is_convertible<T1, boost::shared_ptr<WsType>>());
wsProp, wksp, std::is_convertible<T1, std::shared_ptr<WsType>>());
*indexTypeProp = type;
......@@ -108,9 +111,9 @@ void Algorithm::doSetInputProperties(const std::string &name, const T1 &wksp,
*/
template <typename T1, typename T2, typename, typename>
void Algorithm::setWorkspaceInputProperties(const std::string &name,
const boost::shared_ptr<T1> &wksp,
const std::shared_ptr<T1> &wksp,
IndexType type, const T2 &list) {
doSetInputProperties<boost::shared_ptr<T1>, T2, T1>(name, wksp, type, list);
doSetInputProperties<std::shared_ptr<T1>, T2, T1>(name, wksp, type, list);
}
/** Mechanism for setting the index property with a workspace shared pointer.
......@@ -136,7 +139,7 @@ if T is convertible to a MatrixWorkspace.
@returns Tuple containing Workspace shared pointer and SpectrumIndexSet
*/
template <typename T, typename>
std::tuple<boost::shared_ptr<T>, Indexing::SpectrumIndexSet>
std::tuple<std::shared_ptr<T>, Indexing::SpectrumIndexSet>
Algorithm::getWorkspaceAndIndices(const std::string &name) const {
if (!isCompoundProperty(name))
throw std::runtime_error(
......@@ -144,7 +147,7 @@ Algorithm::getWorkspaceAndIndices(const std::string &name) const {
"with properties declared using "
"declareWorkspaceInputProperties.");
boost::shared_ptr<T> ws = getProperty(name);
std::shared_ptr<T> ws = getProperty(name);
// Not able to use the regular getProperty mechanism because types, in this
// case SpectrumIndexSet, need to be known upfront. Since SpectrumIndexSet is
......
......@@ -12,6 +12,7 @@
#include "MantidAPI/DllConfig.h"
#include "MantidKernel/DynamicFactory.h"
#include "MantidKernel/SingletonHolder.h"
#include <memory>
#include <sstream>
#include <unordered_set>
#include <vector>
......@@ -50,7 +51,7 @@ public:
// Unhide the base class version (to satisfy the intel compiler)
using Kernel::DynamicFactory<Algorithm>::create;
/// Creates an instance of an algorithm
boost::shared_ptr<Algorithm> create(const std::string &, const int &) const;
std::shared_ptr<Algorithm> create(const std::string &, const int &) const;
/// algorithm factory specific function to subscribe algorithms, calls the
/// dynamic factory subscribe function internally
......@@ -72,7 +73,7 @@ public:
std::pair<std::string, int>
subscribe(std::unique_ptr<Kernel::AbstractInstantiator<T>> instantiator,
const SubscribeAction replaceExisting = ErrorIfExists) {
boost::shared_ptr<IAlgorithm> tempAlg = instantiator->createInstance();
std::shared_ptr<IAlgorithm> tempAlg = instantiator->createInstance();
const int version = extractAlgVersion(tempAlg);
const std::string className = extractAlgName(tempAlg);
typename VersionMap::const_iterator it = m_vmap.find(className);
......@@ -129,13 +130,13 @@ private:
/// Extract the name of an algorithm
const std::string
extractAlgName(const boost::shared_ptr<IAlgorithm> &alg) const;
extractAlgName(const std::shared_ptr<IAlgorithm> &alg) const;
/// Extract the version of an algorithm
int extractAlgVersion(const boost::shared_ptr<IAlgorithm> &alg) const;
int extractAlgVersion(const std::shared_ptr<IAlgorithm> &alg) const;
/// Create an algorithm object with the specified name
boost::shared_ptr<Algorithm> createAlgorithm(const std::string &name,
const int version) const;
std::shared_ptr<Algorithm> createAlgorithm(const std::string &name,
const int version) const;
/// Private Constructor for singleton class
AlgorithmFactoryImpl();
......
......@@ -22,7 +22,7 @@ class IAlgorithm;
@date 30/03/2011
*/
class MANTID_API_DLL AlgorithmHasProperty
: public Kernel::TypedValidator<boost::shared_ptr<IAlgorithm>> {
: public Kernel::TypedValidator<std::shared_ptr<IAlgorithm>> {
public:
AlgorithmHasProperty(const std::string &propName);
std::string getType() const;
......@@ -30,7 +30,7 @@ public:
protected:
std::string
checkValidity(const boost::shared_ptr<IAlgorithm> &value) const override;
checkValidity(const std::shared_ptr<IAlgorithm> &value) const override;
private:
/// Store the property name
......
......@@ -25,8 +25,8 @@ class Algorithm;
class AlgorithmHistory;
// typedefs for algorithm history pointers
using AlgorithmHistory_sptr = boost::shared_ptr<AlgorithmHistory>;
using AlgorithmHistory_const_sptr = boost::shared_ptr<const AlgorithmHistory>;
using AlgorithmHistory_sptr = std::shared_ptr<AlgorithmHistory>;
using AlgorithmHistory_const_sptr = std::shared_ptr<const AlgorithmHistory>;
using AlgorithmHistories = std::vector<AlgorithmHistory_sptr>;
/** @class AlgorithmHistory AlgorithmHistory.h API/MAntidAPI/AlgorithmHistory.h
......@@ -107,9 +107,9 @@ public:
return (execCount() == other.execCount() && name() == other.name());
}
/// Create a concrete algorithm based on a history record
boost::shared_ptr<IAlgorithm> createAlgorithm() const;
std::shared_ptr<IAlgorithm> createAlgorithm() const;
/// Create an child algorithm from a history record at a given index
boost::shared_ptr<IAlgorithm> getChildAlgorithm(const size_t index) const;
std::shared_ptr<IAlgorithm> getChildAlgorithm(const size_t index) const;
/// Write this history object to a nexus file
void saveNexus(::NeXus::File *file, int &algCount) const;
// Set the execution count
......
......@@ -44,8 +44,8 @@ public:
/// Creates a managed algorithm with the option of choosing a version
IAlgorithm_sptr create(const std::string &algName, const int &version = -1);
/// Creates an unmanaged algorithm with the option of choosing a version
boost::shared_ptr<Algorithm> createUnmanaged(const std::string &algName,
const int &version = -1) const;
std::shared_ptr<Algorithm> createUnmanaged(const std::string &algName,
const int &version = -1) const;
std::size_t size() const;
......
......@@ -34,10 +34,10 @@ API::IAlgorithm interface.
@date 24/03/2011
*/
class MANTID_API_DLL AlgorithmProperty
: public Kernel::PropertyWithValue<boost::shared_ptr<IAlgorithm>> {
: public Kernel::PropertyWithValue<std::shared_ptr<IAlgorithm>> {
public:
/// Typedef the held type
using HeldType = boost::shared_ptr<IAlgorithm>;
using HeldType = std::shared_ptr<IAlgorithm>;
/// Constructor
AlgorithmProperty(const std::string &propName,
......
......@@ -50,7 +50,7 @@ public:
public:
/// Constructor
GroupWorkspacesNotification(const std::vector<std::string> &wsnames)
: DataServiceNotification("", boost::shared_ptr<API::Workspace>()),
: DataServiceNotification("", std::shared_ptr<API::Workspace>()),
m_wsnames(wsnames) {}
/// returns the workspace names
const std::vector<std::string> &inputworkspacenames() const {
......@@ -67,7 +67,7 @@ public:
public:
/// Constructor
UnGroupingWorkspaceNotification(const std::string &name,
const boost::shared_ptr<Workspace> &obj)
const std::shared_ptr<Workspace> &obj)
: DataServiceNotification(name, obj) {}
};
......@@ -81,7 +81,7 @@ public:
/// Constructor
GroupUpdatedNotification(const std::string &name);
/// Returns the workspace pointer cast to WorkspaceGroup
boost::shared_ptr<const WorkspaceGroup> getWorkspaceGroup() const;
std::shared_ptr<const WorkspaceGroup> getWorkspaceGroup() const;
};
//@}
......@@ -96,12 +96,11 @@ public:
/// Overridden add member to attach the name to the workspace when a
/// workspace object is added to the service
void add(const std::string &name,
const boost::shared_ptr<API::Workspace> &workspace) override;
const std::shared_ptr<API::Workspace> &workspace) override;
/// Overridden addOrReplace member to attach the name to the workspace when
/// a workspace object is added to the service
void
addOrReplace(const std::string &name,
const boost::shared_ptr<API::Workspace> &workspace) override;
void addOrReplace(const std::string &name,
const std::shared_ptr<API::Workspace> &workspace) override;
/// Overridden rename member to attach the new name to the workspace when a
/// workspace object is renamed
virtual void rename(const std::string &oldName, const std::string &newName);
......@@ -116,11 +115,11 @@ public:
* @return a shared pointer of WSTYPE
*/
template <typename WSTYPE>
boost::shared_ptr<WSTYPE> retrieveWS(const std::string &name) const {
std::shared_ptr<WSTYPE> retrieveWS(const std::string &name) const {
// Get as a bare workspace
try {
// Cast to the desired type and return that.
return boost::dynamic_pointer_cast<WSTYPE>(
return std::dynamic_pointer_cast<WSTYPE>(
Kernel::DataService<API::Workspace>::retrieve(name));
} catch (Kernel::Exception::NotFoundError &) {
......@@ -147,7 +146,7 @@ public:
private:
/// Checks the name is valid, throwing if not
void verifyName(const std::string &name,
const boost::shared_ptr<API::WorkspaceGroup> &workspace);
const std::shared_ptr<API::WorkspaceGroup> &workspace);
friend struct Mantid::Kernel::CreateUsingNew<AnalysisDataServiceImpl>;
/// Constructor
......
......@@ -9,7 +9,7 @@
#include "MantidAPI/DllConfig.h"
#include "MantidGeometry/IDTypes.h"
#include <boost/shared_ptr.hpp>
#include <memory>
#include <string>
namespace Mantid {
......@@ -41,11 +41,11 @@ public:
const std::string &title() const;
std::string &title();
const boost::shared_ptr<Kernel::Unit> &unit() const;
boost::shared_ptr<Kernel::Unit> &unit();
const std::shared_ptr<Kernel::Unit> &unit() const;
std::shared_ptr<Kernel::Unit> &unit();
/// Set the unit on the Axis
virtual const boost::shared_ptr<Kernel::Unit> &
virtual const std::shared_ptr<Kernel::Unit> &
setUnit(const std::string &unitName);
/// Returns true is the axis is a Spectra axis
......@@ -98,7 +98,7 @@ private:
/// The user-defined title for this axis
std::string m_title;
/// The unit for this axis
boost::shared_ptr<Kernel::Unit> m_unit;
std::shared_ptr<Kernel::Unit> m_unit;
};
} // namespace API
......
......@@ -41,7 +41,7 @@ public:
BoxController(size_t nd)
: nd(nd), m_maxId(0), m_SplitThreshold(1024), m_splitTopInto(boost::none),
m_numSplit(1), m_numTopSplit(1),
m_fileIO(boost::shared_ptr<API::IBoxControllerIO>()) {
m_fileIO(std::shared_ptr<API::IBoxControllerIO>()) {
// TODO: Smarter ways to determine all of these values
m_maxDepth = 5;
m_numEventsAtMax = 0;
......@@ -399,7 +399,7 @@ public:
IBoxControllerIO *getFileIO() { return m_fileIO.get(); }
/// makes box controller file based by providing class, responsible for
/// fileIO.
void setFileBacked(const boost::shared_ptr<IBoxControllerIO> &newFileIO,
void setFileBacked(const std::shared_ptr<IBoxControllerIO> &newFileIO,
const std::string &fileName = "");
void clearFileBacked();
//-----------------------------------------------------------------------------------
......@@ -530,7 +530,7 @@ private:
std::mutex m_idMutex;
// the class which does actual IO operations, including MRU support list
boost::shared_ptr<IBoxControllerIO> m_fileIO;
std::shared_ptr<IBoxControllerIO> m_fileIO;
/// Number of bytes in a single MDLeanEvent<> of the workspace.
// size_t m_bytesPerEvent;
......@@ -538,10 +538,10 @@ public:
};
/// Shared ptr to BoxController
using BoxController_sptr = boost::shared_ptr<BoxController>;
using BoxController_sptr = std::shared_ptr<BoxController>;
/// Shared ptr to a const BoxController
using BoxController_const_sptr = boost::shared_ptr<const BoxController>;
using BoxController_const_sptr = std::shared_ptr<const BoxController>;
} // namespace API
......
......@@ -58,7 +58,7 @@ private:
~CatalogFactoryImpl() override = default;
/// Stores pointers to already created Catalog instances, with their name as
/// the key
mutable std::map<std::string, boost::shared_ptr<ICatalog>> m_createdCatalogs;
mutable std::map<std::string, std::shared_ptr<ICatalog>> m_createdCatalogs;
};
/// The specialisation of the SingletonHolder class that holds the
......
......@@ -34,7 +34,7 @@ private:
std::string m_endpoint;
};
using CatalogSession_sptr = boost::shared_ptr<CatalogSession>;
using CatalogSession_const_sptr = boost::shared_ptr<const CatalogSession>;
using CatalogSession_sptr = std::shared_ptr<CatalogSession>;
using CatalogSession_const_sptr = std::shared_ptr<const CatalogSession>;
} // namespace API
} // namespace Mantid
......@@ -12,7 +12,7 @@
#include "MantidAPI/DllConfig.h"
#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#include <memory>
#endif
#include <cstring>
#include <limits>
......@@ -239,8 +239,8 @@ MANTID_API_DLL std::ostream &operator<<(std::ostream &, const API::Boolean &);
/// Redaing a Boolean from an input stream
MANTID_API_DLL std::istream &operator>>(std::istream &istr, API::Boolean &);
using Column_sptr = boost::shared_ptr<Column>;
using Column_const_sptr = boost::shared_ptr<const Column>;
using Column_sptr = std::shared_ptr<Column>;
using Column_const_sptr = std::shared_ptr<const Column>;
} // namespace API
} // Namespace Mantid
......@@ -37,7 +37,7 @@ public:
ColumnFactoryImpl(const ColumnFactoryImpl &) = delete;
ColumnFactoryImpl &operator=(const ColumnFactoryImpl &) = delete;
/// Creates an instance of a column
boost::shared_ptr<Column> create(const std::string &type) const override;
std::shared_ptr<Column> create(const std::string &type) const override;
private:
friend struct Mantid::Kernel::CreateUsingNew<ColumnFactoryImpl>;
......
......@@ -51,11 +51,10 @@ public:
/// Returns the function's name
std::string name() const override { return "CompositeFunction"; }
/// Sets the workspace for each member function
void setWorkspace(boost::shared_ptr<const Workspace> ws) override;
void setWorkspace(std::shared_ptr<const Workspace> ws) override;
/// Set matrix workspace
void
setMatrixWorkspace(boost::shared_ptr<const API::MatrixWorkspace> workspace,
size_t wi, double startX, double endX) override;
void setMatrixWorkspace(std::shared_ptr<const API::MatrixWorkspace> workspace,
size_t wi, double startX, double endX) override;
/// Function you want to fit to.
void function(const FunctionDomain &domain,
......@@ -134,7 +133,7 @@ public:
/// Get number of domains required by this function
size_t getNumberDomains() const override;
/// Split this function (if needed) into a list of independent functions.
std::vector<boost::shared_ptr<IFunction>>
std::vector<std::shared_ptr<IFunction>>
createEquivalentFunctions() const override;
/// Returns the pointer to i-th function
IFunction_sptr getFunction(std::size_t i) const override;
......@@ -232,9 +231,9 @@ private:
};
/// shared pointer to the composite function base class
using CompositeFunction_sptr = boost::shared_ptr<CompositeFunction>;
using CompositeFunction_sptr = std::shared_ptr<CompositeFunction>;
/// shared pointer to the composite function base class (const version)
using CompositeFunction_const_sptr = boost::shared_ptr<const CompositeFunction>;
using CompositeFunction_const_sptr = std::shared_ptr<const CompositeFunction>;
/** A Jacobian for individual functions
*/
......
......@@ -13,7 +13,7 @@
#include "MantidKernel/Matrix.h"
#include "MantidKernel/System.h"
#include "MantidKernel/VMD.h"
#include <boost/shared_ptr.hpp>
#include <memory>
namespace Mantid {
namespace API {
......@@ -65,10 +65,10 @@ protected:
};
// Helper typedef for a shared pointer of this type.
using CoordTransform_sptr = boost::shared_ptr<CoordTransform>;
using CoordTransform_sptr = std::shared_ptr<CoordTransform>;
// Helper typdef for a const shared pointer of this type.
using CoordTransform_const_sptr = boost::shared_ptr<const CoordTransform>;
using CoordTransform_const_sptr = std::shared_ptr<const CoordTransform>;
} // namespace API
} // namespace Mantid
......@@ -35,7 +35,7 @@ public:
getProperty(const std::string &name) const override;
protected:
boost::shared_ptr<Algorithm> createChildAlgorithm(
std::shared_ptr<Algorithm> createChildAlgorithm(
const std::string &name, const double startProgress = -1.,
const double endProgress = -1., const bool enableLogging = true,
const int &version = -1) override;
......@@ -52,7 +52,7 @@ protected:
const bool loadQuiet = false);
std::vector<std::string> splitInput(const std::string &input);
void forwardProperties();
boost::shared_ptr<Kernel::PropertyManager> getProcessProperties(
std::shared_ptr<Kernel::PropertyManager> getProcessProperties(
const std::string &propertyManager = std::string()) const;
/// MPI option. If false, we will use one job event if MPI is available
bool m_useMPI;
......
......@@ -71,7 +71,7 @@ public:
return true;
}
// Does it cast to the desired type?
boost::shared_ptr<T> castWS = boost::dynamic_pointer_cast<T>(ws);
std::shared_ptr<T> castWS = std::dynamic_pointer_cast<T>(ws);
if (castWS)
return m_enabledSetting;
else
......
......@@ -107,9 +107,9 @@ public:
/// Easy access to the efixed value for this run & detector ID
double getEFixed(const detid_t detID) const;
/// Easy access to the efixed value for this run & optional detector
double
getEFixed(const boost::shared_ptr<const Geometry::IDetector> &detector =
boost::shared_ptr<const Geometry::IDetector>{nullptr}) const;
double getEFixed(const std::shared_ptr<const Geometry::IDetector> &detector =
std::shared_ptr<const Geometry::IDetector>{
nullptr}) const;
/// Set the efixed value for a given detector ID
void setEFixed(const detid_t detID, const double value);
......@@ -180,7 +180,7 @@ protected:
virtual void updateCachedDetectorGrouping(const size_t index) const;
/// Parameters modifying the base instrument
boost::shared_ptr<Geometry::ParameterMap> m_parmap;
std::shared_ptr<Geometry::ParameterMap> m_parmap;
/// The base (unparametrized) instrument
Geometry::Instrument_const_sptr sptr_instrument;
......@@ -227,10 +227,10 @@ private:
};
/// Shared pointer to ExperimentInfo
using ExperimentInfo_sptr = boost::shared_ptr<ExperimentInfo>;
using ExperimentInfo_sptr = std::shared_ptr<ExperimentInfo>;
/// Shared pointer to const ExperimentInfo
using ExperimentInfo_const_sptr = boost::shared_ptr<const ExperimentInfo>;
using ExperimentInfo_const_sptr = std::shared_ptr<const ExperimentInfo>;
} // namespace API
} // namespace Mantid
......@@ -9,7 +9,7 @@
#include "MantidAPI/DllConfig.h"
#ifndef Q_MOC_RUN
#include <boost/shared_ptr.hpp>
#include <memory>
#endif