SeedHandlerIdxOffset.h

Go to the documentation of this file.

 
#ifndef INTARNA_SEEDHANDLERIDXOFFSET_H_
#define INTARNA_SEEDHANDLERIDXOFFSET_H_
 
#include "IntaRNA/SeedHandler.h"
#include "IntaRNA/InteractionEnergyIdxOffset.h"
 
#include <boost/multi_array.hpp>
 
 
 
namespace IntaRNA {
 
class SeedHandlerIdxOffset : public SeedHandler
{
 
public:
 
    virtual bool guaranteesStackOnlySeeds() const override;
 
 
    SeedHandlerIdxOffset( SeedHandler * seedHandler
                , const bool deleteOnDestruction=true );
 
    virtual ~SeedHandlerIdxOffset() override;
 
    size_t getOffset1() const;
 
    void setOffset1(size_t offset1);
 
    size_t getOffset2() const;
 
    void setOffset2(size_t offset2);
 
 
 
 
    virtual
    const SeedConstraint&
    getConstraint() const override;
 
    virtual
    const InteractionEnergy&
    getInteractionEnergy() const override;
 
 
    virtual
    size_t
    fillSeed(const size_t i1, const size_t j1, const size_t i2, const size_t j2) override;
 
    virtual
    void
    traceBackSeed( Interaction & interaction, const size_t i1, const size_t i2) const override;
 
 
    virtual
    E_type
    getSeedE( const size_t i1, const size_t i2 ) const override;
 
    virtual
    bool
    isSeedBound( const size_t i1, const size_t i2 ) const override;
 
    virtual
    size_t
    getSeedLength1( const size_t i1, const size_t i2 ) const override;
 
    virtual
    size_t
    getSeedLength2( const size_t i1, const size_t i2 ) const override;
 
 
    virtual
    SeedHandler&
    getOriginalSeedHandler();
 
    virtual
    bool
    updateToNextSeed( size_t & i1, size_t & i2
            , const size_t i1min = 0, const size_t i1max = RnaSequence::lastPos
            , const size_t i2min = 0, const size_t i2max = RnaSequence::lastPos
            ) const override;
 
    virtual
    void
    addSeeds( Interaction & i ) const override;
 
    virtual
    bool
    areLoopOverlapping( const size_t i1, const size_t i2
                    , const size_t k1, const size_t k2 ) const override;
 
    virtual
    bool
    isFeasibleSeedBasePair( const size_t i1
                        , const size_t i2
                        , const bool atEndOfSeed = false ) const override;
 
protected:
 
    SeedHandler * seedHandlerOriginal;
 
    const bool deleteOnDestruction;
 
    SeedConstraint seedConstraintOffset;
 
    size_t idxOffset1;
 
    size_t idxOffset2;
 
    InteractionEnergyIdxOffset energyIdxOffset;
 
};
 
 
 
 
 
 
inline
SeedHandlerIdxOffset::
SeedHandlerIdxOffset( SeedHandler * seedHandlerInstance, const bool deleteOnDestruction )
    :
        SeedHandler(seedHandlerInstance->getInteractionEnergy(), seedHandlerInstance->getConstraint() )
        , seedHandlerOriginal( seedHandlerInstance )
        , deleteOnDestruction( deleteOnDestruction )
        , seedConstraintOffset( seedHandlerOriginal->getConstraint() )
        , idxOffset1(0)
        , idxOffset2(0)
        , energyIdxOffset(seedHandlerInstance->getInteractionEnergy(),idxOffset1,idxOffset2)
{
}
 
 
inline
SeedHandlerIdxOffset::~SeedHandlerIdxOffset()
{
    if (deleteOnDestruction && seedHandlerOriginal != NULL) {
        delete seedHandlerOriginal;
        seedHandlerOriginal = NULL;
    }
}
 
 
inline
const SeedConstraint&
SeedHandlerIdxOffset::
getConstraint() const
{
    return seedConstraintOffset;
}
 
 
inline
const InteractionEnergy&
SeedHandlerIdxOffset::
getInteractionEnergy() const
{
    return this->energyIdxOffset;
}
 
 
inline
size_t
SeedHandlerIdxOffset::
fillSeed( const size_t i1min, const size_t i1max, const size_t i2min, const size_t i2max)
{
    return seedHandlerOriginal->fillSeed( i1min+idxOffset1, i1max+idxOffset1, i2min+idxOffset2, i2max+idxOffset2 );
}
 
 
inline
void
SeedHandlerIdxOffset::
traceBackSeed( Interaction & interaction
        , const size_t i1
        , const size_t i2
        ) const
{
    seedHandlerOriginal->traceBackSeed( interaction, i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
E_type
SeedHandlerIdxOffset::
getSeedE( const size_t i1, const size_t i2 ) const
{
    return seedHandlerOriginal->getSeedE( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
bool
SeedHandlerIdxOffset::
isSeedBound( const size_t i1, const size_t i2 ) const
{
    return seedHandlerOriginal->isSeedBound( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
SeedHandlerIdxOffset::
getSeedLength1( const size_t i1, const size_t i2 ) const
{
    return seedHandlerOriginal->getSeedLength1( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
SeedHandlerIdxOffset::
getSeedLength2( const size_t i1, const size_t i2 ) const
{
    return seedHandlerOriginal->getSeedLength2( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
SeedHandlerIdxOffset::
getOffset1() const
{
    return idxOffset1;
}
 
 
inline
size_t
SeedHandlerIdxOffset::
getOffset2() const
{
    return idxOffset2;
}
 
 
inline
void
SeedHandlerIdxOffset::
setOffset1( const size_t offset )
{
#if INTARNA_IN_DEBUG_MODE
    if (offset >= seedHandlerOriginal->getInteractionEnergy().size1()) {
        throw std::runtime_error("SeedHandlerIdxOffset.setOffset1("+toString(offset)
                +") offset > seq1.length "+toString(seedHandlerOriginal->getInteractionEnergy().size1()));
    }
#endif
    // set idx offset
    this->idxOffset1 = offset;
    this->energyIdxOffset.setOffset1(idxOffset1);
    // update ranges of seed constraint
    seedConstraintOffset.getRanges1() = seedHandlerOriginal->getConstraint().getRanges1().shift( -(int)offset, seedHandlerOriginal->getInteractionEnergy().size1()-1-offset );
}
 
 
inline
void
SeedHandlerIdxOffset::
setOffset2( const size_t offset )
{
#if INTARNA_IN_DEBUG_MODE
    if (offset >= seedHandlerOriginal->getInteractionEnergy().size2()) {
        throw std::runtime_error("SeedHandlerIdxOffset.setOffset2("+toString(offset)
                +") offset > seq2.length "+toString(seedHandlerOriginal->getInteractionEnergy().size2()));
    }
#endif
    // set idx offset
    this->idxOffset2 = offset;
    this->energyIdxOffset.setOffset2(idxOffset2);
    // update ranges of seed constraint
    seedConstraintOffset.getRanges2() = seedHandlerOriginal->getConstraint().getRanges2().shift( -(int)offset, seedHandlerOriginal->getInteractionEnergy().size2()-1-offset );
}
 
 
inline
SeedHandler&
SeedHandlerIdxOffset::
getOriginalSeedHandler()
{
    return *seedHandlerOriginal;
}
 
 
inline
bool
SeedHandlerIdxOffset::
updateToNextSeed( size_t & i1_out, size_t & i2_out
        , const size_t i1min, const size_t i1max
        , const size_t i2min, const size_t i2max
        ) const
{
    size_t i1 = i1_out+idxOffset1, i2 = i2_out+idxOffset2;
 
    if (seedHandlerOriginal->updateToNextSeed( i1, i2
            , i1min+idxOffset1,(i1max<energy.size1()?i1max+idxOffset1:i1max)
            , i2min+idxOffset2,(i2max<energy.size2()?i2max+idxOffset2:i2max) ))
    {
        i1_out = i1-idxOffset1;
        i2_out = i2-idxOffset2;
        return true;
    }
    return false;
}
 
 
inline
void
SeedHandlerIdxOffset::
addSeeds( Interaction & i ) const
{
    seedHandlerOriginal->addSeeds(i);
}
 
 
inline
bool
SeedHandlerIdxOffset::
areLoopOverlapping( const size_t i1, const size_t i2
                , const size_t k1, const size_t k2 ) const
{
    return seedHandlerOriginal->areLoopOverlapping(i1+idxOffset1, i2+idxOffset2, k1+idxOffset1, k2+idxOffset2);
}
 
 
inline
bool
SeedHandlerIdxOffset::
isFeasibleSeedBasePair( const size_t i1
                    , const size_t i2
                    , const bool atEndOfSeed ) const
{
    return seedHandlerOriginal->isFeasibleSeedBasePair(i1+idxOffset1,i2+idxOffset2,atEndOfSeed);
}
 
 
inline bool
SeedHandlerIdxOffset::guaranteesStackOnlySeeds() const
{
    return seedHandlerOriginal->guaranteesStackOnlySeeds();
}
 
} // namespace
 
#endif /* SEEDHANDLERIDXOFFSET_H_ */