#ifndef _LATTICE_H_
#define _LATTICE_H_
#include <vector>
#include <string>
#ifdef STANDALONE_TRIGRAM
#define myItem lItem
class lItem {
	public:
		lItem(int s, int e, std::string o, std::string w)
			:_start(s), _end(e), _surface(o), _word(w), 
			_startchar(-1), _endchar(-1){};
		lItem(int s, int e, std::string o, std::string w, int sc, int ec)
			:_start(s), _end(e), _surface(o), _word(w), 
			_startchar(sc), _endchar(ec){};
		int start() {return _start;}
		void start(int s) {_start = s;}
		int end() {return _end;}
		void end(int e) {_end = e;}
		int startchar() {return _startchar;}
		void startchar(int s) {_startchar = s;}
		int endchar() {return _endchar;}
		void endchar(int e) {_endchar = e;}
		std::string surface() {return _surface;}
		void surface(std::string s) {_surface = s;}
		std::string word() {return _word;}
		void word(std::string w) {_word = w;}

	private:
		int _start;
		int _end;
		int _startchar;
		int _endchar;
		std::string _surface;
		std::string _word;
};

#else
#include "item.h"
#define myItem tItem
#endif
class tState; //forward declaration

class iScores {
  public:
    iScores(tState *bp, double a):_alpha(a), _backptr(bp) {};
	 iScores(tState *bp, double d, int t):_delta(d), _trace(t), _backptr(bp) {};
    double alpha() {return _alpha;}
    void alpha(double a) {_alpha = a;}
    double beta() {return _beta;}
    void beta(double b) {_beta = b;}
    double delta() {return _delta;}
    void delta(double d) {_delta = d;}
    int trace() {return _trace;}
	 void trace(int t) {_trace = t;}
    tState *backptr() {return _backptr;}
  private:
    double _alpha;
    double _beta;
	 double _delta;
	 int _trace;
    tState *_backptr;
};

class tState {
  public:
    tState(myItem *i, std::string t, double e, std::string let)
      :_tag(t), _emit(e), _let(let) {_itemptr.push_back(i);};
    void add_prev(tState *b, double a) { _prevs.push_back(iScores(b, a)); }
    void add_prev(tState *b, double d, int t) 
	 	{ _prevs.push_back(iScores(b, d, t)); }
    std::string tag() {return _tag;}
    std::string let() {return _let;}
    std::vector<iScores> &prevs() {return _prevs;}
    double emit() {return _emit;}
    void itemptr(myItem *p) {_itemptr.push_back(p);}
    std::vector<myItem *> &itemptr() {return _itemptr;}

  private:
    std::vector<myItem *> _itemptr;
    std::string _tag;
    std::string _let;
    double _emit;
    std::vector<iScores> _prevs;
};

#endif