feat(CompositionDecorator): added composition decorator

It is sometimes useful for callers to be able to create new composition objects without overloading all the required methods. The CompositionDecorator acts as a simple translation layer which will pass any calls to virtual methods down to the next level of the composition stack (other than those which may have been overloaded by the caller)

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = fourdst::libcomposition
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = v2.0.2
+PROJECT_NUMBER         = v2.0.3
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewers a

meson.build

@@ -18,7 +18,7 @@
 #   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #
 # *********************************************************************** #
-project('libcomposition', 'cpp', version: 'v2.0.2', default_options: ['cpp_std=c++23'], meson_version: '>=1.5.0')
+project('libcomposition', 'cpp', version: 'v2.0.3', default_options: ['cpp_std=c++23'], meson_version: '>=1.5.0')
 
 # Add default visibility for all C++ targets
 add_project_arguments('-fvisibility=default', language: 'cpp')

src/composition/include/fourdst/composition/composition_abstract.h

@@ -171,4 +171,33 @@ namespace fourdst::composition {
          */
         [[nodiscard]] virtual fourdst::atomic::Species getSpeciesAtIndex(size_t index) const = 0;
     };
+
+    // ReSharper disable once CppClassCanBeFinal
+    class CompositionDecorator : public CompositionAbstract {
+    public:
+        explicit CompositionDecorator(std::unique_ptr<CompositionAbstract> decorator) : m_base_composition(std::move(decorator)) {};
+        [[nodiscard]] bool contains(const atomic::Species &species) const noexcept override { return m_base_composition->contains(species); };
+        [[nodiscard]] bool contains(const std::string& symbol) const override { return m_base_composition->contains(symbol); };
+        [[nodiscard]] size_t size() const noexcept override { return m_base_composition->size(); };
+        [[nodiscard]] std::set<std::string> getRegisteredSymbols() const noexcept override { return m_base_composition->getRegisteredSymbols(); };
+        [[nodiscard]] const std::set<atomic::Species> &getRegisteredSpecies() const noexcept override { return m_base_composition->getRegisteredSpecies(); };
+        [[nodiscard]] std::unordered_map<atomic::Species, double> getMassFraction() const noexcept override { return m_base_composition->getMassFraction(); };
+        [[nodiscard]] std::unordered_map<atomic::Species, double> getNumberFraction() const noexcept override { return m_base_composition->getNumberFraction(); };
+        [[nodiscard]] double getMassFraction(const std::string& symbol) const override { return m_base_composition->getMassFraction(symbol); };
+        [[nodiscard]] double getMassFraction(const atomic::Species& species) const override { return m_base_composition->getMassFraction(species); };
+        [[nodiscard]] double getNumberFraction(const std::string& symbol) const override { return m_base_composition->getNumberFraction(symbol); };
+        [[nodiscard]] double getNumberFraction(const atomic::Species& species) const override { return m_base_composition->getNumberFraction(species); };
+        [[nodiscard]] double getMolarAbundance(const std::string& symbol) const override { return m_base_composition->getMolarAbundance(symbol); };
+        [[nodiscard]] double getMolarAbundance(const atomic::Species& species) const override { return m_base_composition->getMolarAbundance(species); };
+        [[nodiscard]] double getMeanParticleMass() const noexcept override { return m_base_composition->getMeanParticleMass(); };
+        [[nodiscard]] double getElectronAbundance() const noexcept override { return m_base_composition->getElectronAbundance(); };
+        [[nodiscard]] std::vector<double> getMassFractionVector() const noexcept override { return m_base_composition->getMassFractionVector(); };
+        [[nodiscard]] std::vector<double> getNumberFractionVector() const noexcept override { return m_base_composition->getNumberFractionVector(); };
+        [[nodiscard]] std::vector<double> getMolarAbundanceVector() const noexcept override { return m_base_composition->getMolarAbundanceVector(); };
+        [[nodiscard]] size_t getSpeciesIndex(const std::string& symbol) const override { return m_base_composition->getSpeciesIndex(symbol); };
+        [[nodiscard]] size_t getSpeciesIndex(const atomic::Species& species) const override { return m_base_composition->getSpeciesIndex(species); };
+        [[nodiscard]] atomic::Species getSpeciesAtIndex(const size_t index) const override { return m_base_composition->getSpeciesAtIndex(index); };
+    private:
+        std::unique_ptr<CompositionAbstract> m_base_composition;
+    };
 }

tests/composition/compositionTest.cpp

@@ -8,6 +8,7 @@
 #include "fourdst/composition/composition.h"
 #include "fourdst/composition/exceptions/exceptions_composition.h"
 #include "fourdst/composition/utils.h"
+#include "fourdst/composition/composition_abstract.h"
 
 #include "fourdst/config/config.h"
 
@@ -247,30 +248,28 @@ TEST_F(compositionTest, buildFromMassFractions) {
  * - All CompositionAbstract children have the standard getter interface.
  */
 TEST_F(compositionTest, abstractBase) {
-    class UnrestrictedComposition : public fourdst::composition::Composition {
-    private:
-        fourdst::atomic::Species m_species;
-        const Composition& m_composition;
+    class UnrestrictedComposition : public fourdst::composition::CompositionDecorator {
     public:
-        UnrestrictedComposition(const Composition& base, const fourdst::atomic::Species& species):
-        Composition(base),
-        m_species(species),
-        m_composition(base)
+        UnrestrictedComposition(std::unique_ptr<CompositionAbstract> base, const fourdst::atomic::Species& species):
+        CompositionDecorator(std::move(base)),
+        m_species(species)
         {}
 
         double getMolarAbundance(const fourdst::atomic::Species &species) const override {
             if (species == m_species) {
                 return 1.0;
             }
-            return m_composition.getMolarAbundance(species);
+            return CompositionDecorator::getMolarAbundance(species);
         }
+    private:
+        fourdst::atomic::Species m_species;
     };
 
     fourdst::composition::Composition comp;
     comp.registerSymbol("H-1"); comp.registerSymbol("He-4"); comp.registerSymbol("O-16");
     comp.setMolarAbundance("H-1", 0.6); comp.setMolarAbundance("He-4", 0.6);
 
-    const UnrestrictedComposition uComp(comp, fourdst::atomic::H_1);
+    const UnrestrictedComposition uComp(std::make_unique<fourdst::composition::Composition>(comp), fourdst::atomic::H_1);
 
     ASSERT_DOUBLE_EQ(uComp.getMolarAbundance(fourdst::atomic::H_1), 1.0);
     ASSERT_DOUBLE_EQ(uComp.getMassFraction("He-4"), comp.getMassFraction("He-4"));