diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/Algorithm.h b/Code/Mantid/Framework/API/inc/MantidAPI/Algorithm.h
index 1b8ad95bad80e55f2b6e0a615c68943fd5485a50..35b5ac9b27f8e1159027581766e4967962481447 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/Algorithm.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/Algorithm.h
@@ -249,6 +249,14 @@ public:
/// setting the child end progress
void setChildEndProgress(const double endProgress)const{m_endChildProgress=endProgress;}
+ /** @name Serialization functions */
+ //@{
+ /// Serialize an object to a string
+ virtual std::string toString() const;
+ /// De-serialize an object from a string
+ static IAlgorithm_sptr fromString(const std::string & input);
+ //@}
+
protected:
// Equivalents of Gaudi's initialize & execute methods
@@ -343,25 +351,18 @@ private:
bool m_isInitialized; ///< Algorithm has been initialized flag
bool m_isExecuted; ///< Algorithm is executed flag
-
bool m_isChildAlgorithm; ///< Algorithm is a child algorithm
-
bool m_runningAsync; ///< Algorithm is running asynchronously
bool m_running; ///< Algorithm is running
bool m_rethrow; ///< Algorithm should rethrow exceptions while executing
-
mutable double m_startChildProgress; ///< Keeps value for algorithm's progress at start of an sub-algorithm
mutable double m_endChildProgress; ///< Keeps value for algorithm's progress at sub-algorithm's finish
-
AlgorithmID m_algorithmID; ///< Algorithm ID for managed algorithms
-
- static unsigned int g_execCount; ///< Counter to keep track of algorithm execution order
-
std::string m_OptionalMessage; ///< An optional message string to be displayed in the GUI.
-
std::string m_WikiSummary; ///< A summary line for the wiki page.
-
std::vector<IAlgorithm_wptr> m_ChildAlgorithms; ///< A list of weak pointers to any child algorithms created
+
+ static size_t g_execCount; ///< Counter to keep track of algorithm execution order
};
///Typedef for a shared pointer to an Algorithm
diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/AlgorithmProxy.h b/Code/Mantid/Framework/API/inc/MantidAPI/AlgorithmProxy.h
index 4b90cf15c3a123d2c7ecc617c4afaf7e6c216e0f..c519958de7198c722fd0fe301d32e1a717390a73 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/AlgorithmProxy.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/AlgorithmProxy.h
@@ -108,10 +108,15 @@ namespace Mantid
///setting the child start progress
void setChildStartProgress(const double startProgress)const;
- /// setting the child end progress
+ /// setting the child end progress
void setChildEndProgress(const double endProgress)const;
-
+ /** @name String serialization */
+ //@{
+ /// Serialize an object to a string
+ virtual std::string toString() const;
+ //@}
+
private:
/// Private Copy constructor: NO COPY ALLOWED
AlgorithmProxy(const AlgorithmProxy&);
@@ -132,7 +137,7 @@ namespace Mantid
std::string m_OptionalMessage; ///<Message to display in GUI
const int m_version; ///< version of the real algorithm
- boost::shared_ptr<Algorithm> m_alg; ///< Shared pointer to a real algorithm. Created on demand
+ mutable boost::shared_ptr<Algorithm> m_alg; ///< Shared pointer to a real algorithm. Created on demand
bool m_isExecuted; ///< Executed flag
bool m_isLoggingEnabled;///< is the logging of the underlying algorithm enabled
bool m_rethrow; ///< Whether or not to rethrow exceptions.
diff --git a/Code/Mantid/Framework/API/inc/MantidAPI/IAlgorithm.h b/Code/Mantid/Framework/API/inc/MantidAPI/IAlgorithm.h
index 52304c83685ee878e4cd435079290c97ae0a3f38..eb4e65c0aeafe7da5c9c3aa65afad3340ffb89da 100644
--- a/Code/Mantid/Framework/API/inc/MantidAPI/IAlgorithm.h
+++ b/Code/Mantid/Framework/API/inc/MantidAPI/IAlgorithm.h
@@ -129,6 +129,13 @@ public:
virtual void setChildStartProgress(const double startProgress)const = 0;
/// setting the child end progress
virtual void setChildEndProgress(const double endProgress)const = 0;
+
+ /** @name String serialization */
+ //@{
+ /// Serialize an object to a string
+ virtual std::string toString() const = 0;
+ //@}
+
};
typedef boost::shared_ptr<IAlgorithm> IAlgorithm_sptr;
diff --git a/Code/Mantid/Framework/API/src/Algorithm.cpp b/Code/Mantid/Framework/API/src/Algorithm.cpp
index 86ba36ce5ec8f1d38bb5076efbd7a8cc8a7b6d8d..47d25e16615e5379bb77ab17c9678923c0f4230a 100644
--- a/Code/Mantid/Framework/API/src/Algorithm.cpp
+++ b/Code/Mantid/Framework/API/src/Algorithm.cpp
@@ -9,6 +9,11 @@
#include "MantidAPI/AlgorithmManager.h"
#include "MantidKernel/Timer.h"
#include "MantidKernel/DateAndTime.h"
+
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/regex.hpp>
+
#include <iomanip>
using namespace Mantid::Kernel;
@@ -18,8 +23,8 @@ namespace Mantid
{
namespace API
{
-
- unsigned int Algorithm::g_execCount=0;
+ /// Initialize static algorithm counter
+ size_t Algorithm::g_execCount=0;
/// Constructor
Algorithm::Algorithm() :
@@ -464,7 +469,81 @@ namespace Mantid
m_notificationCenter.removeObserver(observer);
}
- void Algorithm::cancel()const
+ /**
+ * Serialize this object to a string. The format is
+ * AlgorithmName.version(prop1=value1,prop2=value2,...)
+ * @returns This object serialized as a string
+ */
+ std::string Algorithm::toString() const
+ {
+ std::ostringstream writer;
+ writer << name() << "." << this->version()
+ << "("
+ << Kernel::PropertyManagerOwner::toString() // A comma separated list of prop=value
+ << ")";
+ return writer.str();
+ }
+
+ /**
+ * De-serialize an object from a string
+ * @param input :: An input string in the format. The format is
+ * AlgorithmName.version(prop1=value1,prop2=value2,...). If .version is not found the
+ * highest found is used.
+ * @returns A pointer to a managed algorithm object
+ */
+ IAlgorithm_sptr Algorithm::fromString(const std::string & input)
+ {
+ static const boost::regex nameExp("(^[[:alnum:]]*)");
+ // Double back slash gets rid of the compiler warning about unrecognized escape sequence
+ static const boost::regex versExp("\\.([[:digit:]]+)\\(*");
+ // Property regex. Simply match the brackets and split
+ static const boost::regex propExp("\\((.*)\\)");
+ // Name=Value regex
+ static const boost::regex nameValExp("(.*)=(.*)");
+
+ boost::match_results<std::string::const_iterator> what;
+ if( boost::regex_search(input, what, nameExp, boost::match_not_null) )
+ {
+ const std::string algName = what[1];
+ int version = -1; // Highest version
+ if( boost::regex_search(input, what, versExp, boost::match_not_null) )
+ {
+ try
+ {
+ version = boost::lexical_cast<int, std::string>(what.str(1));
+ }
+ catch(boost::bad_lexical_cast&)
+ {
+ }
+ }
+ IAlgorithm_sptr alg = AlgorithmManager::Instance().create(algName, version);
+ if( boost::regex_search(input, what, propExp, boost::match_not_null) )
+ {
+ std::string propStr = what[1];
+ std::list<std::string> props;
+ boost::algorithm::split(props, propStr, std::bind2nd(std::equal_to<char>(), ','));
+ for( std::list<std::string>::const_iterator itr = props.begin();
+ itr != props.end(); ++itr )
+ {
+ std::string nameValue = *itr;
+ if( boost::regex_search(nameValue, what, nameValExp, boost::match_not_null) )
+ {
+ alg->setPropertyValue(what.str(1), what.str(2));
+ }
+ }
+ }
+ return alg;
+ }
+ else
+ {
+ throw std::runtime_error("Cannot create algorithm, invalid string format.");
+ }
+ }
+
+ /**
+ * Cancel an algorithm
+ */
+ void Algorithm::cancel() const
{
//set myself to be cancelled
m_cancel = true;
diff --git a/Code/Mantid/Framework/API/src/AlgorithmProxy.cpp b/Code/Mantid/Framework/API/src/AlgorithmProxy.cpp
index 1a2526a0c49d181c83ec29fcd1abc0018a9e590b..bec698cf3f8fa34f2ea149a0b511729a68a4494a 100644
--- a/Code/Mantid/Framework/API/src/AlgorithmProxy.cpp
+++ b/Code/Mantid/Framework/API/src/AlgorithmProxy.cpp
@@ -9,219 +9,233 @@ using namespace Mantid::Kernel;
namespace Mantid
{
-namespace API
-{
-
-// Get a reference to the logger
-Kernel::Logger& AlgorithmProxy::g_log = Kernel::Logger::get("AlgorithmProxy");
-
-//----------------------------------------------------------------------
-// Public methods
-//----------------------------------------------------------------------
-
-/// Constructor
-AlgorithmProxy::AlgorithmProxy(Algorithm_sptr alg) :
- PropertyManagerOwner(),_executeAsync(this,&AlgorithmProxy::executeAsyncImpl),
- m_name(alg->name()),m_category(alg->category()),
- m_version(alg->version()), m_alg(alg),
- m_isExecuted(),m_isLoggingEnabled(true), m_rethrow(false)
-{
- if (!alg)
+ namespace API
{
- g_log.error("Unable to create a proxy algorithm.");
- throw std::logic_error("Unable to create a proxy algorithm.");
- }
- alg->initialize();
- m_OptionalMessage = alg->getOptionalMessage();
- copyPropertiesFrom(*alg);
-}
-
-/// Virtual destructor
-AlgorithmProxy::~AlgorithmProxy()
-{
-}
-/** Initialization method invoked by the framework.
- * Does nothing for AlgorithmProxy as initialization is done in the constructor.
- */
-void AlgorithmProxy::initialize()
-{
- return;
-}
-
-/** The actions to be performed by the AlgorithmProxy on a dataset. This method is
- * invoked for top level AlgorithmProxys by the application manager.
- * This method invokes exec() method.
- * For sub-AlgorithmProxys either the execute() method or exec() method
- * must be EXPLICITLY invoked by the parent AlgorithmProxy.
- *
- * @throw runtime_error Thrown if AlgorithmProxy or sub-AlgorithmProxy cannot be executed
- */
-bool AlgorithmProxy::execute()
-{
- createConcreteAlg();
- try
- {
- m_alg->execute();
- }
- catch(...)
- {
- m_alg.reset();
- throw;
- }
- stopped();
-
- return m_isExecuted;
-}
-
-/// Asynchronous execution of the algorithm.
-Poco::ActiveResult<bool> AlgorithmProxy::executeAsync()
-{
- return _executeAsync(Poco::Void());
-}
-
-/// True if the algorithm is running asynchronously.
-bool AlgorithmProxy::isRunningAsync()
-{
- return m_alg ? m_alg->isRunningAsync() : false;
-}
-
-/// True if the algorithm is running.
-bool AlgorithmProxy::isRunning()
-{
- return m_alg ? m_alg->isRunning() : false;
-}
-
-/// Has the AlgorithmProxy already been initialized
-bool AlgorithmProxy::isInitialized() const
-{
- return true;//!!!!!!!!!
-}
-
-/// Has the AlgorithmProxy already been executed
-bool AlgorithmProxy::isExecuted() const
-{
- return m_isExecuted;
-}
-
-///Cancel the execution of the algorithm
-void AlgorithmProxy::cancel()const
-{
- if (m_alg)
- m_alg->cancel();
-}
-
-/** Add an observer for a notification. If the real algorithm is running
- * the observer is added directly. If the algorithm is not running yet
- * the observer's address is added to a buffer to be used later when execute/executeAsync
- * method is called.
- * @param observer :: Observer
- */
-void AlgorithmProxy::addObserver(const Poco::AbstractObserver& observer)const
-{
- const Poco::AbstractObserver* obs = &observer;
- if (m_alg)
- {
- m_alg->addObserver(*obs);
- }
- // save the observer in any case because m_alg can be reset (eg in createConcreteAlg())
- m_externalObservers.push_back(obs);
-}
-
-/** Remove an observer.
- * @param observer :: Observer
- */
-void AlgorithmProxy::removeObserver(const Poco::AbstractObserver& observer)const
-{
- std::vector<const Poco::AbstractObserver*>::iterator o =
- std::find(m_externalObservers.begin(),m_externalObservers.end(),&observer);
- if (o != m_externalObservers.end()) m_externalObservers.erase(o);
- if (m_alg) m_alg->removeObserver(observer);
-}
-
-void AlgorithmProxy::setRethrows(const bool rethrow)
-{
- this->m_rethrow = rethrow;
- if(m_alg) m_alg->setRethrows(rethrow);
-}
-
-/**
- * Override setPropertyValue
- * @param name The name of the property
- * @param value The value of the property as a string
- */
-void AlgorithmProxy::setPropertyValue(const std::string &name, const std::string &value)
-{
- createConcreteAlg(true);
- m_alg->setPropertyValue(name, value);
- copyPropertiesFrom(*m_alg);
- m_alg.reset();
-}
-
-
-//----------------------------------------------------------------------
-// Private methods
-//----------------------------------------------------------------------
-
-/**
- * Creates an unmanaged instance of the actual algorithm and sets its properties
- * @param initOnly If true then the algorithm will only having its init step run, otherwise observers will
- * also be added and rethrows will be true
- */
-void AlgorithmProxy::createConcreteAlg(bool initOnly)
-{
- m_alg = boost::dynamic_pointer_cast<Algorithm>(AlgorithmManager::Instance().createUnmanaged(name(),version()));
- m_alg->initializeFromProxy(*this);
- if( !initOnly )
- {
- m_alg->setRethrows(this->m_rethrow);
- addObservers();
- }
-}
-
-/**
- * Clean up when the real algorithm stops
- */
-void AlgorithmProxy::stopped()
-{
- m_isExecuted = m_alg->isExecuted();
- m_alg.reset();
-}
-
-/**
- * Add observers stored previously in m_externalObservers
- */
-void AlgorithmProxy::addObservers()
-{
- if (!m_alg) return;
- std::vector<const Poco::AbstractObserver*>::reverse_iterator o = m_externalObservers.rbegin();
- for(;o != m_externalObservers.rend();o++)
- m_alg->addObserver(**o);
- m_externalObservers.clear();
-}
-
-/** executeAsync() implementation. Calls execute and when it has finished deletes the real algorithm.
- * @param dummy :: A dummy variable
- */
-bool AlgorithmProxy::executeAsyncImpl(const Poco::Void & dummy)
-{
- createConcreteAlg();
- // Call Algorithm::executeAsyncImpl rather than executeAsync() because the latter
- // would spawn off another (3rd) thread which is unecessary.
- m_alg->executeAsyncImpl(dummy); // Pass through dummy argument, though not used
- stopped();
-
- return m_isExecuted;
-}
- ///setting the child start progress
- void AlgorithmProxy::setChildStartProgress(const double startProgress)const
- {
- m_alg->setChildStartProgress(startProgress);
- }
- /// setting the child end progress
- void AlgorithmProxy::setChildEndProgress(const double endProgress)const
- {
- m_alg->setChildEndProgress(endProgress);
- }
-} // namespace API
+ // Get a reference to the logger
+ Kernel::Logger& AlgorithmProxy::g_log = Kernel::Logger::get("AlgorithmProxy");
+
+ //----------------------------------------------------------------------
+ // Public methods
+ //----------------------------------------------------------------------
+
+ /// Constructor
+ AlgorithmProxy::AlgorithmProxy(Algorithm_sptr alg) :
+ PropertyManagerOwner(),_executeAsync(this,&AlgorithmProxy::executeAsyncImpl),
+ m_name(alg->name()),m_category(alg->category()),
+ m_version(alg->version()), m_alg(alg),
+ m_isExecuted(),m_isLoggingEnabled(true), m_rethrow(false)
+ {
+ if (!alg)
+ {
+ g_log.error("Unable to create a proxy algorithm.");
+ throw std::logic_error("Unable to create a proxy algorithm.");
+ }
+ alg->initialize();
+ m_OptionalMessage = alg->getOptionalMessage();
+ copyPropertiesFrom(*alg);
+ }
+
+ /// Virtual destructor
+ AlgorithmProxy::~AlgorithmProxy()
+ {
+ }
+
+ /** Initialization method invoked by the framework.
+ * Does nothing for AlgorithmProxy as initialization is done in the constructor.
+ */
+ void AlgorithmProxy::initialize()
+ {
+ return;
+ }
+
+ /** The actions to be performed by the AlgorithmProxy on a dataset. This method is
+ * invoked for top level AlgorithmProxys by the application manager.
+ * This method invokes exec() method.
+ * For sub-AlgorithmProxys either the execute() method or exec() method
+ * must be EXPLICITLY invoked by the parent AlgorithmProxy.
+ *
+ * @throw runtime_error Thrown if AlgorithmProxy or sub-AlgorithmProxy cannot be executed
+ */
+ bool AlgorithmProxy::execute()
+ {
+ createConcreteAlg();
+ try
+ {
+ m_alg->execute();
+ }
+ catch(...)
+ {
+ m_alg.reset();
+ throw;
+ }
+ stopped();
+
+ return m_isExecuted;
+ }
+
+ /// Asynchronous execution of the algorithm.
+ Poco::ActiveResult<bool> AlgorithmProxy::executeAsync()
+ {
+ return _executeAsync(Poco::Void());
+ }
+
+ /// True if the algorithm is running asynchronously.
+ bool AlgorithmProxy::isRunningAsync()
+ {
+ return m_alg ? m_alg->isRunningAsync() : false;
+ }
+
+ /// True if the algorithm is running.
+ bool AlgorithmProxy::isRunning()
+ {
+ return m_alg ? m_alg->isRunning() : false;
+ }
+
+ /// Has the AlgorithmProxy already been initialized
+ bool AlgorithmProxy::isInitialized() const
+ {
+ return true;//!!!!!!!!!
+ }
+
+ /// Has the AlgorithmProxy already been executed
+ bool AlgorithmProxy::isExecuted() const
+ {
+ return m_isExecuted;
+ }
+
+ ///Cancel the execution of the algorithm
+ void AlgorithmProxy::cancel()const
+ {
+ if (m_alg)
+ m_alg->cancel();
+ }
+
+ /** Add an observer for a notification. If the real algorithm is running
+ * the observer is added directly. If the algorithm is not running yet
+ * the observer's address is added to a buffer to be used later when execute/executeAsync
+ * method is called.
+ * @param observer :: Observer
+ */
+ void AlgorithmProxy::addObserver(const Poco::AbstractObserver& observer)const
+ {
+ const Poco::AbstractObserver* obs = &observer;
+ if (m_alg)
+ {
+ m_alg->addObserver(*obs);
+ }
+ // save the observer in any case because m_alg can be reset (eg in createConcreteAlg())
+ m_externalObservers.push_back(obs);
+ }
+
+ /** Remove an observer.
+ * @param observer :: Observer
+ */
+ void AlgorithmProxy::removeObserver(const Poco::AbstractObserver& observer)const
+ {
+ std::vector<const Poco::AbstractObserver*>::iterator o =
+ std::find(m_externalObservers.begin(),m_externalObservers.end(),&observer);
+ if (o != m_externalObservers.end()) m_externalObservers.erase(o);
+ if (m_alg) m_alg->removeObserver(observer);
+ }
+
+ void AlgorithmProxy::setRethrows(const bool rethrow)
+ {
+ this->m_rethrow = rethrow;
+ if(m_alg) m_alg->setRethrows(rethrow);
+ }
+
+ /**
+ * Override setPropertyValue
+ * @param name The name of the property
+ * @param value The value of the property as a string
+ */
+ void AlgorithmProxy::setPropertyValue(const std::string &name, const std::string &value)
+ {
+ createConcreteAlg(true);
+ m_alg->setPropertyValue(name, value);
+ copyPropertiesFrom(*m_alg);
+ m_alg.reset();
+ }
+
+
+ //----------------------------------------------------------------------
+ // Private methods
+ //----------------------------------------------------------------------
+
+ /**
+ * Creates an unmanaged instance of the actual algorithm and sets its properties
+ * @param initOnly If true then the algorithm will only having its init step run, otherwise observers will
+ * also be added and rethrows will be true
+ */
+ void AlgorithmProxy::createConcreteAlg(bool initOnly)
+ {
+ m_alg = boost::dynamic_pointer_cast<Algorithm>(AlgorithmManager::Instance().createUnmanaged(name(),version()));
+ m_alg->initializeFromProxy(*this);
+ if( !initOnly )
+ {
+ m_alg->setRethrows(this->m_rethrow);
+ addObservers();
+ }
+ }
+
+ /**
+ * Clean up when the real algorithm stops
+ */
+ void AlgorithmProxy::stopped()
+ {
+ m_isExecuted = m_alg->isExecuted();
+ m_alg.reset();
+ }
+
+ /**
+ * Add observers stored previously in m_externalObservers
+ */
+ void AlgorithmProxy::addObservers()
+ {
+ if (!m_alg) return;
+ std::vector<const Poco::AbstractObserver*>::reverse_iterator o = m_externalObservers.rbegin();
+ for(;o != m_externalObservers.rend();o++)
+ m_alg->addObserver(**o);
+ m_externalObservers.clear();
+ }
+
+ /** executeAsync() implementation. Calls execute and when it has finished deletes the real algorithm.
+ * @param dummy :: A dummy variable
+ */
+ bool AlgorithmProxy::executeAsyncImpl(const Poco::Void & dummy)
+ {
+ createConcreteAlg();
+ // Call Algorithm::executeAsyncImpl rather than executeAsync() because the latter
+ // would spawn off another (3rd) thread which is unecessary.
+ m_alg->executeAsyncImpl(dummy); // Pass through dummy argument, though not used
+ stopped();
+
+ return m_isExecuted;
+ }
+ ///setting the child start progress
+ void AlgorithmProxy::setChildStartProgress(const double startProgress)const
+ {
+ m_alg->setChildStartProgress(startProgress);
+ }
+ /// setting the child end progress
+ void AlgorithmProxy::setChildEndProgress(const double endProgress)const
+ {
+ m_alg->setChildEndProgress(endProgress);
+ }
+
+ /**
+ * Serialize this object to a string. Simple routes the call the algorithm
+ * @returns This object serialized as a string
+ */
+ std::string AlgorithmProxy::toString() const
+ {
+ const_cast<AlgorithmProxy*>(this)->createConcreteAlg();
+ std::string serialized = m_alg->toString();
+ m_alg.reset();
+ return serialized;
+ }
+
+
+ } // namespace API
} // namespace Mantid
diff --git a/Code/Mantid/Framework/API/test/AlgorithmTest.h b/Code/Mantid/Framework/API/test/AlgorithmTest.h
index c117e4858ba5ea3e1659c7eafefae8efd893e84f..eab87b960da76c329958eb6c20577f9bbb4dc4c5 100644
--- a/Code/Mantid/Framework/API/test/AlgorithmTest.h
+++ b/Code/Mantid/Framework/API/test/AlgorithmTest.h
@@ -20,7 +20,8 @@ public:
const std::string category() const { return "Cat";} ///< Algorithm's category for identification
void init()
- { declareProperty("prop1","value");
+ {
+ declareProperty("prop1","value");
declareProperty("prop2",1);
}
void exec() {}
@@ -35,11 +36,44 @@ public:
}
};
-DECLARE_ALGORITHM(ToyAlgorithm)
+class ToyAlgorithmTwo : public Algorithm
+{
+public:
+ ToyAlgorithmTwo() : Algorithm() {}
+ virtual ~ToyAlgorithmTwo() {}
+
+ const std::string name() const { return "ToyAlgorithm";} ///< Algorithm's name for identification
+ int version() const { return 2;} ///< Algorithm's version for identification
+ const std::string category() const { return "Cat";}
+ void init()
+ {
+ declareProperty("prop1","value");
+ declareProperty("prop2",1);
+ declareProperty("prop3",10.5);
+ }
+ void exec() {}
+};
class AlgorithmTest : public CxxTest::TestSuite
{
-public:
+public:
+
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static AlgorithmTest *createSuite() { return new AlgorithmTest(); }
+ static void destroySuite( AlgorithmTest *suite ) { delete suite; }
+
+ AlgorithmTest()
+ {
+ Mantid::API::AlgorithmFactory::Instance().subscribe<ToyAlgorithm>();
+ Mantid::API::AlgorithmFactory::Instance().subscribe<ToyAlgorithmTwo>();
+ }
+
+ ~AlgorithmTest()
+ {
+ Mantid::API::AlgorithmFactory::Instance().unsubscribe("ToyAlgorithm|1");
+ Mantid::API::AlgorithmFactory::Instance().unsubscribe("ToyAlgorithm|2");
+ }
void testAlgorithm()
{
@@ -120,10 +154,100 @@ public:
TS_ASSERT( ! vec.empty() )
TS_ASSERT( vec.size() == 2 )
TS_ASSERT( ! vec[0]->name().compare("prop1") )
- }
+ }
+
+ void testStringization()
+ {
+ //Set the properties so that we know what they are
+ alg.setPropertyValue("prop1", "value1");
+ alg.setProperty("prop2", 5);
+ const std::string expected = "ToyAlgorithm.1(prop1=value1,prop2=5)";
+
+ TS_ASSERT_EQUALS(alg.toString(), expected);
+ }
+
+ void test_From_String_With_Invalid_Input_Throws()
+ {
+ const std::string input = "()";
+ TS_ASSERT_THROWS(Algorithm::fromString(input), std::runtime_error );
+ }
+
+ void test_Construction_Via_Valid_String_With_No_Properties()
+ {
+ IAlgorithm_sptr testAlg = runFromString("ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 2);
+ }
+
+ void test_Construction_Via_Valid_String_With_Version()
+ {
+ IAlgorithm_sptr testAlg = runFromString("ToyAlgorithm.1");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 1);
+
+ // No brackets
+ testAlg = runFromString("ToyAlgorithm.1");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 1);
+ }
+
+ void test_Construction_Via_Valid_String_With_Version_And_Empty_Props()
+ {
+ IAlgorithm_sptr testAlg = runFromString("ToyAlgorithm.1()");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 1);
+
+ // No brackets
+ testAlg = runFromString("ToyAlgorithm.1");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 1);
+ }
+
+
+ void test_Construction_Via_Valid_String_With_Set_Properties_And_Version()
+ {
+ IAlgorithm_sptr testAlg = runFromString("ToyAlgorithm.2(prop1=val1,prop2=8,prop3=10.0)");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 2);
+
+ std::string prop1;
+ TS_ASSERT_THROWS_NOTHING( prop1 = testAlg->getProperty("prop1") );
+ TS_ASSERT_EQUALS(prop1,"val1");
+ int prop2;
+ TS_ASSERT_THROWS_NOTHING( prop2 = testAlg->getProperty("prop2") );
+ TS_ASSERT_EQUALS(prop2, 8);
+ double prop3;
+ TS_ASSERT_THROWS_NOTHING( prop3 = testAlg->getProperty("prop3") );
+ TS_ASSERT_EQUALS(prop3, 10.0);
+ }
+
+ void test_Construction_Via_Valid_String_With_Empty_Properties()
+ {
+ IAlgorithm_sptr testAlg = runFromString("ToyAlgorithm()");
+ TS_ASSERT_EQUALS(testAlg->name(), "ToyAlgorithm");
+ TS_ASSERT_EQUALS(testAlg->version(), 2);
+
+ std::string prop1;
+ TS_ASSERT_THROWS_NOTHING( prop1 = testAlg->getProperty("prop1") );
+ TS_ASSERT_EQUALS(prop1,"value");
+ int prop2;
+ TS_ASSERT_THROWS_NOTHING( prop2 = testAlg->getProperty("prop2") );
+ TS_ASSERT_EQUALS(prop2, 1);
+ }
+
private:
- ToyAlgorithm alg;
+ IAlgorithm_sptr runFromString(const std::string & input)
+ {
+ IAlgorithm_sptr testAlg;
+ TS_ASSERT_THROWS_NOTHING(testAlg = Algorithm::fromString(input) );
+ TS_ASSERT(testAlg);
+ if(!testAlg) TS_FAIL("Failed to create algorithm, cannot continue test.");
+ return testAlg;
+ }
+
+ ToyAlgorithm alg;
+ ToyAlgorithmTwo algv2;
};
diff --git a/Code/Mantid/Framework/Kernel/inc/MantidKernel/IPropertyManager.h b/Code/Mantid/Framework/Kernel/inc/MantidKernel/IPropertyManager.h
index ffce45af39ca6f0551e7ace03c14e09acad14c16..210586bc3aa82a17ea9376a9bba292a31efefc50 100644
--- a/Code/Mantid/Framework/Kernel/inc/MantidKernel/IPropertyManager.h
+++ b/Code/Mantid/Framework/Kernel/inc/MantidKernel/IPropertyManager.h
@@ -111,6 +111,8 @@ public:
this->setPropertyValue(name, std::string(value));
return this;
}
+ /// Return the property manager serialized as a string.
+ virtual std::string toString(bool includeDefaults = false) const = 0;
protected:
diff --git a/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManager.h b/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManager.h
index 1d81312cb8241401a29c272588b482fcf7e6d40f..b8f193b740292466aaf735e89c1f171049e1207e 100644
--- a/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManager.h
+++ b/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManager.h
@@ -86,6 +86,8 @@ public:
/// Get the value of a property
TypedValue getProperty(const std::string &name) const;
+ /// Return the property manager serialized as a string.
+ virtual std::string toString(bool includeDefaults = false) const;
protected:
using IPropertyManager::declareProperty;
diff --git a/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManagerOwner.h b/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManagerOwner.h
index a0c0925ec1bb5e66aa9cac6d891946f477043650..890288d8c7174bad551bf4c24a49aa418ea2c960 100644
--- a/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManagerOwner.h
+++ b/Code/Mantid/Framework/Kernel/inc/MantidKernel/PropertyManagerOwner.h
@@ -80,6 +80,8 @@ public:
/// Get the value of a property
TypedValue getProperty(const std::string &name) const;
+ /// Return the property manager serialized as a string.
+ virtual std::string toString(bool includeDefaults = false) const;
/// Removes the property from management
void removeProperty(const std::string &name);
diff --git a/Code/Mantid/Framework/Kernel/src/PropertyManager.cpp b/Code/Mantid/Framework/Kernel/src/PropertyManager.cpp
index 64a8115f25998193278aafd3cc1a45a9341dfb47..516aaf6c75b696a835d61979b3a8f574a050ef1e 100644
--- a/Code/Mantid/Framework/Kernel/src/PropertyManager.cpp
+++ b/Code/Mantid/Framework/Kernel/src/PropertyManager.cpp
@@ -343,6 +343,28 @@ namespace Mantid
return p->value();
}
+ //-----------------------------------------------------------------------------------------------
+ /**
+ * Return the property manager serialized as a string.
+ * The format is propName=value,propName=value,propName=value
+ * @param includeDefaults :: If true then the value of default parameters will be included
+ * @returns A stringized version of the manager
+ */
+ std::string PropertyManager::toString(bool includeDefaults) const
+ {
+ std::ostringstream writer;
+ const size_t count = propertyCount();
+ for( size_t i = 0; i < count; ++i )
+ {
+ Property *p = getPointerToPropertyOrdinal((int)i);
+ if( includeDefaults || !(p->isDefault()) )
+ {
+ writer << p->name() << "=" << p->value();
+ if( i < count - 1 ) writer << ",";
+ }
+ }
+ return writer.str();
+ }
//-----------------------------------------------------------------------------------------------
/** Get a property by name
diff --git a/Code/Mantid/Framework/Kernel/src/PropertyManagerOwner.cpp b/Code/Mantid/Framework/Kernel/src/PropertyManagerOwner.cpp
index 38f1c921f9366d52f4741ecefaec3b4909b891c2..d9037e210ec477462db440179cd08ad77606837e 100644
--- a/Code/Mantid/Framework/Kernel/src/PropertyManagerOwner.cpp
+++ b/Code/Mantid/Framework/Kernel/src/PropertyManagerOwner.cpp
@@ -162,6 +162,17 @@ namespace Mantid
return m_properties->getProperty( name );
}
+ /**
+ * Return the property manager serialized as a string.
+ * The format is propName=value,propName=value,propName=value
+ * @param includeDefaults :: If true then the value of default parameters will be included
+ * @returns A stringized version of the manager
+ */
+ std::string PropertyManagerOwner::toString(bool includeDefaults) const
+ {
+ return m_properties->toString(includeDefaults);
+ }
+
/**
* Removes the property from properties map.
* @param name :: Name of the property to be removed.