Improved BoundedValidator constructor in Python. Refs #4399

Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Exports/BoundedValidator.cpp

@@ -1,18 +1,42 @@
 #include "MantidKernel/BoundedValidator.h"
 #include <boost/python/class.hpp>
 #include <boost/python/copy_const_reference.hpp>
+#include <boost/python/make_constructor.hpp>
+#include <boost/python/default_call_policies.hpp>
 
 using Mantid::Kernel::BoundedValidator;
 using Mantid::Kernel::IValidator;
 using namespace boost::python;
 
 namespace
 {
+  /**
+   * Factory function to allow more flexibility in the constructor
+   * @param lower An optional lower bound
+   * @param upper An optional upper bound
+   * @returns A pointer to a new BoundedValidator object
+   */
+  template<typename T>
+  BoundedValidator<T> * createBoundedValidator(object lower = object(), object upper = object())
+  {
+    BoundedValidator<T> * validator = new BoundedValidator<T>();
+    if(!lower.is_none())
+    {
+      validator->setLower(extract<T>(lower));
+    }
+    if(!upper.is_none())
+    {
+      validator->setUpper(extract<T>(upper));
+    }
+    return validator;
+  }
+
   /// A macro for generating exports for each type
   #define EXPORT_BOUNDEDVALIDATOR(ElementType, prefix) \
     class_<BoundedValidator<ElementType>, bases<IValidator>, \
            boost::noncopyable>(#prefix"BoundedValidator") \
-      .def(init<ElementType,ElementType>()) \
+      .def("__init__", make_constructor(&createBoundedValidator<ElementType>, \
+                                        default_call_policies(), (arg("lower")=object(), arg("upper")=object())))\
       .def("setLower", &BoundedValidator<ElementType>::setLower, "Set the lower bound") \
       .def("setUpper", &BoundedValidator<ElementType>::setUpper, "Set the upper bound" ) \
       .def("lower", &BoundedValidator<ElementType>::lower, return_value_policy<copy_const_reference>(), \
@@ -21,7 +45,7 @@ namespace
            "Returns the upper bound" ) \
       .def("setBounds", &BoundedValidator<ElementType>::setBounds, "Set both bounds" ) \
       .def("hasLower", &BoundedValidator<ElementType>::hasLower, "Returns True if a lower bound has been set" ) \
-      .def("hasUpper", &BoundedValidator<ElementType>::hasLower, "Returns True if an upper bound has been set" ) \
+      .def("hasUpper", &BoundedValidator<ElementType>::hasUpper, "Returns True if an upper bound has been set" ) \
     ;
 
 }

Code/Mantid/Framework/PythonInterface/test/python/BoundedValidatorTest.py

@@ -2,20 +2,39 @@
 import testhelpers
 from mantid import FloatBoundedValidator, IntBoundedValidator
 
-class BoundedValidatorTest(object):
+class BoundedValidatorTest(unittest.TestCase):
 
     def test_construction_does_not_raise_error_when_both_are_floats(self):
         testhelpers.assertRaisesNothing(self, FloatBoundedValidator, 1.0, 2.0)
+
+    def test_constructor_sets_both_boundary_values_correctly(self):
+        validator = FloatBoundedValidator(1.3, 2.6)
+        self.assertTrue(validator.hasLower())
+        self.assertEquals(validator.lower(), 1.3)
+        self.assertTrue(validator.hasUpper())
+        self.assertEquals(validator.upper(), 2.6)
 
     def test_construction_does_not_raise_error_when_both_are_ints(self):
         testhelpers.assertRaisesNothing(self, IntBoundedValidator, 1, 20)
 
+    def test_lower_only_keyword_in_constructor(self):
+        validator = FloatBoundedValidator(lower=2.5)
+        self.assertTrue(validator.hasLower())
+        self.assertEquals(validator.lower(), 2.5)
+        self.assertFalse(validator.hasUpper())
+
+    def test_upper_only_keyword_in_constructor(self):
+        validator = FloatBoundedValidator(upper=5.5)
+        self.assertFalse(validator.hasLower())
+        self.assertTrue(validator.hasUpper())
+        self.assertEquals(validator.upper(), 5.5)
+
     def test_construction_with_lower_sets_only_lower(self):
         validator = FloatBoundedValidator()
         lower = 1.4
         validator.setLower(lower)
         self.assertEquals(validator.hasLower(), True)
-        self.assertEquals(validator.hasUpper(), False)
+        self.assertFalse(validator.hasUpper())
         self.assertEquals(validator.lower(), lower)
 
     def test_construction_with_upper_sets_only_upper(self):