PredictionTrackerHub.h

Go to the documentation of this file.

 
#ifndef INTARNA_PREDICTIONTRACKERHUB_H_
#define INTARNA_PREDICTIONTRACKERHUB_H_
 
#include "IntaRNA/PredictionTracker.h"
 
#include <list>
 
namespace IntaRNA {
 
class PredictionTrackerHub: public PredictionTracker
{
protected:
 
    std::list< PredictionTracker * > trackList;
 
    bool deleteTrackListOnDestruction;
 
public:
 
    PredictionTrackerHub( const bool deleteTrackListOnDestruction = true );
 
    PredictionTrackerHub( const PredictionTrackerHub & toCopy );
 
 
    virtual ~PredictionTrackerHub();
 
    virtual
    void
    updateOptimumCalled( const size_t i1, const size_t j1
                        , const size_t i2, const size_t j2
                        , const E_type energy
                        );
 
    virtual
    void
    addPredictionTracker( PredictionTracker * tracker );
 
    virtual
    void
    setDeleteOnDestruction( const bool deleteOnDestruction );
 
    virtual
    bool
    isDeleteOnDestruction() const;
 
 
    PredictionTrackerHub &
    operator= ( const PredictionTrackerHub & toCopy);
 
 
    bool
    empty() const;
 
};
 
 
 
inline
PredictionTrackerHub
::PredictionTrackerHub( const bool deleteOnDestruction )
 : PredictionTracker()
    , trackList()
    , deleteTrackListOnDestruction(deleteOnDestruction)
{
}
 
 
inline
PredictionTrackerHub
::PredictionTrackerHub( const PredictionTrackerHub & toCopy )
 : PredictionTracker()
    , trackList( toCopy.trackList )
    // dont delete on destruction (should be done by original) to avoid double cleanup
    , deleteTrackListOnDestruction(false)
{
}
 
 
inline
PredictionTrackerHub::
~PredictionTrackerHub()
{
    // check if something is to be done
    if (isDeleteOnDestruction()) {
        // delete all tracker
        for( auto it = trackList.begin(); it != trackList.end(); it++ ) {
             INTARNA_CLEANUP( (*it) );
        }
    }
}
 
 
 
 
inline
void
PredictionTrackerHub::
addPredictionTracker( PredictionTracker * tracker )
{
#if INTARNA_IN_DEBUG_MODE
    if (tracker != NULL) {
        // check if already present
        for (auto it=trackList.begin(); it!=trackList.end(); it++) {
            if (tracker == (*it)) {
                throw std::runtime_error("PredictionTrackerHub::addPredictionTracker() : repeated adding of the same PredictionTracker pointer");
            }
        }
    }
#endif
    // add if not null
    if (tracker != NULL) {
        trackList.push_back(tracker);
    }
}
 
 
inline
void
PredictionTrackerHub::
updateOptimumCalled( const size_t i1, const size_t j1
                    , const size_t i2, const size_t j2
                    , const E_type energy
                    )
{
    // forward to all in list
    for (auto trackIt=trackList.begin(); trackIt!=trackList.end(); trackIt++) {
        (*trackIt)->updateOptimumCalled(i1,j1,i2,j2,energy);
    }
}
 
 
inline
void
PredictionTrackerHub::
setDeleteOnDestruction( const bool deleteOnDestruction )
{
    this->deleteTrackListOnDestruction = deleteOnDestruction;
}
 
 
inline
bool
PredictionTrackerHub::
isDeleteOnDestruction() const
{
    return this->deleteTrackListOnDestruction;
}
 
 
inline
PredictionTrackerHub &
PredictionTrackerHub::
operator= ( const PredictionTrackerHub & toCopy)
{
    // clean up current content
    if (this->deleteTrackListOnDestruction) {
        for (auto it=trackList.begin(); it!=trackList.end(); it++) {
             INTARNA_CLEANUP( (*it) );
        }
    }
    trackList.clear();
 
    // copy data
    trackList = toCopy.trackList;
    // ensure this copy doesnt delete the list content
    deleteTrackListOnDestruction = false;
 
    // modified object access
    return *this;
}
 
 
inline
bool
PredictionTrackerHub::
empty() const
{
    // return whether or not the tracker list is empty
    return trackList.empty();
}
 
 
} // namespace
 
#endif /* PREDICTIONTRACKERHUB_H_ */