Add local class EmptyStructureAdapter.

This adapter type can only be empty.  Use it for the singleton
returned from emptyStructureAdapter().  This ensures that empty
singleton cannot be broken by adding some atoms.

Author: pavoljuhas

src/diffpy/srreal/EmptyStructureAdapter.cpp

@@ -0,0 +1,130 @@
+/*****************************************************************************
+*
+* 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 EmptyStructureAdapter -- immutable class that is always empty.
+*
+*****************************************************************************/
+
+#include <diffpy/serialization.ipp>
+#include <diffpy/srreal/StructureAdapter.hpp>
+
+namespace diffpy {
+namespace srreal {
+
+// Local constants -----------------------------------------------------------
+
+namespace {
+
+std::out_of_range outofrange("Index out of range.");
+
+}   // namespace
+
+//////////////////////////////////////////////////////////////////////////////
+// class EmptyStructureAdapter
+//////////////////////////////////////////////////////////////////////////////
+
+class EmptyStructureAdapter : public StructureAdapter
+{
+    public:
+
+        // virtual methods from the base class
+
+        virtual StructureAdapterPtr clone() const
+        {
+            StructureAdapterPtr rv =
+                boost::const_pointer_cast<StructureAdapter>(shared_from_this());
+            return rv;
+        }
+
+
+        virtual BaseBondGeneratorPtr createBondGenerator() const
+        {
+            return boost::make_shared<BaseBondGenerator>(shared_from_this());
+        }
+
+
+        virtual int countSites() const
+        {
+            return 0;
+        }
+
+        // reusing StructureAdapter::totalOccupancy()
+        // reusing StructureAdapter::numberDensity()
+
+        virtual const std::string& siteAtomType(int idx) const
+        {
+            throw outofrange;
+        }
+
+
+        virtual const R3::Vector& siteCartesianPosition(int idx) const
+        {
+            throw outofrange;
+        }
+
+
+        virtual int siteMultiplicity(int idx) const
+        {
+            throw outofrange;
+        }
+
+
+        virtual double siteOccupancy(int idx) const
+        {
+            throw outofrange;
+        }
+
+
+        virtual bool siteAnisotropy(int idx) const
+        {
+            throw outofrange;
+        }
+
+
+        virtual const R3::Matrix& siteCartesianUij(int idx) const
+        {
+            throw outofrange;
+        }
+
+        // reusing StructureAdapter::customPQConfig()
+        // reusing StructureAdapter::diff()
+
+    private:
+
+        // serialization
+        friend class boost::serialization::access;
+        template<class Archive>
+            void serialize(Archive& ar, const unsigned int version)
+        {
+            ar & boost::serialization::base_object<StructureAdapter>(*this);
+        }
+
+};
+
+// Routines ------------------------------------------------------------------
+
+StructureAdapterPtr emptyStructureAdapter()
+{
+    static StructureAdapterPtr stru(new EmptyStructureAdapter);
+    assert(stru && stru->countSites() == 0);
+    return stru;
+}
+
+}   // namespace srreal
+}   // namespace diffpy
+
+BOOST_CLASS_EXPORT(diffpy::srreal::EmptyStructureAdapter)
+DIFFPY_INSTANTIATE_PTR_SERIALIZATION(diffpy::srreal::EmptyStructureAdapter)
+
+// End of file

src/diffpy/srreal/StructureAdapter.cpp

@@ -23,7 +23,6 @@
 #include <diffpy/serialization.ipp>
 #include <diffpy/mathutils.hpp>
 #include <diffpy/srreal/StructureAdapter.hpp>
-#include <diffpy/srreal/AtomicStructureAdapter.hpp>
 #include <diffpy/srreal/StructureDifference.hpp>
 
 using namespace std;
@@ -80,14 +79,6 @@ StructureAdapter::diff(StructureAdapterConstPtr other) const
 
 // Routines ------------------------------------------------------------------
 
-StructureAdapterPtr emptyStructureAdapter()
-{
-    static StructureAdapterPtr stru(new AtomicStructureAdapter);
-    assert(stru && stru->countSites() == 0);
-    return stru;
-}
-
-
 double meanSquareDisplacement(const R3::Matrix& Uijcartn,
         const R3::Vector& s, bool anisotropy)
 {

src/tests/TestEmptyStructureAdapter.hpp

@@ -0,0 +1,82 @@
+/*****************************************************************************
+*
+* 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 TestEmptyStructureAdapter -- test adapter that is always empty
+*
+*****************************************************************************/
+
+#include <cxxtest/TestSuite.h>
+
+#include <diffpy/srreal/AtomicStructureAdapter.hpp>
+#include "serialization_helpers.hpp"
+
+namespace diffpy {
+namespace srreal {
+
+using namespace std;
+
+//////////////////////////////////////////////////////////////////////////////
+// class TestEmptyStructureAdapter
+//////////////////////////////////////////////////////////////////////////////
+
+class TestEmptyStructureAdapter : public CxxTest::TestSuite
+{
+    private:
+
+        StructureAdapterPtr mstru;
+
+    public:
+
+        void setUp()
+        {
+            mstru = emptyStructureAdapter();
+        }
+
+
+        void test_empty_instance()
+        {
+            TS_ASSERT_EQUALS(0, mstru->countSites());
+            TS_ASSERT_EQUALS(mstru.get(), mstru->clone().get());
+            TS_ASSERT_EQUALS(mstru, emptyStructureAdapter());
+            TS_ASSERT_THROWS(mstru->siteAtomType(0), std::out_of_range);
+            TS_ASSERT_THROWS(mstru->siteCartesianPosition(0),
+                    std::out_of_range);
+            TS_ASSERT_THROWS(mstru->siteMultiplicity(0), std::out_of_range);
+            TS_ASSERT_THROWS(mstru->siteOccupancy(0), std::out_of_range);
+            TS_ASSERT_THROWS(mstru->siteAnisotropy(0), std::out_of_range);
+            TS_ASSERT_THROWS(mstru->siteCartesianPosition(0),
+                    std::out_of_range);
+        }
+
+
+        void test_serialization()
+        {
+            StructureAdapterPtr stru1;
+            stru1 = dumpandload(mstru);
+            AtomicStructureAdapterPtr astru1 =
+                boost::dynamic_pointer_cast<AtomicStructureAdapter>(stru1);
+            TS_ASSERT(!astru1);
+            TS_ASSERT_EQUALS(0, stru1->countSites());
+            TS_ASSERT_EQUALS(stru1, stru1->clone());
+            TS_ASSERT_THROWS(mstru->siteAtomType(0), std::out_of_range);
+        }
+
+};  // class TestEmptyStructureAdapter
+
+}   // namespace srreal
+}   // namespace diffpy
+
+using diffpy::srreal::TestEmptyStructureAdapter;
+
+// End of file