Merge branch 'extend-class-registry'.

Author: pavoljuhas

src/diffpy/HasClassRegistry.hpp

@@ -54,15 +54,26 @@ class HasClassRegistry
 
         // methods provided by HasClassRegistry
 
-        /// Add a prototype of this instance to the registry
+        /// Add a prototype of this instance to the registry.
         virtual bool registerThisType() const;
 
-        /// Make registered type tp available under a different alias
+        /// Make registered type tp available under a different alias.
         static bool aliasType(const std::string& tp, const std::string& al);
 
+        /// Clear registration of the specified type under its standard name
+        /// or any alias.  Return the number of unset names and aliases or
+        /// 0 if the specifed string type was not registered.
+        static int deregisterType(const std::string& tp);
+
         /// Create new instance of a specified string type.
         static SharedPtr createByType(const std::string& tp);
 
+        /// Return true if string is a registered string type or its alias.
+        static bool isRegisteredType(const std::string& tp);
+
+        /// Return a map of string aliases to standard type strings.
+        static std::map<std::string, std::string> getAliasedTypes();
+
         /// Return a set of all registered string types
         static std::set<std::string> getRegisteredTypes();
 

src/diffpy/HasClassRegistry.ipp

@@ -35,9 +35,6 @@ bool HasClassRegistry<TBase>::registerThisType() const
     RegistryStorage& reg = getRegistry();
     if (reg.count(this->type()))
     {
-        // do nothing when registering the same class twice
-        const TBase& regprot = *(reg[this->type()]);
-        if (typeid(*this) == typeid(regprot))    return true;
         // raise exception if trying to register a different class
         ostringstream emsg;
         emsg << "Prototype type '" << this->type() <<
@@ -77,6 +74,27 @@ bool HasClassRegistry<TBase>::aliasType(const std::string& tp,
 }
 
 
+template <class TBase>
+int HasClassRegistry<TBase>::deregisterType(const std::string& tp)
+{
+    RegistryStorage& reg = getRegistry();
+    typename RegistryStorage::iterator ii = reg.find(tp);
+    if (ii == reg.end())  return 0;
+    SharedPtr p = ii->second;
+    int rv = 0;
+    for (ii = reg.begin(); ii != reg.end();)
+    {
+        typename RegistryStorage::iterator jj = ii++;
+        if (jj->second == p)
+        {
+            reg.erase(jj);
+            ++rv;
+        }
+    }
+    return rv;
+}
+
+
 template <class TBase>
 typename HasClassRegistry<TBase>::SharedPtr
 HasClassRegistry<TBase>::createByType(const std::string& tp)
@@ -96,6 +114,34 @@ HasClassRegistry<TBase>::createByType(const std::string& tp)
 }
 
 
+template <class TBase>
+bool
+HasClassRegistry<TBase>::isRegisteredType(const std::string& tp)
+{
+    const RegistryStorage& reg = getRegistry();
+    return reg.count(tp);
+}
+
+
+template <class TBase>
+std::map<std::string, std::string>
+HasClassRegistry<TBase>::getAliasedTypes()
+{
+    using namespace std;
+    map<string, string> rv;
+    const RegistryStorage& reg = getRegistry();
+    typename RegistryStorage::const_iterator irg = reg.begin();
+    for (; irg != reg.end(); ++irg)
+    {
+        if (irg->first != irg->second->type())
+        {
+            rv[irg->first] = irg->second->type();
+        }
+    }
+    return rv;
+}
+
+
 template <class TBase>
 std::set<std::string>
 HasClassRegistry<TBase>::getRegisteredTypes()

src/tests/TestHasClassRegistry.hpp

@@ -0,0 +1,87 @@
+/*****************************************************************************
+*
+* libdiffpy         Complex Modeling Initiative
+*                   (c) 2016 Brookhaven Science Associates,
+*                   Brookhaven National Laboratory.
+*                   All rights reserved.
+*
+* File coded by:    Pavol Juhas
+*
+* See AUTHORS.txt for a list of people who contributed.
+* See LICENSE.txt for license information.
+*
+******************************************************************************
+*
+* class TestHasClassRegistry -- test registration machinery for named classes.
+*
+*****************************************************************************/
+
+#include <cxxtest/TestSuite.h>
+
+#include <diffpy/srreal/ScatteringFactorTable.hpp>
+
+using diffpy::srreal::ScatteringFactorTable;
+using diffpy::srreal::ScatteringFactorTablePtr;
+
+//////////////////////////////////////////////////////////////////////////////
+// class TestHasClassRegistry
+//////////////////////////////////////////////////////////////////////////////
+
+class TestHasClassRegistry : public CxxTest::TestSuite
+{
+    private:
+
+        typedef diffpy::HasClassRegistry<ScatteringFactorTable> HCRBase;
+        ScatteringFactorTablePtr msftb;
+        HCRBase* mpreg;
+
+    public:
+
+        void setUp()
+        {
+            msftb = ScatteringFactorTable::createByType("xray");
+            mpreg = msftb.get();
+        }
+
+        void tearDown()
+        {
+            // restore SFTXray registration if removed in some test.
+            msftb->deregisterType(msftb->type());
+            msftb->registerThisType();
+            TS_ASSERT(ScatteringFactorTable::isRegisteredType("X"));
+            TS_ASSERT(ScatteringFactorTable::isRegisteredType("xray"));
+        }
+
+
+        void test_deregisterType()
+        {
+            TS_ASSERT_EQUALS(0,
+                    ScatteringFactorTable::deregisterType("invalid"));
+            TS_ASSERT_EQUALS(2,
+                    ScatteringFactorTable::deregisterType("X"));
+            TS_ASSERT(!(mpreg->isRegisteredType("xray")));
+            TS_ASSERT(!(mpreg->isRegisteredType("X")));
+        }
+
+
+        void test_isRegisteredType()
+        {
+            TS_ASSERT(msftb->isRegisteredType("xray"));
+            TS_ASSERT(ScatteringFactorTable::isRegisteredType("X"));
+            TS_ASSERT_EQUALS(false, mpreg->isRegisteredType("invalid"));
+        }
+
+
+        void test_getAliasedTypes()
+        {
+            std::map<std::string, std::string> atps;
+            atps = ScatteringFactorTable::getAliasedTypes();
+            TS_ASSERT_EQUALS(4, atps.size());
+            TS_ASSERT(atps.count("X"));
+            TS_ASSERT_EQUALS("xray", atps["X"]);
+            TS_ASSERT_EQUALS("electronnumber", atps["EN"]);
+        }
+
+};  // class TestHasClassRegistry
+
+// End of file