src/LocARNA/alphabet.hh

#ifndef LOCARNA_ALPHABET_HH
#define LOCARNA_ALPHABET_HH

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

#include <vector>
#include <map>
#include <iosfwd>
#include <assert.h>

namespace LocARNA {

    template <class T>
    class Alphabet {
        typedef std::vector<T> vec_t;

    public:
        typedef typename vec_t::size_type size_type; 
    private:
        typedef std::map<T, size_type> hash_t;

        vec_t alph_vec;
        hash_t alph_hash;

    public:
        typedef size_type index_type; 
        typedef T elem_type;          
        typedef std::vector<T> elem_vector_type; 

        typedef typename elem_vector_type::iterator iterator;

        typedef typename elem_vector_type::const_iterator const_iterator;

        Alphabet();

        explicit Alphabet(const elem_vector_type &a);

        Alphabet(const elem_type *s, int len);

        size_type
        size() const;

        size_type
        idx(const elem_type &elem) const;

        const elem_type &
        elem(size_type idx) const;

        bool
        in(const elem_type &elem) const;

        const_iterator
        begin() const {
            return alph_vec.begin();
        }

        const_iterator
        end() const {
            return alph_vec.end();
        }

        iterator
        begin() {
            return alph_vec.begin();
        }

        iterator
        end() {
            return alph_vec.end();
        }

    private:
        void
        init(const vec_t &a);
    };

    template <class T>
    std::ostream &
    operator<<(std::ostream &out, const Alphabet<T> &a);
}

#include "alphabet.icc"

#endif // LOCARNA_ALPHABET_HH