Reactor.hpp

Go to the documentation of this file.

/* 
 * Reactor.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_REACTOR_HPP
#define CDPL_CHEM_REACTOR_HPP
 
#include <map>
#include <vector>
#include <utility>
#include <cstddef>
 
#include "CDPL/Chem/APIPrefix.hpp"
#include "CDPL/Chem/Reaction.hpp"
#include "CDPL/Chem/ReactionSubstructureSearch.hpp"
#include "CDPL/Util/BitSet.hpp"
 
 
namespace CDPL
{
 
    namespace Chem
    {
 
        class CDPL_CHEM_API Reactor
        {
 
          public:
            typedef AtomBondMapping ReactionSite;
 
            typedef ReactionSubstructureSearch::MappingIterator ReactionSiteIterator;
 
            typedef ReactionSubstructureSearch::ConstMappingIterator ConstReactionSiteIterator;
 
            Reactor();
 
            Reactor(const Reaction& rxn_pattern);
 
            ~Reactor();
 
            void setReactionPattern(const Reaction& rxn_pattern);
 
            bool findReactionSites(Reaction& rxn_target);
 
            std::size_t getNumReactionSites() const;
 
            ReactionSite& getReactionSite(std::size_t idx);
 
            const ReactionSite& getReactionSite(std::size_t idx) const;
 
            ReactionSiteIterator getReactionSitesBegin();
 
            ConstReactionSiteIterator getReactionSitesBegin() const;
 
            ReactionSiteIterator getReactionSitesEnd();
 
            ConstReactionSiteIterator getReactionSitesEnd() const;
 
            ReactionSiteIterator begin();
 
            ConstReactionSiteIterator begin() const;
 
            ReactionSiteIterator end();
 
            ConstReactionSiteIterator end() const;
 
            void performReaction(const ReactionSite& rxn_site);
 
          private:
            Reactor(const Reactor&);
 
            Reactor& operator=(const Reactor&);
 
            void init();
 
            void createAtoms(Molecule*);
            void createBonds(Molecule*);
 
            void deleteBonds(const ReactionSite&, Molecule*) const;
            void deleteAtoms(const ReactionSite&, Molecule*) const;
 
            void editAtoms() const;
            void editBonds() const;
 
            void editStereoProperties() const;
 
            void editProdAtomStereoDescriptor(const Atom*, Atom*) const;
            void editProdBondStereoDescriptor(const Bond*, Bond*) const;
 
            template <typename T>
            void copyProperty(const T*, T*, const Base::LookupKey&) const;
 
            const Base::Any& getProperty(const Atom*, const Base::LookupKey&) const;
            const Base::Any& getProperty(const Bond*, const Base::LookupKey&) const;
 
            Molecule* copyReactants(const ReactionSite&);
 
            Atom* getMappedTgtProdAtom(const Atom*) const;
            Bond* getMappedTgtProdBond(const Bond*) const;
 
            typedef std::pair<std::size_t, std::size_t> IDPair;
 
            struct IDPairLessCmpFunc
            {
 
                bool operator()(const IDPair&, const IDPair&) const;
            };
 
            typedef std::pair<const Atom*, const Atom*>              AtomPair;
            typedef std::pair<const Bond*, const Bond*>              BondPair;
            typedef std::map<std::size_t, const Atom*>               IDAtomMap;
            typedef std::map<IDPair, const Bond*, IDPairLessCmpFunc> IDPairBondMap;
            typedef std::map<const Atom*, Atom*>                     AtomMap;
            typedef std::map<const Bond*, Bond*>                     BondMap;
            typedef std::vector<AtomPair>                            AtomPairList;
            typedef std::vector<BondPair>                            BondPairList;
 
            const Reaction*            rxnPattern;
            Reaction*                  rxnTarget;
            ReactionSubstructureSearch rxnSiteSearch;
            IDAtomMap                  reacAtomsToDelete;
            IDAtomMap                  prodAtomsToCreate;
            IDPairBondMap              reacBondsToDelete;
            IDPairBondMap              prodBondsToCreate;
            AtomPairList               ptnAtomMapping;
            BondPairList               ptnBondMapping;
            AtomMap                    tgtAtomMapping;
            BondMap                    tgtBondMapping;
            Util::BitSet               mappedAtomMask;
        };
    } // namespace Chem
} // namespace CDPL
 
#endif // CDPL_CHEM_REACTOR_HPP