action.h

Go to the documentation of this file.

#ifndef __ZGEN_SHIFTREDUCE_TYPES_ACTION_H__
#define __ZGEN_SHIFTREDUCE_TYPES_ACTION_H__

#include <iostream>
#include "engine/engine.h"
#include "types/instance.h"
#include "shiftreduce/settings.h"
#include <boost/tuple/tuple.hpp>
#include <boost/functional/hash.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/singleton.hpp>

namespace ZGen {

namespace ShiftReduce {

class Action {
public:
  Action() 
    : prefix(0), label(0), word(0), index(-1) {
    seed = 0;
  }

  Action(int _prefix, int _label, int _word)
    : prefix(_prefix), label(_label), word(_word), index(-1) {

    seed = 0;
    boost::hash_combine(seed, _prefix);
    boost::hash_combine(seed, _label);
    boost::hash_combine(seed, _word);
  }

  Action(int _prefix, int _label, int _word, int _index)
    : prefix(_prefix), label(_label), word(_word), index(_index) {

    seed = 0;
    // Only hash the first three element since index is only
    // a auxilary element.
    boost::hash_combine(seed, _prefix);
    boost::hash_combine(seed, _label);
    boost::hash_combine(seed, _word);
  }

  inline std::size_t hash() const {
    return seed;
  }

  Action & operator = (const Action & a) {
    seed    = a.seed;
    prefix  = a.prefix;
    label   = a.label;
    word    = a.word;
    index   = a.index;

    return (*this);
  }

  bool operator == (const Action & a) const {
    return (a.seed == seed && 
        a.prefix == prefix &&
        a.label == label &&
        a.word == word);
  }

  bool operator != (const Action & a) const {
    return !((*this) == a);
  }

  friend class boost::serialization::access;

  template<class Archive>
  void serialize(Archive & ar, const unsigned int /* file_version */) {
    ar & prefix & label & word & index & seed;
  }

  friend std::ostream & operator << (std::ostream& os, const Action& act) {
    namespace eg = Engine;
    os << "(" << eg::ActionEngine::get_const_instance().decode(act.prefix)
      << ", ";

    if (act.prefix == eg::ActionAlphabet::SH) {
      os << eg::PostagEngine::get_const_instance().decode(act.label)
        << ", "
        << eg::WordEngine::get_const_instance().decode(act.word)
        << ", [" << act.index << "]"
        << ")";
    } else {
      os << eg::DeprelEngine::get_const_instance().decode(act.label)
        << ")";
    }
    return os;
  }

  friend std::size_t hash_value(const Action& a) {
    return a.seed;
  }

  int prefix;
  // The action prefix (SHIFT, LEFT-ARC, RIGHT-ARC)

  int label;
  // The relation field. It represent PoSTag (on SHIFT) and
  // dependency relation (on LEFT-ARC and RIGHT-ARC)

  int word;
  // The word inded.

  int index;
  // extra field for auxilary in the SHIFT action.

  std::size_t seed;
};

typedef Action action_t;

}

}

#endif  //  end for __SR_ACTION_HPP__