src/LocARNA/aux.hh

#ifndef LOCARNA_AUX_HH
#define LOCARNA_AUX_HH

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iosfwd>
#include <exception>
#include <string>
#include <vector>
#include <cassert>

#if __cplusplus < 201100L
#    define nullptr NULL
#endif

// import and define types for unordered_map/set
// in a way that is compatible with stdc++ and libc++
#ifdef _LIBCPP_VERSION
#include <unordered_map>
#include <unordered_set>
namespace LocARNA {
    template <class Key,                       // unordered_map::key_type
              class T,                         // unordered_map::mapped_type
              class Hash = std::hash<Key>,     // unordered_map::hasher
              class Pred = std::equal_to<Key>, // unordered_map::key_equal
              class Alloc = std::allocator<
                  std::pair<const Key, T> > // unordered_map::allocator_type
              >
    struct unordered_map {
        typedef std::unordered_map<Key, T, Hash, Pred, Alloc> type;
    };

    template <class Key,                   // unordered_set::key_type/value_type
              class Hash = std::hash<Key>, // unordered_set::hasher
              class Pred = std::equal_to<Key>,  // unordered_set::key_equal
              class Alloc = std::allocator<Key> // unordered_set::allocator_type
              >
    struct unordered_set {
        typedef std::unordered_set<Key, Hash, Pred, Alloc> type;
    };
}
// typedef std::unordered_set LocARNA::unordered_set;
#else
#include <tr1/unordered_map>
#include <tr1/unordered_set>
namespace LocARNA {
    template <class Key,                        // unordered_map::key_type
              class T,                          // unordered_map::mapped_type
              class Hash = std::tr1::hash<Key>, // unordered_map::hasher
              class Pred = std::equal_to<Key>,  // unordered_map::key_equal
              class Alloc = std::allocator<
                  std::pair<const Key, T> > // unordered_map::allocator_type
              >
    struct unordered_map {
        typedef std::tr1::unordered_map<Key, T, Hash, Pred, Alloc> type;
    };

    template <class Key, // unordered_set::key_type/value_type
              class Hash = std::tr1::hash<Key>, // unordered_set::hasher
              class Pred = std::equal_to<Key>,  // unordered_set::key_equal
              class Alloc = std::allocator<Key> // unordered_set::allocator_type
              >
    struct unordered_set {
        typedef std::tr1::unordered_set<Key, Hash, Pred, Alloc> type;
    };
}
#endif


namespace LocARNA {

    class string1;

    struct pair_of_size_t_hash {
        size_t
        operator()(std::pair<size_t, size_t> p) const {
            return p.first << (sizeof(size_t) / 2) | p.second;
        }
    };

    typedef size_t size_type;

    typedef size_type pos_type;

    // ------------------------------------------------------------
    // define gap codes and symbols

    class Gap {
    private:
        size_t idx_; 
    public:
        static size_t size; 

        static const Gap regular;
        static const Gap loop;
        static const Gap locality;
        static const Gap other;

        explicit Gap(size_t idx) : idx_(idx) {}

        size_t
        idx() const {
            return (size_t)idx_;
        }

        bool
        operator==(const Gap &x) const {
            return this->idx_ == x.idx_;
        }

        bool
        operator!=(const Gap &x) const {
            return this->idx_ != x.idx_;
        }
    };

    bool
    is_gap_symbol(char c);

    char
    gap_symbol(Gap gap);

    char
    special_gap_symbol(Gap gap);

    Gap
    gap_code(char symbol);
    // ------------------------------------------------------------

    class failure : public std::exception {
        std::string msg_;

    public:
        explicit failure(const std::string &msg)
            : std::exception(), msg_(msg){};

        explicit failure() : std::exception(), msg_(){};

        virtual ~failure() throw();

        virtual const char *
        what() const throw();
    };

    struct wrong_format_failure : public failure {
        wrong_format_failure() : failure("Wrong format") {}
    };

    struct syntax_error_failure : public failure {
        syntax_error_failure() : failure("Syntax error") {}

        explicit syntax_error_failure(const std::string &msg)
            : failure("Syntax error: " + msg) {}
    };

    inline double
    prob_exp_f(int seqlen) {
        return 1.0 / (2.0 * seqlen);
    }

    // ------------------------------------------------------------
    // transformation of strings

    void
    transform_toupper(std::string &s);

    void
    normalize_rna_sequence(std::string &seq);

    void
    split_at_separator(const std::string &s,
                       char sep,
                       std::vector<std::string> &v);

    std::vector<std::string>
    split_at_separator(const std::string &s, char sep);

    std::string
    concat_with_separator(const std::vector<std::string> &v, char sep);

    typedef double FLT_OR_DBL;

    inline bool
    frag_len_geq(size_t i, size_t j, size_t minlen) {
        return i + minlen <= j + 1;
    }

    inline size_t
    frag_len(size_t i, size_t j) {
        return j + 1 - i;
    }

    inline size_t
    bp_span(size_t i, size_t j) {
        return frag_len(i, j);
    }

    bool
    has_prefix(const std::string &s, const std::string &p, size_t start = 0);

    bool
    get_nonempty_line(std::istream &in, std::string &line);

    double
    sequence_identity(const string1 &seqA, const string1 &seqB);
}

#endif