/home/msneddon/eclipse/galileoSR1_cpp/workspace/NFsim/src/NFreactions/transformations/transformation.hh

Go to the documentation of this file.

#ifndef TRANSFORMATION_HH_
#define TRANSFORMATION_HH_


#include "../NFreactions.hh"

namespace NFcore
{

        class SpeciesCreator;
        class Mapping;
        class Transformation;


        class TransformationFactory {
                public:
                        static Transformation * genStateChangeTransform(unsigned int cIndex, int newValue);

                        static Transformation * genBindingTransform1(unsigned int bSiteIndex, unsigned int otherReactantIndex, unsigned int otherMappingIndex);
                        static Transformation * genBindingSeparateComplexTransform1(unsigned int bSiteIndex, unsigned int otherReactantIndex, unsigned int otherMappingIndex);

                        static Transformation * genBindingTransform2(unsigned int bSiteIndex);

                        static Transformation * genUnbindingTransform(unsigned int bSiteIndex);

                        static Transformation * genAddMoleculeTransform(SpeciesCreator *sc);

                        static Transformation * genRemoveMoleculeTransform(int removalType);
                        static Transformation * genEmptyTransform();

                        static Transformation * genIncrementStateTransform(unsigned int cIndex);

                        static Transformation * genDecrementStateTransform(unsigned int cIndex);



                        static const int COMPLETE_SPECIES_REMOVAL = 0;

                        static const int DELETE_MOLECULES = 1;

                        static const int DELETE_MOLECULES_NO_KEYWORD = 2;






                        static const unsigned int STATE_CHANGE = 0;

                        static const unsigned int BINDING = 1;

                        static const unsigned int UNBINDING = 2;

                        static const unsigned int REMOVE = 3;

                        static const unsigned int ADD = 4;

                        static const unsigned int EMPTY = 5;

                        static const unsigned int INCREMENT_STATE = 6;


                        static const unsigned int DECREMENT_STATE = 7;




                        static Transformation * genLocalFunctionReference(string PointerName, int type, TemplateMolecule *tm);
                        static const unsigned int LOCAL_FUNCTION_REFERENCE = 8;

        };



        class Transformation {
                public:
                        Transformation(int type) {this->type=type;};
                        virtual ~Transformation() {};
                        int getType() const { return type; }
                        virtual void apply(Mapping *m, MappingSet **ms) = 0;
                        virtual int getComponentIndex() const = 0;
                        virtual int getRemovalType() { return -1; };
                protected:
                        int type;
        };


        class LocalFunctionReference : public Transformation {
                public:
                        LocalFunctionReference(string PointerName, int scope, TemplateMolecule *tm);
                        virtual ~LocalFunctionReference() {};
                        virtual void apply(Mapping *m, MappingSet **ms) {};
                        virtual int getComponentIndex() const { return -1; };

                        TemplateMolecule *getTemplateObject() const {return tm;};
                        string getPointerName() const { return PointerName; };
                        int getFunctionScope() const {return scope; };

                        static const unsigned int SPECIES_FUNCTION=0;
                        static const unsigned int SINGLE_MOLECULE_FUNCTION=1;
                protected:
                        string PointerName;
                        int scope;
                        TemplateMolecule *tm;
        };



        class EmptyTransform : public Transformation {
                public:
                        EmptyTransform() : Transformation(TransformationFactory::EMPTY){ this->cIndex=-1; };
                        EmptyTransform(int cIndex) : Transformation(TransformationFactory::EMPTY){ this->cIndex=cIndex; };
                        virtual ~EmptyTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms) {};
                        virtual int getComponentIndex() const { return cIndex; };
                protected:
                        int cIndex;
        };


        class StateChangeTransform : public Transformation {
                public:
                        StateChangeTransform(int cIndex, int newValue);
                        virtual ~StateChangeTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {return cIndex;};
                protected:
                        int cIndex;
                        int newValue;
        };

        class BindingTransform : public Transformation {
                public:
                        BindingTransform(int cIndex, int otherReactantIndex, int otherMappingIndex);
                        virtual ~BindingTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {return cIndex;};
                protected:
                        int cIndex;
                        int otherReactantIndex;
                        int otherMappingIndex;
        };

        class BindingSeparateComplexTransform : public BindingTransform {
                        public:
                                BindingSeparateComplexTransform(int cIndex, int otherReactantIndex, int otherMappingIndex) :
                                        BindingTransform(cIndex, otherReactantIndex, otherMappingIndex) {};
                                virtual ~BindingSeparateComplexTransform() {};
                                virtual void apply(Mapping *m, MappingSet **ms);
                                virtual int getComponentIndex() const {return cIndex;};
        };

        class UnbindingTransform : public Transformation {
                public:
                        UnbindingTransform(int cIndex);
                        virtual ~UnbindingTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {return cIndex;};
                protected:
                        int cIndex;
        };

        class AddMoleculeTransform : public Transformation {
                public:
                        AddMoleculeTransform(SpeciesCreator *sc);
                        virtual ~AddMoleculeTransform();
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {cerr<<"You should not get a component index from an AddMoleculeTransform!!"<<endl; return -1;};
                protected:
                        SpeciesCreator *sc;
        };

        class RemoveMoleculeTransform : public Transformation {
                public:
                        RemoveMoleculeTransform(int removalType);
                        virtual ~RemoveMoleculeTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {cout<<"You should not get a component index from a RemoveMoleculeTransform!!"<<endl; exit(1); return -1;};
                        virtual int getRemovalType() { return removalType; };

                protected:
                        int removalType;

        };




        class IncrementStateTransform : public Transformation {
                public:
                        IncrementStateTransform(unsigned int stateIndex);
                        virtual ~IncrementStateTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {return cIndex;};
                protected:
                        int cIndex;
        };

        class DecrementStateTransform : public Transformation {
                public:
                        DecrementStateTransform(unsigned int stateIndex);
                        virtual ~DecrementStateTransform() {};
                        virtual void apply(Mapping *m, MappingSet **ms);
                        virtual int getComponentIndex() const {return cIndex;};
                protected:
                        int cIndex;
        };



}







#endif /*TRANSFORMATION_HH_*/

---