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,Alphabet<T> a);

}

#   include "alphabet.icc"

#endif // LOCARNA_ALPHABET_HH