main page namespaces classes files
ELL home

src/ell/State.hh

Go to the documentation of this file.

#ifndef STATE_H_
#define STATE_H_

#include <memory>
#include <string>
#include <limits.h>
#include <biu/VirtualList.hh>
#include <biu/Alphabet.hh>

namespace ell
{
    
    typedef biu::Alphabet::CSequence CSequence; 
    class State
    {
    public:
        // TYPEDEFs
    
        typedef biu::VirtualList<State> NeighborList;
        
        typedef std::auto_ptr<NeighborList> NeighborListPtr;

        State()
        {}
        
        virtual ~State()
        {}
        
        virtual const std::string& getID( void ) const = 0;
        
        virtual bool            operator== (const State& state2) const = 0;
        virtual bool            operator!= (const State& state2) const = 0;
        
        virtual bool            operator< (const State& state2) const;

        static
        bool less(const State* s1, const State* s2);
        
        virtual double      getEnergy() const = 0;
        
        virtual unsigned int    getMinimalDistance(const State& state2) const = 0;
        
        virtual State*  clone( State* toFill = NULL) const = 0;
        
        virtual State* fromString(const std::string& stringRep) const = 0;
        
        virtual std::string toString() const = 0;

        virtual std::string& toString( std::string & toFill ) const = 0;

        // neighborhood
        virtual NeighborListPtr getNeighborList() const = 0;

        virtual NeighborListPtr getRandomNeighborList() const = 0;

        virtual State* getRandomNeighbor(State* inPlaceNeigh = NULL) const = 0;
        
        
        virtual CSequence compress(void) const = 0;
        
        virtual CSequence& compress(CSequence& toFill) const = 0;
        
        virtual State* uncompress(const CSequence& cseq, State* toFill ) const = 0;
        
        virtual State* uncompress(const CSequence& cseq) = 0;
        
    };

}

#include <biu/assertbiu.hh>

namespace ell {

    inline
    bool
    State::
	operator< (const State& state2) const
    {
          // check if same object
        if (this == &state2)
            return false;
          // check if 
          // - smaller energy or
          // - equal energy and smaller string representation
        return ( this->getEnergy() < state2.getEnergy() )
                || ( this->getEnergy() == state2.getEnergy()
                    && this->toString().compare(state2.toString()) < 0 );
    }
    
    inline
    bool
    State::
	less(const State* s1, const State* s2)
    {
        assertbiu( s1 != NULL, "no state s1 given (NULL)");
        assertbiu( s2 != NULL, "no state s2 given (NULL)");
        
        return s1->operator <( *s2 );
    }
}



#endif /*STATE_H_*/