main page namespaces classes files
ELL home

src/ell/protein/S_LP_PullM.cc

Go to the documentation of this file.

#include "ell/State.hh"
#include "ell/protein/S_LP_PullM.hh"
#include <biu/LatticeProtein_Ipnt.hh>
#include <biu/PullMoveSet.hh>
#include <biu/LatticeDescriptorCUB.hh>
#include <biu/assertbiu.hh>

namespace ell
{

const std::string S_LP_PullM::ID = std::string("ell::S_LP_PullM");

// TODO maybe better to replace pointer copy with real clone to avoid dependency to external data
// inconsistency to copy construction 
S_LP_PullM::S_LP_PullM(     biu::LatticeProtein_I* _latProt,
                            biu::LatticeMoveSet* _moveSet)
    : S_LP(_latProt, _moveSet)
    {}

S_LP_PullM::S_LP_PullM( const S_LP_PullM& s)
    : S_LP( s.latProt->clone(), s.moveSet->clone() )
    {}

S_LP_PullM::~S_LP_PullM()
    {}

const std::string & 
S_LP_PullM::getID( void ) const {
    return S_LP_PullM::ID; 
}


S_LP_PullM* 
S_LP_PullM::clone(State* toFill) const
{
    assertbiu(latProt != NULL , "no lattice protein (NULL)");
    assertbiu(moveSet != NULL , "no move set (NULL)");
    if (toFill == NULL) {
        return new S_LP_PullM(*this);
    }
      // cast toFill
    assertbiu(dynamic_cast<S_LP_PullM*>(toFill) != NULL
                , "toFill is no instance of S_LP_PullM");
    S_LP_PullM* s = static_cast<S_LP_PullM*>(toFill);
      // copy data
    s->latProt->operator=(*(this->latProt));
      // TODO replace with copying instead of destruction and new allocation !
    delete s->moveSet;
    s->moveSet = this->moveSet->clone();

    return s;
}

State* 
S_LP_PullM::fromString(const std::string& stringRep) const {
    return new S_LP_PullM(this->latProt->fromString(stringRep), 
                            this->moveSet->clone());
}



    
        /* Access to a compressed sequence representation of the state.
         * @return the compressed sequence representation
         */
    CSequence  
    S_LP_PullM::compress(void) const {
        return latProt->getLatticeModel()->getDescriptor()->
                    getAlphabet()->compress(latProt->getMoveSeqAbs());
    }
    
        /* Access to a compressed sequence representation of the state.
         * @param toFill a data structure to write the compressed 
         *               representation too
         * @return the compressed sequence representation
         */
    CSequence&  
    S_LP_PullM::compress(CSequence& toFill) const {
        toFill = latProt->getLatticeModel()->getDescriptor()->
                    getAlphabet()->compress(latProt->getMoveSeqAbs());
        return toFill;
    }
    
        /* Uncompresses a compressed sequence representation into a new
         * State object.
         * @param cseq the compressed sequence representation of a state
         * @param toFill a state object to uncompress too or NULL if a new 
         *               object has to be created
         * @return new State object that is encoded in cseq or NULL in error
         *         case.
         */
    State*  
    S_LP_PullM::uncompress(const CSequence& cseq, State* toFill) const {
        
        const std::string newSeq =
            latProt->getLatticeModel()->getString(
                    latProt->getLatticeModel()->getDescriptor()->
                    getAlphabet()->decompress(cseq, latProt->getLength()-1));
        
        if (toFill==NULL) {
            // create new object
            biu::LatticeProtein_I* newProt = latProt->clone();
            newProt->setMoveStrAbs(newSeq);
            toFill = new S_LP_PullM(newProt, moveSet->clone());
        }
        else
        {
            S_LP_PullM* s = dynamic_cast<S_LP_PullM*>(toFill);
            assertbiu(s != NULL, "casting to S_LP_PullM failed");
            s->latProt->setMoveStrAbs(newSeq);
            toFill = s;
        }
        
        return toFill;
    }
    
        /* Uncompresses a compressed sequence representation into a this
         * State object.
         * @param cseq the compressed sequence representation of a state
         * @return this or NULL in error case
         */
    State*  
    S_LP_PullM::uncompress(const CSequence& cseq) {
        return uncompress(cseq, this);
    }

} // namespace ell