main page namespaces classes files
ELL home

src/ell/rna/S_RNAfe_SingleM.hh

Go to the documentation of this file.

#ifndef RNAFREEENERGYSINGLEMOVESTATE_HH_
#define RNAFREEENERGYSINGLEMOVESTATE_HH_


#include "ell/State.hh"
#include "ell/rna/RNAFreeEnergy.hh"

namespace ell
{
    class S_RNAfe_SingleM : public State
    {
    protected:  
        typedef RNAFreeEnergy::SingleMove   SingleMove;

        class NeighborList : public State::NeighborList
        {
        protected:
            const S_RNAfe_SingleM* const origin;

        public:
            class ItState : public State::NeighborList::ItState
            {
            public:
                SingleMove  lastMove;

                ItState() : lastMove() {}
                ItState(const ItState &itstate)
                 : lastMove(itstate.lastMove) {}
                virtual ~ItState() {}

                virtual ItState* clone() const {
                    return new ItState(*this);
                }
            };

            NeighborList(const S_RNAfe_SingleM* _origin);
            
            virtual ~NeighborList();

            virtual State* first(State::NeighborList::ItState** itstate) const;
                         
            virtual State* next(    State::NeighborList::ItState* itstate, 
                                    State* elem) const;
        };

        class RandomNeighborList : public State::NeighborList
        {
        public:
            class ItState;
            
        protected:
            const S_RNAfe_SingleM* const origin;

            void    switchMode(ItState* itstate) const;
            
        public:
            class ItState : public State::NeighborList::ItState
            {
            public:
                static const size_t SWITCH_MODE_THRESHOLD;
                
                size_t switchModeValue;
                
                std::set<SingleMove> chosenMoves;
                
                std::vector<SingleMove> unchosenValidMoves;

                ItState() : switchModeValue(SWITCH_MODE_THRESHOLD),
                            chosenMoves(),
                            unchosenValidMoves()
                {}
                
                ItState(const ItState &itstate) 
                    : switchModeValue(itstate.switchModeValue),
                      chosenMoves(itstate.chosenMoves),
                      unchosenValidMoves(itstate.unchosenValidMoves)
                {}
                
                virtual ~ItState() 
                {}

                virtual ItState* clone() const {
                    return new ItState(*this);
                }
            };

            RandomNeighborList(const S_RNAfe_SingleM* _origin);
            
            virtual ~RandomNeighborList();

            virtual State* first(State::NeighborList::ItState** itstate) const;
                         
            virtual State* next(    State::NeighborList::ItState* itstate, 
                                    State* elem) const;
        };

        RNAFreeEnergy rnaFreeEnergy;

        biu::Alphabet::AlphElem open;
        biu::Alphabet::AlphElem none;
        biu::Alphabet::AlphElem close;

        SingleMove  firstValidSingleMove() const;
        
        SingleMove nextValidSingleMove(const SingleMove lastSingleMove) const;
        
        SingleMove searchForNextValidSingleMove(size_t pos1,
                                            size_t pos2) const;
    
    public:
        S_RNAfe_SingleM(    const std::string& rnaSeqStr,
                            const std::string& rnaStructBracketNotStr);
        
        S_RNAfe_SingleM(    const RNAFreeEnergy& rna );
                
        S_RNAfe_SingleM( 
                        const S_RNAfe_SingleM& rnaFESMS);
                        
        virtual ~S_RNAfe_SingleM();

    // abstract functions (State)
        virtual bool    operator== (const State& state2) const;
        virtual bool    operator!= (const State& state2) const;

        virtual int getFitness() const;
        
        virtual double      getEnergy() const;
        
        virtual unsigned int    getMinimalDistance(const State& state2) const;
        
        virtual S_RNAfe_SingleM*    clone() const;
        
        virtual State* fromString(const std::string& stringRep) const;          
        
        virtual std::string toString() const;

        virtual NeighborListPtr getNeighborList() const;
        
        virtual NeighborListPtr getRandomNeighborList() const;
        
        virtual State*  getRandomNeighbor(State* inPlaceNeigh = NULL) const;

        
        virtual CSequence compress(void) const ;
        
        virtual CSequence& compress(CSequence& toFill) const;
        
        virtual State* uncompress(const CSequence& cseq, State* toFill) const;
        
        virtual State* uncompress(const CSequence& cseq);
        
        
    };

} // namespace ell

#endif /*RNAFREEENERGYSINGLEMOVESTATE_HH_*/