OutputHandlerCsv.h

Go to the documentation of this file.

 
#ifndef INTARNA_OUTPUTHANDLERCSV_H_
#define INTARNA_OUTPUTHANDLERCSV_H_
 
#include "IntaRNA/general.h"
 
#include "IntaRNA/OutputConstraint.h"
#include "IntaRNA/OutputHandler.h"
#include "IntaRNA/InteractionEnergy.h"
 
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <utility>
 
#include <boost/algorithm/string.hpp>
 
namespace IntaRNA {
 
class OutputHandlerCsv : public OutputHandler
{
 
public:
 
    static const std::string notAvailable;
 
 
    enum ColType {
        id1 = 0, 
        id2, 
        seq1, 
        seq2, 
        subseq1, 
        subseq2, 
        subseqDP, 
        subseqDB, 
        start1, 
        end1, 
        start2, 
        end2, 
        hybridDP, 
        hybridDB, 
        hybridDPfull, 
        hybridDBfull, 
        bpList, 
        E, 
        Etotal, 
        ED1, 
        ED2, 
        Pu1, 
        Pu2, 
        E_init, 
        E_loops, 
        E_dangleL, 
        E_dangleR, 
        E_endL, 
        E_endR, 
        E_hybrid, 
        E_norm, 
        E_hybridNorm, 
        E_add, 
        seedStart1, 
        seedEnd1, 
        seedStart2, 
        seedEnd2, 
        seedE, 
        seedED1, 
        seedED2, 
        seedPu1, 
        seedPu2, 
        w, 
        // output only available if Zall was computed (outConstraint.needZall)
        Eall, 
        Eall1, 
        Eall2, 
        Zall, 
        Zall1, 
        Zall2, 
        EallTotal, 
        P_E, 
        RT, 
        ColTypeNumber 
    };
 
    typedef std::list<ColType> ColTypeList;
 
    static const ColTypeList colTypeNumericSort;
 
    static
    const std::map<ColType,std::string> &
    getColType2string();
 
protected:
 
    static std::map<ColType,std::string> colType2string;
 
    static
    void
    initColType2string() {
        if (colType2string.empty()) {
            // fill container : ensure strings are non-redundant!
            colType2string[id1] = "id1";
            colType2string[id2] = "id2";
            colType2string[seq1] = "seq1";
            colType2string[seq2] = "seq2";
            colType2string[start1] = "start1";
            colType2string[end1] = "end1";
            colType2string[start2] = "start2";
            colType2string[end2] = "end2";
            colType2string[subseq1] = "subseq1";
            colType2string[subseq2] = "subseq2";
            colType2string[subseqDP] = "subseqDP";
            colType2string[subseqDB] = "subseqDB";
            colType2string[hybridDP] = "hybridDP";
            colType2string[hybridDB] = "hybridDB";
            colType2string[hybridDPfull] = "hybridDPfull";
            colType2string[hybridDBfull] = "hybridDBfull";
            colType2string[bpList] = "bpList";
            colType2string[E] = "E";
            colType2string[Etotal] = "Etotal";
            colType2string[ED1] = "ED1";
            colType2string[ED2] = "ED2";
            colType2string[Pu1] = "Pu1";
            colType2string[Pu2] = "Pu2";
            colType2string[E_init] = "E_init";
            colType2string[E_loops] = "E_loops";
            colType2string[E_dangleL] = "E_dangleL";
            colType2string[E_dangleR] = "E_dangleR";
            colType2string[E_endL] = "E_endL";
            colType2string[E_endR] = "E_endR";
            colType2string[E_hybrid] = "E_hybrid";
            colType2string[E_norm] = "E_norm";
            colType2string[E_hybridNorm] = "E_hybridNorm";
            colType2string[E_add] = "E_add";
            colType2string[w] = "w";
            colType2string[seedStart1] = "seedStart1";
            colType2string[seedEnd1] = "seedEnd1";
            colType2string[seedStart2] = "seedStart2";
            colType2string[seedEnd2] = "seedEnd2";
            colType2string[seedE] = "seedE";
            colType2string[seedED1] = "seedED1";
            colType2string[seedED2] = "seedED2";
            colType2string[seedPu1] = "seedPu1";
            colType2string[seedPu2] = "seedPu2";
            colType2string[Eall] = "Eall";
            colType2string[Eall1] = "Eall1";
            colType2string[Eall2] = "Eall2";
            colType2string[EallTotal] = "EallTotal";
            colType2string[Zall] = "Zall";
            colType2string[Zall1] = "Zall1";
            colType2string[Zall2] = "Zall2";
            colType2string[P_E] = "P_E";
            colType2string[RT] = "RT";
            // ensure filling is complete
            for (size_t i=0; i<ColTypeNumber; i++) {
                if ( colType2string.find( static_cast<ColType>(i) ) == colType2string.end() ) {
                    throw std::runtime_error("OutputHandlerCsv::initColType2string() : ColType "+toString(i)+" without string representative");
                }
            }
        }
    }
 
public:
 
    OutputHandlerCsv( const OutputConstraint & outConstraint
                        , std::ostream & out
                        , const InteractionEnergy & energy
                        , const ColTypeList columns
                        , const std::string& colSep = ";"
                        , const bool printHeader = false
                        , const std::string& listSep = ":"
                        );
 
    virtual ~OutputHandlerCsv();
 
    virtual
    void
    add( const Interaction & interaction  );
 
    static
    std::string
    list2string( const ColTypeList & colTypes, const std::string & sep );
 
    static
    ColTypeList
    string2list( const std::string & listString );
 
    static
    bool
    needsZall( const ColTypeList & colTypes );
 
    static
    bool
    needBPs( const ColTypeList & colTypes );
 
    static
    std::string
    getHeader( const ColTypeList & colTypes, const std::string& colSep );
 
 
protected:
 
    using OutputHandler::Z;
 
    std::ostream & out;
 
    const InteractionEnergy & energy;
 
    const std::list< ColType > columns;
 
    std::string colSep;
 
    std::string listSep;
 
 
 
};
 
 
 
inline
const std::map<OutputHandlerCsv::ColType,std::string> &
OutputHandlerCsv::
getColType2string()
{
    return colType2string;
}
 
 
inline
std::string
OutputHandlerCsv::
list2string( const ColTypeList & colTypes, const std::string & sep )
{
    // init string encodings
    initColType2string();
 
    // lamda function to add next column to list
    auto addCol = [&](std::string a, ColType b) {
                     return std::move(a) + sep + colType2string[b];
                 };
 
    // generate full list
    return std::accumulate(std::next(colTypes.begin())
                        , colTypes.end()
                        , colType2string[*(colTypes.begin())] // start with first element
                        , addCol);
}
 
 
inline
OutputHandlerCsv::
ColTypeList
OutputHandlerCsv::
string2list( const std::string & stringEncoding )
{
    // init string encodings
    initColType2string();
 
    ColTypeList list;
    // empty string : give full list
    if (stringEncoding.empty() || stringEncoding == "*") {
        // generate list of all types
        for (size_t c = 0; c < (size_t)ColTypeNumber; c++) {
            list.push_back( static_cast<ColType>(c) );
        }
    }
    else {
        // find split position
        size_t startPos = 0, splitPos = std::string::npos;
        while (startPos != splitPos) {
            splitPos = stringEncoding.find(',',startPos);
            // get current type string
            std::string curTypeString = stringEncoding.substr(startPos,splitPos-(splitPos==std::string::npos?0:startPos));
            // trim leading/trailing whitespaces
            boost::trim(curTypeString);
            // try to find type encoding
            bool notFound = true;
            for (auto it = colType2string.begin(); notFound && it != colType2string.end(); it++ ) {
                // check if type found (case insensitive for being user friendly
                if ( boost::iequals( it->second, curTypeString) ) {
                    list.push_back( it->first );
                    notFound = false;
                }
            }
            // check if error to be raised
            if (notFound) {
                throw std::runtime_error("OutputHandlerCsv::string2list("+stringEncoding+") contains unsupported ColType encoding '"+curTypeString+"'");
            }
            // update start of next interval encoding to parse
            startPos = splitPos + (splitPos != std::string::npos ? 1 : 0);
        }
    }
    return list;
}
 
 
inline
bool
OutputHandlerCsv::
needsZall( const ColTypeList & colTypes )
{
    for ( const auto& type : colTypes ) {
        // check if type requires Zall computation
        switch ( type ) {
            case Eall:
            case EallTotal:
            case Zall:
            case P_E:
                return true;
            default: // ignore all other types
                break;
        }
    }
    return false;
}
 
 
inline
bool
OutputHandlerCsv::
needBPs( const ColTypeList & colTypes )
{
    for ( const auto& type : colTypes ) {
        // check if type requires Zall computation
        switch ( type ) {
            case hybridDB:
            case hybridDBfull:
            case hybridDP:
            case hybridDPfull:
            case bpList:
                return true;
            default: // ignore all other types
                break;
        }
    }
    return false;
}
 
 
inline
std::string
OutputHandlerCsv::
getHeader( const OutputHandlerCsv::ColTypeList & colList, const std::string& colSep )
{
    // return string
    return list2string( colList, colSep ) + "\n";
}
 
 
} // namespace
 
#endif /* OUTPUTHANDLERCSV_H_ */