main page namespaces classes files
ELL home

src/ell/rna/S_RNAfe_SingleM_TB.hh

Go to the documentation of this file.

#ifndef RNAFREEENERGYSINGLEMOVESTATE_TB_HH_
#define RNAFREEENERGYSINGLEMOVESTATE_TB_HH_


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

namespace ell
{
    class S_RNAfe_SingleM_TB : public State
    {
    protected:  
        typedef RNAFreeEnergy_TB::SingleMove    SingleMove;

        class NeighborList : public State::NeighborList
        {
        protected:
            const S_RNAfe_SingleM_TB* 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_TB* _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_TB* 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_TB* _origin);
            
            virtual ~RandomNeighborList();

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

        RNAFreeEnergy_TB rnaFreeEnergy;

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

        SingleMove  firstValidSingleMove() const;
        
        SingleMove nextValidSingleMove(const SingleMove lastSingleMove) const;
        
//          /*! Searches for the next valid single move and starts
//           *  the search for the first move position at pos 1
//           *  and for the second move position at pos2.
//           *  If a move was found, it will be returned, otherwise
//           *  SingleMove(0,RNAStructure::INVALID_INDEX) will be returned.
//           */
//      SingleMove searchForNextValidSingleMove(size_t pos1,
//                                          size_t pos2) const;
    
    public:
        
        static const std::string ID;
        
        S_RNAfe_SingleM_TB( const std::string& rnaSeqStr,
                            const std::string& rnaStructBracketNotStr);
        
        S_RNAfe_SingleM_TB( const RNAFreeEnergy_TB& rna );
                
        S_RNAfe_SingleM_TB( const S_RNAfe_SingleM_TB& toCopy);
                        
        virtual ~S_RNAfe_SingleM_TB();
        
        virtual const std::string& getID( void ) const;


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

        
        virtual double      getEnergy() const;
        
        virtual unsigned int    getMinimalDistance(const State& state2) const;
        
        virtual S_RNAfe_SingleM_TB* clone(State* toFill = NULL) const;
        
        virtual State* fromString(const std::string& stringRep) const;          
        virtual State* fromString(  const std::string& stringRep
                                    , const double energy) const;           
        
        virtual std::string toString() const;
            
        virtual std::string& toString( std::string & toFill ) const;
        
        virtual std::string getSequence() const;
        
        virtual std::string getStructure() 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_TB_HH_*/