Token_map.h

Go to the documentation of this file.

#ifndef TOKEN_MAP_H_
#define TOKEN_MAP_H_

#include <boost/bimap.hpp>
#include <boost/bind.hpp>
#include <fstream>
#include <algorithm>
#include <string>

namespace semantics
{

class Token_map
{
public:
    typedef std::string Key_type;
    typedef size_t Val_type;
    typedef boost::bimap<Key_type, Val_type> Map;
    typedef Map::value_type Key_val_pair;
    typedef Map::right_value_type Val_key_pair;
    typedef Map::const_iterator const_iterator;

    static const Val_type UNKNOWN_TOKEN_VAL;
    
    Token_map() : map_(), next_val_(UNKNOWN_TOKEN_VAL + 1) {}
    virtual ~Token_map() {}

    virtual Val_type get_code(const Token_map::Key_type& key);
    
    virtual Val_type encode(const Key_type& key, bool learn = false);
    virtual const Key_type& decode(const Val_type& val);
    virtual Val_type next_val() {return next_val_;}
    friend std::ostream& operator<<(std::ostream& os, Token_map& map);
    
    const_iterator begin() {return map_.begin();}
    const_iterator end(){return map_.end();}
    
protected:
    virtual const Key_type& unknown_key() = 0;
    Map map_;
    Val_type next_val_;
};

    template<class T>
    void multi_encode(Token_map& map, const T& keys)
    {
        std::for_each(
            keys.begin(), keys.end(),
            boost::bind(&Token_map::encode, &map, _1, true)
            );
    }

    template<class T, class U, class M>
    T multi_map_encode(M maps, U keys)
    {
        T vals;
        std::transform(
            keys.begin(), keys.end(), maps.begin(), vals.begin(),
            boost::bind(&Token_map::encode, _1, _2, false)
            );
        return vals;
    }

    template<class U, class T, class M>
    U multi_map_decode(M maps, T vals)
    {
        U keys;
        std::transform(
            vals.begin(), vals.end(), maps.begin(), keys.begin(),
            boost::bind(&Token_map::decode, _2, _1)
            );
        return keys;
    }
    
};
    
#endif