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>


// 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;   
    }

    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