Added a property collection. Re #54.

Code/Mantid/Kernel/doc/PropertyManager.txt

+RJT, 20/11/07
+=============
+
+Regarding the IProperty interface methods....
+
+	setProperty (const Property &p)    - don't really understand the function of this method.
+										 It uses the Gaudi Property assign() method.
+	setProperty (const std::string &s) - this uses the output of Gaudi's Property::fillStream method where the property is 
+										 represented as 'name':value. I haven't included that method at present, so
+										 have left out this one as well.
+										 
+    setProperty (const std::string &n, const std::string &v) - Kept, but return type changed to void
+    getProperty (Property *p) const  ->  renamed checkProperty
+	getProperty (const std::string &name) const  - Kept
+	getProperty (const std::string &n, std::string &v)  ->  renamed getPropertyValue and string value is the return type
+	std::vector< Property * >& getProperties () const  - Kept
+
+	
+There's no concept of 'mandatoryness' in there yet.
+
+The Gaudi class has 'remote properties' - I don't.
+
+Our property manager class owns all its properties.
\ No newline at end of file

Code/Mantid/Kernel/inc/PropertyManager.h

+#ifndef MANTID_KERNEL_PROPERTYMANAGER_H_
+#define MANTID_KERNEL_PROPERTYMANAGER_H_
+
+//----------------------------------------------------------------------
+// Includes
+//----------------------------------------------------------------------
+#include "IProperty.h"
+#include <vector>
+
+namespace Mantid
+{
+namespace Kernel
+{
+//----------------------------------------------------------------------
+// Forward declaration
+//----------------------------------------------------------------------
+class Property;
+
+/** @class PropertyManager PropertyManager.h Kernel/PropertyManager.h
+
+    Property manager helper class.
+    This class is used by algorithms and services for helping to manage their own set of properties.
+    It implements the IProperty interface.
+
+    @author Russell Taylor, Tessella Support Services plc
+    @author Based on the Gaudi class PropertyMgr (see http://proj-gaudi.web.cern.ch/proj-gaudi/)
+    @date 20/11/2007
+    
+    Copyright &copy; 2007 STFC Rutherford Appleton Laboratories
+
+    This file is part of Mantid.
+
+    Mantid is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    Mantid is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+    
+    File change history is stored at: <https://svn.mantidproject.org/mantid/trunk/Code/Mantid>.
+    Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+class DLLExport PropertyManager //: public IProperty
+{
+public:
+	PropertyManager();
+	virtual ~PropertyManager();
+	
+	// Overloaded functions to declare properties (i.e. store them)
+	void declareProperty( Property *p );
+	void declareProperty( const std::string &name, int value, const std::string &doc="" );
+  void declareProperty( const std::string &name, double value, const std::string &doc="" );
+  void declareProperty( const std::string &name, std::string value, const std::string &doc="" );
+  
+  // IProperty methods
+  void setProperty( const std::string &name, const std::string &value );
+  bool checkProperty( Property *p ) const;
+  std::string getPropertyValue( const std::string &name ) const;
+  Property* getProperty( std::string name ) const;
+  const std::vector< Property* >& getProperties() const;
+	
+private:
+  bool checkProperty( const std::string& name) const;
+  
+  /// The properties under management
+  std::vector<Property*> m_properties;
+};
+
+} // namespace Kernel
+} // namespace Mantid
+
+#endif /*MANTID_KERNEL_PROPERTYMANAGER_H_*/

Code/Mantid/Kernel/inc/PropertyWithValue.h

@@ -128,7 +128,7 @@ public:
 	  return m_value;
 	}
 	
-	/** Allows you to get the value of the property simply by typing its name. (e.g. myProperty)
+	/** Allows you to get the value of the property simply by typing its name.
 	 *  Means you can use an expression like: int i = myProperty;
 	 */
 	operator const TYPE& () const

Code/Mantid/Kernel/src/PropertyManager.cpp

+#include "PropertyManager.h"
+#include "PropertyWithValue.h"
+#include "Exception.h"
+
+namespace Mantid
+{
+namespace Kernel
+{
+
+/// Default constructor
+PropertyManager::PropertyManager() :
+  m_properties()
+{
+}
+
+/// Virtual destructor
+PropertyManager::~PropertyManager()
+{
+  for ( std::vector<Property*>::const_iterator it = m_properties.begin() ; it != m_properties.end() ; ++it )
+  {
+    delete (*it);
+  }
+}
+
+/** Add a property to the list of managed properties
+ *  @param p The property object to add
+ */
+void PropertyManager::declareProperty( Property *p )
+{
+  if ( ! checkProperty( p ) )
+  {
+    m_properties.push_back(p);
+  }
+  else
+  {
+    throw Exception::ExistsError("Property with given name already exists", p->name() );
+  }
+}
+
+/** Add an integer property to the list of managed properties
+ *  @param name The name to assign to the property
+ *  @param value The initial value to assign to the property
+ *  @param doc The (optional) documentation string
+ */
+void PropertyManager::declareProperty( const std::string &name, int value, const std::string &doc )
+{
+  if ( ! checkProperty( name ) )
+  {
+    Property *p = new PropertyWithValue<int>(name, value);
+    p->setDocumentation(doc);
+    m_properties.push_back(p);
+  }
+  else
+  {
+    throw Exception::ExistsError("Property with given name already exists", name );
+  }
+}
+
+/** Add a double property to the list of managed properties
+ *  @param name The name to assign to the property
+ *  @param value The initial value to assign to the property
+ *  @param doc The (optional) documentation string
+ */
+void PropertyManager::declareProperty( const std::string &name, double value, const std::string &doc )
+{
+  if ( ! checkProperty( name ) )
+  {
+    Property *p = new PropertyWithValue<double>(name, value);
+    p->setDocumentation(doc);
+    m_properties.push_back(p);
+  }
+  else
+  {
+    throw Exception::ExistsError("Property with given name already exists", name );
+  }
+}
+
+/** Add a string property to the list of managed properties
+ *  @param name The name to assign to the property
+ *  @param value The initial value to assign to the property
+ *  @param doc The (optional) documentation string
+ */
+void PropertyManager::declareProperty( const std::string &name, std::string value, const std::string &doc )
+{
+  if ( ! checkProperty( name ) )
+  {
+    Property *p = new PropertyWithValue<std::string>(name, value);
+    p->setDocumentation(doc);
+    m_properties.push_back(p);
+  }
+  else
+  {
+    throw Exception::ExistsError("Property with given name already exists", name );
+} 
+}
+
+/** Set the value of a property by string
+ *  @param name The name of the property (case insensitive)
+ *  @param value The value to assign to the property
+ *  @throw NotFoundError if the named property is unknown
+ */
+void PropertyManager::setProperty( const std::string &name, const std::string &value )
+{
+  Property *p = getProperty(name);   // throws NotFoundError if property not in vector
+  bool success = p->setValue(value);
+  if ( !success ) throw std::invalid_argument("Invalid value for this property");
+}
+
+/** Check whether a given property is already in the list of managed properties.
+ *  Note that the check is performed purely on the name (not on, for example, the type)
+ *  and is case insensitive.
+ *  @param p The property to check
+ *  @return True if the property is already stored
+ */
+bool PropertyManager::checkProperty( Property *p ) const
+{
+  return checkProperty( p->name() );
+}
+
+/** Checks whether the named property is already in the list of managed property.
+ *  @param p The name of the property (case insensitive)
+ *  @return True is the property is already stored
+ */
+bool PropertyManager::checkProperty( const std::string& name ) const
+{
+  try {
+    getProperty(name);
+    return true;
+  } catch (Exception::NotFoundError e) {
+    return false;
+  }
+}
+
+/** Get the value of a property as a string
+ *  @param name The name of the property (case insensitive)
+ *  @return The value of the named property
+ *  @throw NotFoundError if the named property is unknown
+ */
+std::string PropertyManager::getPropertyValue( const std::string &name ) const
+{
+  Property *p = getProperty(name);   // throws NotFoundError if property not in vector
+  return p->value();
+}
+
+/** Get a property by name
+ *  @param name The name of the property (case insensitive)
+ *  @return A pointer to the named property
+ *  @throw NotFoundError if the named property is unknown
+ */
+Property* PropertyManager::getProperty( std::string name ) const
+{
+  /// TODO Re-work to be more efficient
+  for ( std::vector<Property*>::const_iterator it = m_properties.begin() ; it != m_properties.end() ; ++it )
+  {
+    std::string n = (*it)->name();
+    std::transform(n.begin(), n.end(), n.begin(), toupper);
+    std::transform(name.begin(), name.end(), name.begin(), toupper);
+    if ( ! name.compare(n) )
+    {
+      return *it;
+    }
+  }
+  throw Exception::NotFoundError("Unable to retrieve property", name);
+}
+
+/** Get the list of managed properties
+ *  @return A vector holding pointers to the list of properties
+ */
+const std::vector< Property* >& PropertyManager::getProperties() const
+{
+  return m_properties;
+}
+
+} // namespace Kernel
+} // namespace Mantid

Code/Mantid/Kernel/test/PropertyManagerTest.h

+#ifndef PROPERTYMANAGERTEST_H_
+#define PROPERTYMANAGERTEST_H_
+
+#include <cxxtest/TestSuite.h>
+
+#include "../inc/PropertyManager.h"
+#include "../inc/PropertyWithValue.h"
+#include <iostream>
+
+using namespace Mantid::Kernel;
+
+class PropertyManagerTest : public CxxTest::TestSuite
+{
+public:
+  PropertyManagerTest()
+  {
+    Property *p = new PropertyWithValue<int>("aProp",1);
+    manager.declareProperty(p);
+  }
+  
+	void testConstructor()
+	{
+	  PropertyManager mgr;
+	  std::vector<Property*> props = mgr.getProperties();
+	  TS_ASSERT( props.empty() )
+	}
+
+	void testdeclareProperty_pointer()
+	{
+		PropertyManager mgr;
+		Property *p = new PropertyWithValue<double>("myProp", 9.99);
+		TS_ASSERT_THROWS_NOTHING( mgr.declareProperty(p) )
+		TS_ASSERT( mgr.checkProperty(p) )
+		TS_ASSERT( ! mgr.getPropertyValue("myProp").compare("9.99") )
+		
+		TS_ASSERT_THROWS( mgr.declareProperty(p), Exception::ExistsError )
+	}
+
+	void testdeclareProperty_int()
+	{
+		PropertyManager mgr;
+		TS_ASSERT_THROWS_NOTHING( mgr.declareProperty("myProp", 1, "hello") )
+		TS_ASSERT( ! mgr.getPropertyValue("myProp").compare("1") )
+		Property *p = mgr.getProperty("myProp");
+		TS_ASSERT( ! p->documentation().compare("hello") )
+		
+		TS_ASSERT_THROWS( mgr.declareProperty("MYPROP", 5), Exception::ExistsError )
+	}
+
+	void testdeclareProperty_double()
+	{
+    PropertyManager mgr;
+    TS_ASSERT_THROWS_NOTHING( mgr.declareProperty("myProp", 9.99, "hello") )
+    TS_ASSERT( ! mgr.getPropertyValue("myProp").compare("9.99") )
+    Property *p = mgr.getProperty("myProp");
+    TS_ASSERT( ! p->documentation().compare("hello") )
+    
+    TS_ASSERT_THROWS( mgr.declareProperty("MYPROP", 5), Exception::ExistsError )
+	}
+
+	void testdeclareProperty_string()
+	{
+    PropertyManager mgr;
+    TS_ASSERT_THROWS_NOTHING( mgr.declareProperty("myProp", "theValue", "hello") )
+    TS_ASSERT( ! mgr.getPropertyValue("myProp").compare("theValue") )
+    Property *p = mgr.getProperty("myProp");
+    TS_ASSERT( ! p->documentation().compare("hello") )
+    
+    TS_ASSERT_THROWS( mgr.declareProperty("MYPROP", 5), Exception::ExistsError )
+	}
+
+	void testSetProperty()
+	{
+		manager.setProperty("APROP","10");
+		TS_ASSERT( ! manager.getPropertyValue("aProp").compare("10") )
+    manager.setProperty("aProp","1");
+		TS_ASSERT_THROWS( manager.setProperty("fhfjsdf","0"), Exception::NotFoundError )
+	}
+
+	void testCheckProperty()
+	{
+	  Property *p = new PropertyWithValue<int>("sjfudh",0);
+	  TS_ASSERT( ! manager.checkProperty(p) )
+		Property *pp = new PropertyWithValue<double>("APROP",9.99);
+    // Note that although the name of the property is the same, the type is different - yet it passes
+		TS_ASSERT( manager.checkProperty(pp) )
+	}
+
+	void testGetPropertyValue()
+	{
+		TS_ASSERT( ! manager.getPropertyValue("APROP").compare("1") )
+		TS_ASSERT_THROWS( manager.getPropertyValue("sdfshdu"), Exception::NotFoundError )
+	}
+
+	void testGetProperty()
+	{
+		Property *p = manager.getProperty("APROP");
+		TS_ASSERT( p )
+		TS_ASSERT( ! p->name().compare("aProp") )
+		TS_ASSERT( ! p->value().compare("1") )
+		TS_ASSERT( ! p->documentation().compare("") )
+		TS_ASSERT( typeid(int) == *p->type_info() )
+		
+		TS_ASSERT_THROWS( manager.getProperty("werhui"), Exception::NotFoundError )
+
+	}
+
+	void testGetProperties()
+	{
+	  std::vector<Property*> props = manager.getProperties();
+	  TS_ASSERT( props.size() == 1 )
+	  Property *p = props[0];
+    TS_ASSERT( ! p->name().compare("aProp") )
+    TS_ASSERT( ! p->value().compare("1") )
+	}
+
+private:
+  PropertyManager manager;
+	
+};
+
+#endif /*PROPERTYMANAGERTEST_H_*/