Expose the new class registry methods.

Added wrappers for _aliasType, _deregisterType, isRegisteredType,
and getAliasedTypes.

Author: pavoljuhas

diffpy/srreal/_docstrings.py

@@ -37,7 +37,11 @@ def get_registry_docstrings(cls):
         ("clone", doc_HasClassRegistry_clone),
         ("type", doc_HasClassRegistry_type),
         ("_registerThisType", doc_HasClassRegistry__registerThisType),
+        ("_aliasType", doc_HasClassRegistry__aliasType),
+        ("_deregisterType", doc_HasClassRegistry__deregisterType),
         ("createByType", doc_HasClassRegistry_createByType),
+        ("isRegisteredType", doc_HasClassRegistry_isRegisteredType),
+        ("getAliasedTypes", doc_HasClassRegistry_getAliasedTypes),
         ("getRegisteredTypes", doc_HasClassRegistry_getRegisteredTypes),
     )}
     return rv
@@ -74,6 +78,40 @@ class to support pickling and the `createByType` factory.
 """
 
 
+doc_HasClassRegistry__aliasType = """\
+Register the specified class type under another string alias.
+
+Parameters
+----------
+tp : str
+    string type identifying a registered @NAME@ class.
+alias : str
+    string alias to be used for the `tp` type.
+
+Raises
+------
+RuntimeError
+    When they `tp` type is unknown or if the `alias` type is already
+    registered.
+"""
+
+
+doc_HasClassRegistry__deregisterType = """\
+Cancel registration of the specified string type and any of its aliases.
+
+Parameters
+----------
+tp : str
+    string type or an alias of a registered @NAME@ class.
+
+Returns
+-------
+count : int
+    Number of unregistered names or aliases.
+    Return 0 if `tp` is not a registered type.
+"""
+
+
 doc_HasClassRegistry_createByType = """\
 Return a new @NAME@ instance of the specified string type.
 
@@ -87,6 +125,30 @@ class to support pickling and the `createByType` factory.
 See Also
 --------
 getRegisteredTypes : Return set of the recognized type strings.
+getAliasedTypes : Return dictionary of string aliases.
+"""
+
+
+doc_HasClassRegistry_isRegisteredType = """\
+Check if the given string is registered as a @NAME@ type.
+
+Parameters
+----------
+tp : str
+    string name or an alias to be checked.
+
+Return ``True`` if `tp` is known to the registry either as
+a standard type or its alias.
+"""
+
+
+doc_HasClassRegistry_getAliasedTypes = """\
+Get all aliases registered for the @NAME@ string types.
+
+Returns
+-------
+dict
+    a map of registered aliases to their corresponding standard names.
 """
 
 

diffpy/srreal/tests/testpdfbaseline.py

@@ -21,6 +21,10 @@ def setUp(self):
 
 
     def tearDown(self):
+        for tp in PDFBaseline.getRegisteredTypes():
+            PDFBaseline._deregisterType(tp)
+        self.linear._registerThisType()
+        self.zero._registerThisType()
         return
 
 
@@ -87,13 +91,69 @@ def test_type(self):
         return
 
 
+    def test__aliasType(self):
+        """check PDFBaseline._aliasType.
+        """
+        self.assertRaises(ValueError, PDFBaseline.createByType, "alias")
+        self.assertRaises(RuntimeError, PDFBaseline._aliasType,
+                          "invalid", "alias")
+        self.assertRaises(RuntimeError, PDFBaseline._aliasType,
+                          "linear", "zero")
+        PDFBaseline._aliasType("linear", "alias")
+        bl = PDFBaseline.createByType("alias")
+        self.assertEqual("linear", bl.type())
+        self.assertTrue(isinstance(bl, LinearBaseline))
+        # second registration is a no-op
+        PDFBaseline._aliasType("linear", "alias")
+        bl1 = PDFBaseline.createByType("alias")
+        self.assertTrue(isinstance(bl1, LinearBaseline))
+        # no other type can be aliased to the existing name.
+        self.assertRaises(RuntimeError, PDFBaseline._aliasType,
+                          "zero", "alias")
+        return
+
+
+    def test__deregisterType(self):
+        """check PDFBaseline._deregisterType.
+        """
+        self.assertEqual(0, PDFBaseline._deregisterType("nonexistent"))
+        PDFBaseline._aliasType("linear", "alias")
+        self.assertEqual(2, PDFBaseline._deregisterType("alias"))
+        self.assertFalse('linear' in PDFBaseline.getRegisteredTypes())
+        self.assertEqual(0, PDFBaseline._deregisterType("alias"))
+        return
+
+
     def test_createByType(self):
         """check PDFBaseline.createByType()
         """
         self.assertRaises(ValueError, PDFBaseline.createByType, 'notregistered')
         return
 
 
+    def test_isRegisteredType(self):
+        """check PDFBaseline.isRegisteredType()
+        """
+        self.assertTrue(PDFBaseline.isRegisteredType("linear"))
+        self.assertFalse(PDFBaseline.isRegisteredType("nonexistent"))
+        PDFBaseline._deregisterType("linear")
+        self.assertFalse(PDFBaseline.isRegisteredType("linear"))
+        return
+
+
+    def test_getAliasedTypes(self):
+        """check PDFBaseline.getAliasedTypes()
+        """
+        self.assertEqual({}, PDFBaseline.getAliasedTypes())
+        PDFBaseline._aliasType("linear", "foo")
+        PDFBaseline._aliasType("linear", "bar")
+        PDFBaseline._aliasType("linear", "linear")
+        PDFBaseline._aliasType("bar", "foo")
+        self.assertEqual({'bar' : 'linear', 'foo' : 'linear'},
+                         PDFBaseline.getAliasedTypes())
+        return
+
+
     def test_getRegisteredTypes(self):
         """check PDFBaseline.getRegisteredTypes
         """

srrealmodule/srreal_registry.hpp

@@ -72,7 +72,14 @@ class wrapper_registry_configurator
 ::boost::python::object get_registry_docstrings(::boost::python::object& cls);
 
 
-/// helper wrapper function for return value conversion.
+/// helper wrapper functions for return value conversions.
+
+template <class W>
+::boost::python::object getAliasedTypes_asdict()
+{
+    return convertToPythonDict(W::getAliasedTypes());
+}
+
 template <class W>
 ::boost::python::object getRegisteredTypes_asset()
 {
@@ -94,7 +101,11 @@ C& wrap_registry_methods(C& boostpythonclass)
     const char* doc_clone = CString(d["clone"]);
     const char* doc_type = CString(d["type"]);
     const char* doc__registerThisType = CString(d["_registerThisType"]);
+    const char* doc__aliasType = CString(d["_aliasType"]);
+    const char* doc__deregisterType = CString(d["_deregisterType"]);
     const char* doc_createByType = CString(d["createByType"]);
+    const char* doc_isRegisteredType = CString(d["isRegisteredType"]);
+    const char* doc_getAliasedTypes = CString(d["getAliasedTypes"]);
     const char* doc_getRegisteredTypes = CString(d["getRegisteredTypes"]);
     // define the class registry related methods.
     boostpythonclass
@@ -105,9 +116,21 @@ C& wrap_registry_methods(C& boostpythonclass)
                 doc_type)
         .def("_registerThisType", &B::registerThisType,
                 doc__registerThisType)
+        .def("_aliasType", &B::aliasType,
+                (bp::arg("tp"), bp::arg("alias")), doc__aliasType)
+        .staticmethod("_aliasType")
+        .def("_deregisterType", &B::deregisterType,
+                bp::arg("tp"), doc__deregisterType)
+        .staticmethod("_deregisterType")
         .def("createByType", &B::createByType,
                 bp::arg("tp"), doc_createByType)
         .staticmethod("createByType")
+        .def("isRegisteredType", &B::isRegisteredType,
+                bp::arg("tp"), doc_isRegisteredType)
+        .staticmethod("isRegisteredType")
+        .def("getAliasedTypes", getAliasedTypes_asdict<B>,
+                doc_getAliasedTypes)
+        .staticmethod("getAliasedTypes")
         .def("getRegisteredTypes", getRegisteredTypes_asset<B>,
                 doc_getRegisteredTypes)
         .staticmethod("getRegisteredTypes")