HelixHandlerIdxOffset.h

Go to the documentation of this file.

 
#ifndef INTARNA_HELIXHANDLERIDXOFFSET_H_
#define INTARNA_HELIXHANDLERIDXOFFSET_H_
 
#include "IntaRNA/HelixHandler.h"
#include "IntaRNA/SeedHandlerIdxOffset.h"
 
#include <boost/multi_array.hpp>
 
 
namespace IntaRNA {
 
class HelixHandlerIdxOffset : public HelixHandler
{
 
public:
 
    HelixHandlerIdxOffset( HelixHandler * helixHandler );
 
    virtual ~HelixHandlerIdxOffset();
 
    virtual
    const InteractionEnergy&
    getInteractionEnergy() const;
 
    size_t getOffset1() const;
 
    void setOffset1(size_t offset1);
 
    size_t getOffset2() const;
 
    void setOffset2(size_t offset2);
 
 
    virtual
    const HelixConstraint&
    getConstraint() const;
 
    virtual
    size_t
    fillHelix(const size_t i1, const size_t j1, const size_t i2, const size_t j2);
 
    virtual
    size_t
    fillHelixSeed(const size_t i1, const size_t j1, const size_t i2, const size_t j2);
 
    virtual
    void
    traceBackHelix( Interaction & interaction, const size_t i1, const size_t i2);
 
    virtual
    void
    traceBackHelixSeed( Interaction & interaction, const size_t i1, const size_t i2);
 
    virtual
    E_type
    getHelixE( const size_t i1, const size_t i2 ) const;
 
    virtual
    E_type
    getHelixSeedE( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixLength1( const size_t i1, const size_t i2 ) const;
 
 
    virtual
    size_t
    getHelixLength2( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixSeedLength1( const size_t i1, const size_t i2 ) const;
 
    virtual
    size_t
    getHelixSeedLength2( const size_t i1, const size_t i2 ) const;
 
    virtual
    void
    setSeedHandler( SeedHandler & seedHandler);
 
protected:
 
    HelixHandler * helixHandlerOriginal;
 
    HelixConstraint helixConstraintOffset;
 
    SeedHandlerIdxOffset * seedHandlerIdxOffset;
 
    size_t idxOffset1;
 
    size_t idxOffset2;
 
};
 
 
 
 
inline
HelixHandlerIdxOffset::
HelixHandlerIdxOffset( HelixHandler * helixHandlerInstance )
    :
        helixHandlerOriginal( helixHandlerInstance )
        , helixConstraintOffset( helixHandlerOriginal->getConstraint() )
        , idxOffset1(0)
        , idxOffset2(0)
        , seedHandlerIdxOffset(NULL)
{
 
}
 
 
inline
HelixHandlerIdxOffset::~HelixHandlerIdxOffset()
{
    if (helixHandlerOriginal != NULL) {
        delete helixHandlerOriginal;
        helixHandlerOriginal = NULL;
    }
}
 
 
inline
const InteractionEnergy&
HelixHandlerIdxOffset::
getInteractionEnergy() const
{
    return helixHandlerOriginal->getInteractionEnergy();
}
 
 
inline
const HelixConstraint&
HelixHandlerIdxOffset::
getConstraint() const
{
    return helixConstraintOffset;
}
 
 
inline
size_t
HelixHandlerIdxOffset::
fillHelix(const size_t i1min, const size_t i1max, const size_t i2min, const size_t i2max)
{
    return helixHandlerOriginal->fillHelix( i1min+idxOffset1, i1max+idxOffset1, i2min+idxOffset2, i2max+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
fillHelixSeed(const size_t i1min, const size_t i1max, const size_t i2min, const size_t i2max)
{
    return helixHandlerOriginal->fillHelixSeed( i1min+idxOffset1, i1max+idxOffset1, i2min+idxOffset2, i2max+idxOffset2 );
}
 
 
inline
void
HelixHandlerIdxOffset::
traceBackHelix(Interaction &interaction
        , const size_t i1
        , const size_t i2
        )
{
    helixHandlerOriginal->traceBackHelix( interaction, i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
void
HelixHandlerIdxOffset::
traceBackHelixSeed(Interaction &interaction
        , const size_t i1
        , const size_t i2
)
{
    helixHandlerOriginal->traceBackHelixSeed( interaction, i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
E_type
HelixHandlerIdxOffset::
getHelixE(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixE( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
E_type
HelixHandlerIdxOffset::
getHelixSeedE(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixSeedE( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getHelixLength1(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixLength1( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getHelixLength2(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixLength2( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getHelixSeedLength1(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixSeedLength1( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getHelixSeedLength2(const size_t i1, const size_t i2) const
{
    return helixHandlerOriginal->getHelixSeedLength2( i1+idxOffset1, i2+idxOffset2 );
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getOffset1() const
{
    return idxOffset1;
}
 
 
inline
size_t
HelixHandlerIdxOffset::
getOffset2() const
{
    return idxOffset2;
}
 
 
inline
void
HelixHandlerIdxOffset::
setOffset1( const size_t offset )
{
#if INTARNA_IN_DEBUG_MODE
    if (offset >= helixHandlerOriginal->getInteractionEnergy().size1()) {
        throw std::runtime_error("HelixHandlerIdxOffset.setOffset1("+toString(offset)
        +") offset > seq1.length "+toString(helixHandlerOriginal->getInteractionEnergy().size1()));
    }
#endif
    // set idx offset
    this->idxOffset1 = offset;
}
 
 
inline
void
HelixHandlerIdxOffset::
setOffset2( const size_t offset )
{
#if INTARNA_IN_DEBUG_MODE
    if (offset >= helixHandlerOriginal->getInteractionEnergy().size2()) {
        throw std::runtime_error("HelixHandlerIdxOffset.setOffset1("+toString(offset)
                                 +") offset > seq1.length "+toString(helixHandlerOriginal->getInteractionEnergy().size2()));
    }
#endif
    // set idx offset
    this->idxOffset2 = offset;
}
 
 
inline
void
HelixHandlerIdxOffset::
setSeedHandler(SeedHandler & seedHandler)
{
    // cast input
    SeedHandlerIdxOffset * shOffset = dynamic_cast<SeedHandlerIdxOffset*>(&seedHandler);
 
#if INTARNA_IN_DEBUG_MODE
    // sanity check
    if (shOffset == NULL) {
        throw std::runtime_error("HelixHandlerIdxOffset.setSeedHandler(). Given seedHandler is not of type SeedHandlerIdxOffset.");
    }
#endif
 
    // store locally (might be useful later)
    seedHandlerIdxOffset = shOffset;
 
    // forward seedHandler to helixHandler
    helixHandlerOriginal->setSeedHandler( shOffset->getOriginalSeedHandler());
}
 
} // namespace
#endif /* HELIXHANDLERIDXOFFSET_H_ */