OutputHandler.h

Go to the documentation of this file.

 
#ifndef INTARNA_OUTPUTHANDLER_H_
#define INTARNA_OUTPUTHANDLER_H_
 
#include "IntaRNA/general.h"
#include "IntaRNA/PartitionArithmetic.h"
#include "IntaRNA/Interaction.h"
#include "IntaRNA/InteractionRange.h"
#include "IntaRNA/OutputConstraint.h"
#include <string>
#include <exception>
 
namespace IntaRNA {
 
class OutputHandler {
 
public:
 
    OutputHandler( const OutputConstraint & outConstraint );
 
    virtual ~OutputHandler();
 
 
    virtual
    void
    add( const Interaction & interaction ) = 0;
 
    virtual
    size_t
    reported() const;
 
 
    static
    std::string
    reverse( const std::string & str );
 
    virtual
    void
    incrementZ( const Z_type subZ );
 
    virtual
    Z_type
    getZ() const;
 
    const OutputConstraint &
    getOutputConstraint() const;
 
 
    virtual void setExactPartition(bool exact);
    bool usesExactPartition() const;
    bool hasNonzeroZ() const;
 
protected:
    bool exactPartition = false;
 
    const OutputConstraint outConstraint;
 
    size_t reportedInteractions;
 
    Z_type Z;
 
};
 
 
 
inline
OutputHandler::OutputHandler( const OutputConstraint & outConstraint )
    : outConstraint(outConstraint)
    , reportedInteractions(0)
    , Z(0)
{
}
 
 
inline
OutputHandler::~OutputHandler() {
}
 
 
inline
std::string
OutputHandler::
reverse( const std::string & str )
{
    return std::string(str.rbegin(), str.rend());
}
 
 
inline
size_t
OutputHandler::
reported() const
{
    return reportedInteractions;
}
 
 
inline
Z_type
OutputHandler::
getZ() const
{
    return Z;
}
 
 
inline
const OutputConstraint &
OutputHandler::
getOutputConstraint() const
{
    return outConstraint;
}
 
 
inline
void
OutputHandler::
incrementZ( const Z_type subZ )
{
#if INTARNA_IN_DEBUG_MODE
    if (std::numeric_limits<Z_type>::max() - subZ <= Z) {
        LOG(WARNING) <<"OutputHandler::incrementZ() : partition function overflow! Recompile with larger partition function data type!";
    }
#endif
    // Capture range failures within the OpenMP structured block.
    std::exception_ptr failure;
#if INTARNA_MULITHREADING
    #pragma omp critical(intarna_omp_outputHandlerIncrementZ)
#endif
    {
        try { Z = exactPartition ? PartitionArithmetic::add(Z,subZ) : Z+subZ; }
        catch (...) { failure=std::current_exception(); }
    }
    if (failure) std::rethrow_exception(failure);
}
 
 
inline void OutputHandler::setExactPartition(bool exact) { exactPartition=exact; }
inline bool OutputHandler::usesExactPartition() const { return exactPartition; }
inline bool OutputHandler::hasNonzeroZ() const { return exactPartition ? getZ()!=0 : !Z_equal(getZ(),Z_type(0)); }
 
} // namespace
 
#endif /* OUTPUTHANDLER_H_ */