Event_parser.h

Go to the documentation of this file.

#ifndef EVENT_PARSER_H_
#define EVENT_PARSER_H_

#include "semantics/Syntactic_event.h"
#include <boost/shared_ptr.hpp>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <map>

#define PRINT(a) std::cout << #a << " = " << a << std::endl

namespace semantics
{

    class Lexicon_db;
    class Nonterminal_db;
    
    class Event_db
    {
        // Pointer to generic Syntactic_event
        typedef boost::shared_ptr<Syntactic_event> Event_ptr;
        // Containers for syntactic event pointers
        typedef std::vector<Event_ptr> Event_list;
        // The low frequency word map
        typedef std::map<Lexicon_db::Val_type, bool> LF_map_t;
    public:

        Event_db() : event_list_(), tree_list_(), num_events_(0), learn_(false)
        {}
        
        Event_db(
            std::string event_file,
            std::string lexicon_file,
            bool        learn = true,
            int         num_lines = 10000
            ) : event_list_(), tree_list_(), num_events_(0), learn_(learn)
        {
            read_lexicon(lexicon_file);
            event_list_.push_back(Event_ptr());
            read_events(event_file, num_lines);
        }

        Event_ptr get_tree(const int& i) const {return tree_list_[i];}

        void print_tree(const int& i, std::ostream& os) const
        {
            tree_list_[i] -> print_subtree(os);
        }

        size_t num_trees() const {return tree_list_.size();}

        size_t num_events() const {return num_events_;}
    public:
        static Lexicon_db& lexicon() {return Syntactic_event::lexicon();}

        static Nonterminal_db& nt_lexicon()
        {
            return Syntactic_event::nt_lexicon();
        }
        static LF_map_t& lf_word_map()
        {
            static boost::shared_ptr<LF_map_t> lfwm(new LF_map_t);
            return *lfwm;
        }
        static bool VERBOSE;
    private:
        Event_list event_list_; 
        Event_list tree_list_;  
        size_t num_events_;     
        bool learn_;            
        void read_lexicon(const std::string& lexicon_file);
        
        void read_events(const std::string& event_file, const int& num_lines);
        
        bool read_event(std::istringstream& event_stream);
        
        bool read_event_f(std::istringstream&)
        {
            num_events_ += event_list_.size();
            event_list_.clear();
            return true;
        }
        
        bool read_event_u(std::istringstream& input);
        
        bool read_event_d(std::istringstream& input);
    };

    
    Event_db process_event_file(
        std::string train_path,
        std::string lexicon_file,
        size_t      max_events,
        std::string test_path = ""
        );
};

#endif