Reaction.hpp

Go to the documentation of this file.

/* 
 * Reaction.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_CHEM_REACTION_HPP
#define CDPL_CHEM_REACTION_HPP
 
#include <memory>
#include <functional>
 
#include "CDPL/Chem/APIPrefix.hpp"
#include "CDPL/Base/PropertyContainer.hpp"
#include "CDPL/Util/IndexedElementIterator.hpp"
 
 
namespace CDPL
{
 
    namespace Chem
    {
 
        class Molecule;
 
        class CDPL_CHEM_API Reaction : public Base::PropertyContainer
        {
 
            class ConstComponentAccessor;
            class ComponentAccessor;
 
          public:
            typedef std::shared_ptr<Reaction> SharedPointer;
 
            typedef Util::IndexedElementIterator<const Molecule, ConstComponentAccessor> ConstComponentIterator;
 
            typedef Util::IndexedElementIterator<Molecule, ComponentAccessor> ComponentIterator;
 
            typedef std::function<void(Reaction&, const Reaction&)> CopyPostprocessingFunction;
 
            virtual ~Reaction() {}
 
            virtual void clear() = 0;
 
            virtual std::size_t getNumComponents() const = 0;
 
            virtual std::size_t getNumComponents(unsigned int role) const = 0;
 
            virtual unsigned int getComponentRole(const Molecule& mol) const = 0;
 
            virtual std::size_t getComponentIndex(const Molecule& mol) const = 0;
 
            virtual bool containsComponent(const Molecule& mol) const = 0;
 
            ConstComponentIterator getComponentsBegin() const;
 
            ComponentIterator getComponentsBegin();
 
            ConstComponentIterator getComponentsEnd() const;
 
            ComponentIterator getComponentsEnd();
 
            ConstComponentIterator begin() const;
 
            ComponentIterator begin();
 
            ConstComponentIterator end() const;
 
            ComponentIterator end();
 
            ConstComponentIterator getComponentsBegin(unsigned int role) const;
 
            ComponentIterator getComponentsBegin(unsigned int role);
 
            ConstComponentIterator getComponentsEnd(unsigned int role) const;
 
            ComponentIterator getComponentsEnd(unsigned int role);
 
            virtual const Molecule& getComponent(std::size_t idx) const = 0;
 
            virtual Molecule& getComponent(std::size_t idx) = 0;
 
            virtual const Molecule& getComponent(std::size_t idx, unsigned int role) const = 0;
 
            virtual Molecule& getComponent(std::size_t idx, unsigned int role) = 0;
 
            virtual Molecule& addComponent(unsigned int role) = 0;
 
            virtual void swapComponentRoles(unsigned int role1, unsigned int role2) = 0;
 
            virtual void removeComponent(std::size_t idx) = 0;
 
            virtual void removeComponent(std::size_t idx, unsigned int role) = 0;
 
            ComponentIterator removeComponent(const ComponentIterator& it);
 
            virtual void removeComponents(unsigned int role) = 0;
 
            virtual SharedPointer clone() const = 0;
 
            virtual void copy(const Reaction& rxn) = 0;
 
            Reaction& operator=(const Reaction& rxn);
 
            static void registerCopyPostprocessingFunction(const CopyPostprocessingFunction& func);
 
          protected:
            void invokeCopyPostprocessingFunctions(const Reaction& src_rxn);
            
          private:
            class CDPL_CHEM_API ConstComponentAccessor
            {
 
                friend class Reaction;
 
              public:
                ConstComponentAccessor(const ComponentAccessor& accessor):
                    reaction(accessor.reaction), compRole(accessor.compRole) {}
                ConstComponentAccessor(const Reaction* rxn, unsigned int role):
                    reaction(rxn), compRole(role) {}
 
                const Molecule& operator()(std::size_t idx) const;
 
                bool operator==(const ConstComponentAccessor& accessor) const;
 
              private:
                const Reaction* reaction;
                unsigned int    compRole;
            };
 
            class CDPL_CHEM_API ComponentAccessor
            {
 
                friend class Reaction;
                friend class ConstComponentAccessor;
 
              public:
                ComponentAccessor(Reaction* rxn, unsigned int role):
                    reaction(rxn), compRole(role) {}
 
                Molecule& operator()(std::size_t idx) const;
 
                bool operator==(const ComponentAccessor& accessor) const;
 
              private:
                Reaction*    reaction;
                unsigned int compRole;
            };
        };
    } // namespace Chem
} // namespace CDPL
 
#endif // CDPL_CHEM_REACTION_HPP