OutputHandlerHub.h

Go to the documentation of this file.

 
#ifndef INTARNA_OUTPUTHANDLERHUB_H_
#define INTARNA_OUTPUTHANDLERHUB_H_
 
#include "IntaRNA/OutputHandler.h"
 
#include <list>
 
namespace IntaRNA {
 
class OutputHandlerHub: public OutputHandler
{
protected:
 
    std::list< OutputHandler * > outList;
 
    bool deleteOutListOnDestruction;
 
public:
 
    void setExactPartition(bool exact) override;
 
    OutputHandlerHub( const OutputConstraint & outConstraint
                    , const bool deleteOutListOnDestruction = true );
 
    OutputHandlerHub( const OutputHandlerHub & toCopy );
 
 
    virtual ~OutputHandlerHub() override;
 
 
    virtual
    void
    add( const Interaction & interaction  ) override;
 
    virtual
    size_t
    reported() const override;
 
    virtual
    void
    incrementZ( const Z_type subZ ) override;
 
    virtual
    Z_type
    getZ() const override;
 
    virtual
    void
    addOutputHandler( OutputHandler * handler );
 
    virtual
    void
    setDeleteOnDestruction( const bool deleteOnDestruction );
 
    virtual
    bool
    isDeleteOnDestruction() const;
 
 
    OutputHandlerHub &
    operator= ( const OutputHandlerHub & toCopy);
 
 
};
 
 
 
inline
OutputHandlerHub
::OutputHandlerHub( const OutputConstraint & outConstraint
                    , const bool deleteOnDestruction )
 : OutputHandler(outConstraint)
    , outList()
    , deleteOutListOnDestruction(deleteOnDestruction)
{
}
 
 
inline
OutputHandlerHub
::OutputHandlerHub( const OutputHandlerHub & toCopy )
 : OutputHandler( toCopy.outConstraint )
    , outList( toCopy.outList )
    // dont delete on destruction (should be done by original) to avoid double cleanup
    , deleteOutListOnDestruction(false)
{
    exactPartition=toCopy.exactPartition;
}
 
 
inline
OutputHandlerHub::
~OutputHandlerHub()
{
    // check if something is to be done
    if (isDeleteOnDestruction()) {
        // delete all handler
        for( auto it = outList.begin(); it != outList.end(); it++ ) {
             INTARNA_CLEANUP( (*it) );
        }
    }
}
 
 
 
 
inline
void
OutputHandlerHub::
addOutputHandler( OutputHandler * handler )
{
#if INTARNA_IN_DEBUG_MODE
    if (handler != NULL) {
        // check if already present
        for (auto it=outList.begin(); it!=outList.end(); it++) {
            if (handler == (*it)) {
                throw std::runtime_error("OutputHandlerHub::addOutputHandler() : repeated adding of the same OutputHandler pointer");
            }
        }
    }
#endif
    // add if not null
    if (handler != NULL) {
        handler->setExactPartition(usesExactPartition());
        outList.push_back(handler);
    }
}
 
 
inline
void
OutputHandlerHub::
add( const Interaction & inter )
{
    // forward to all in list
    for (auto it=outList.begin(); it!=outList.end(); it++) {
        (*it)->add(inter);
    }
}
 
 
inline
size_t
OutputHandlerHub::
reported() const
{
    size_t maxReported = 0;
    // get maximal number of reports among all handlers
    for (auto it=outList.begin(); it!=outList.end(); it++) {
        maxReported = std::max( maxReported, (*it)->reported() );
    }
    // return maximum
    return maxReported;
}
 
 
inline
void
OutputHandlerHub::
incrementZ( const Z_type subZ )
{
    // forward to all in list
    for (auto it=outList.begin(); it!=outList.end(); it++) {
        (*it)->incrementZ(subZ);
    }
}
 
 
inline
Z_type
OutputHandlerHub::
getZ( ) const
{
    Z_type maxZ = 0;
    // find max from all in list
    for (auto it=outList.begin(); it!=outList.end(); it++) {
        if ((*it)->getZ() > maxZ) {
            maxZ = (*it)->getZ();
        }
    }
    return maxZ;
}
 
 
inline
void
OutputHandlerHub::
setDeleteOnDestruction( const bool deleteOnDestruction )
{
    this->deleteOutListOnDestruction = deleteOnDestruction;
}
 
 
inline
bool
OutputHandlerHub::
isDeleteOnDestruction() const
{
    return this->deleteOutListOnDestruction;
}
 
 
inline
OutputHandlerHub &
OutputHandlerHub::
operator= ( const OutputHandlerHub & toCopy)
{
    // clean up current content
    if (this->deleteOutListOnDestruction) {
        for (auto it=outList.begin(); it!=outList.end(); it++) {
             INTARNA_CLEANUP( (*it) );
        }
    }
    outList.clear();
 
    // copy data
    exactPartition=toCopy.exactPartition;
    outList = toCopy.outList;
    // ensure this copy doesnt delete the list content
    deleteOutListOnDestruction = false;
 
    // modified object access
    return *this;
}
 
 
inline void OutputHandlerHub::setExactPartition(bool exact) {
    OutputHandler::setExactPartition(exact);
    for (auto handler:outList) handler->setExactPartition(exact);
}
 
} // namespace
 
#endif /* OUTPUTHANDLERHUB_H_ */