main page namespaces classes files
BIU home

src/biu/PullMoveSet.hh

Go to the documentation of this file.

#ifndef PULLMOVESET_HH_
#define PULLMOVESET_HH_

#include "LatticeMoveSet.hh"
#include "LatticeProtein.hh"
#include <vector>

namespace biu
{

class PullMoveSet : public LatticeMoveSet
{
public:
    class PullMoveDecoder 
    {
    protected:
        const biu::LatticeModel* const lattice;
        
        IPointVec neighDirections;      

        std::vector< std::vector< IPointVec > > stdPulls;
        
        std::vector< IPointVec > endPulls;
        
        size_t directionNumber;
        
        size_t stdPullNumber;
        size_t endPullNumber;
        
    public:
        PullMoveDecoder(const LatticeModel* const lattice);
        
        void lookupMove(const size_t& proteinLength, 
                size_t& moveIndex, bool& pullFront, 
                bool& stdPull, size_t& movePosition) const;
        IPointVec lookupStdMove(const IntPoint& rootpoint, 
                const IntPoint& fixpoint, 
                const size_t& moveIndex) const;
        
        IPointVec lookupEndMove(const IntPoint& rootpoint,
                const size_t& moveIndex) const;
        
        size_t getMoveNumber(const size_t proteinLength) const; 
        
        const LatticeModel* const getLattice(void) const;
    };
    
private:
    class RelativeInt
    {
    private:
        class Operators {
        public:
            virtual ~Operators() {}
            
            virtual const int add(const int& a, const int& b) const = 0;
            
            virtual const int sub(const int& a, const int& b) const = 0;
            
            virtual const bool largerEq(const int& a, const int& b) const = 0;
            
            virtual const bool smallerEq(const int& a, const int& b) const = 0;
        };
        
        class StdOps : public Operators {
        public:
            virtual const int add(const int& a, const int& b) const 
                { return a + b; }
            virtual const int sub(const int& a, const int& b) const
                { return a - b; }
            virtual const bool largerEq(const int& a, const int& b) const 
                { return a >= b; }
            virtual const bool smallerEq(const int& a, const int& b) const 
                { return a <= b; }
        };
        
        class InvOps : public Operators {
            virtual const int add(const int& a, const int& b) const 
                { return a - b; }
            virtual const int sub(const int& a, const int& b) const 
                { return a + b; }
            virtual const bool largerEq(const int& a, const int& b) const 
                { return a <= b; }
            virtual const bool smallerEq(const int& a, const int& b) const 
                { return a >= b; }
        };

        Operators* ops;
        int value;
        
    public:
        RelativeInt(int _value, bool direction) : value(_value) {
            if (direction)
                ops=new PullMoveSet::RelativeInt::StdOps();
            else
                ops=new PullMoveSet::RelativeInt::InvOps();
        }
        
        ~RelativeInt() { delete ops; }
        
        const bool
        operator >= (const int& y) const { return ops->largerEq(value,y); }
        
        const bool
        operator <= (const int& y) const { return ops->smallerEq(value,y); }    
        
        const int
        operator+ (const int& y) const { return ops->add(value,y); }
        
        const int
        operator- (const int& y) const { return ops->sub(value,y); }
        
        void
        operator --(int) { value = ops->sub(value,1); }
        
        void
        operator ++(int) { value = ops->add(value,1); }
        
        const int
        getValue() const { return value; };
    };
    
protected:
    struct UndoRecord
    {
        LatticeProtein* lastChangedObject;
        bool hasChanged;
        bool pullFront;
        size_t position;
        size_t lastPullPosition;
        IntPoint lostPos0;
        IntPoint lostPos1;
    } undoRec;
    
    PullMoveSet::PullMoveDecoder* decoder;
    
    const bool decoderIsShared;
    
public:

    PullMoveSet(const LatticeModel* lattice); 
    
    PullMoveSet(PullMoveDecoder* decoder, const bool decoderIsShared);
    
    PullMoveSet(const PullMoveSet& moveSet);
    PullMoveSet& operator=(const PullMoveSet& moveSet2);
    
    PullMoveSet* clone();

    virtual ~PullMoveSet();

    virtual LatticeProtein* applyMove(const LatticeProtein* const todo, 
            const size_t moveIndex);

    virtual LatticeProtein* applyMoveInPlace(LatticeProtein* const todo, 
            const size_t moveIndex);

    size_t getMoveNumber ( const LatticeProtein* const lp) const; 

    virtual LatticeProtein* undoLastMove(LatticeProtein* toUndo);
    
    virtual const PullMoveDecoder* const getDecoder(void) const;
};

} // end namespace biu

#endif /*PULLMOVESET_HH_*/