00001 #include "RuleTrieScope3.h"
00002
00003 #include <map>
00004 #include <vector>
00005
00006 #include <boost/functional/hash.hpp>
00007 #include <boost/unordered_map.hpp>
00008 #include <boost/version.hpp>
00009
00010 #include "moses/NonTerminal.h"
00011 #include "moses/TargetPhrase.h"
00012 #include "moses/TargetPhraseCollection.h"
00013 #include "moses/Util.h"
00014 #include "moses/Word.h"
00015
00016 namespace Moses
00017 {
00018 namespace Syntax
00019 {
00020 namespace S2T
00021 {
00022
00023 void RuleTrieScope3::Node::Prune(std::size_t tableLimit)
00024 {
00025
00026 for (TerminalMap::iterator p = m_terminalMap.begin();
00027 p != m_terminalMap.end(); ++p) {
00028 p->second.Prune(tableLimit);
00029 }
00030 if (m_gapNode) {
00031 m_gapNode->Prune(tableLimit);
00032 }
00033
00034
00035 for (LabelMap::iterator p = m_labelMap.begin(); p != m_labelMap.end(); ++p) {
00036 p->second->Prune(true, tableLimit);
00037 }
00038 }
00039
00040 void RuleTrieScope3::Node::Sort(std::size_t tableLimit)
00041 {
00042
00043 for (TerminalMap::iterator p = m_terminalMap.begin();
00044 p != m_terminalMap.end(); ++p) {
00045 p->second.Sort(tableLimit);
00046 }
00047 if (m_gapNode) {
00048 m_gapNode->Sort(tableLimit);
00049 }
00050
00051
00052 for (LabelMap::iterator p = m_labelMap.begin(); p != m_labelMap.end(); ++p) {
00053 p->second->Sort(true, tableLimit);
00054 }
00055 }
00056
00057 RuleTrieScope3::Node *RuleTrieScope3::Node::GetOrCreateTerminalChild(
00058 const Word &sourceTerm)
00059 {
00060 assert(!sourceTerm.IsNonTerminal());
00061 std::pair<TerminalMap::iterator, bool> result;
00062 result = m_terminalMap.insert(std::make_pair(sourceTerm, Node()));
00063 const TerminalMap::iterator &iter = result.first;
00064 Node &child = iter->second;
00065 return &child;
00066 }
00067
00068 RuleTrieScope3::Node *RuleTrieScope3::Node::GetOrCreateNonTerminalChild(
00069 const Word &targetNonTerm)
00070 {
00071 assert(targetNonTerm.IsNonTerminal());
00072 if (m_gapNode == NULL) {
00073 m_gapNode = new Node();
00074 }
00075 return m_gapNode;
00076 }
00077
00078 TargetPhraseCollection::shared_ptr
00079 RuleTrieScope3::
00080 Node::
00081 GetOrCreateTargetPhraseCollection(const TargetPhrase &target)
00082 {
00083 const AlignmentInfo &alignmentInfo = target.GetAlignNonTerm();
00084 const std::size_t rank = alignmentInfo.GetSize();
00085
00086 std::vector<int> vec;
00087 vec.reserve(rank);
00088
00089 m_labelTable.resize(rank);
00090
00091 int i = 0;
00092 for (AlignmentInfo::const_iterator p = alignmentInfo.begin();
00093 p != alignmentInfo.end(); ++p) {
00094 std::size_t targetNonTermIndex = p->second;
00095 const Word &targetNonTerm = target.GetWord(targetNonTermIndex);
00096 vec.push_back(InsertLabel(i++, targetNonTerm));
00097 }
00098 TargetPhraseCollection::shared_ptr& ret = m_labelMap[vec];
00099 if (!ret) ret.reset(new TargetPhraseCollection);
00100 return ret;
00101 }
00102
00103 TargetPhraseCollection::shared_ptr
00104 RuleTrieScope3::
00105 GetOrCreateTargetPhraseCollection(const Phrase &source,
00106 const TargetPhrase &target,
00107 const Word *sourceLHS)
00108 {
00109 Node &currNode = GetOrCreateNode(source, target, sourceLHS);
00110 return currNode.GetOrCreateTargetPhraseCollection(target);
00111 }
00112
00113 RuleTrieScope3::Node &RuleTrieScope3::GetOrCreateNode(
00114 const Phrase &source, const TargetPhrase &target, const Word *)
00115 {
00116 const std::size_t size = source.GetSize();
00117
00118 const AlignmentInfo &alignmentInfo = target.GetAlignNonTerm();
00119 AlignmentInfo::const_iterator iterAlign = alignmentInfo.begin();
00120
00121 Node *currNode = &m_root;
00122 for (std::size_t pos = 0 ; pos < size ; ++pos) {
00123 const Word &word = source.GetWord(pos);
00124
00125 if (word.IsNonTerminal()) {
00126 assert(iterAlign != alignmentInfo.end());
00127 assert(iterAlign->first == pos);
00128 std::size_t targetNonTermInd = iterAlign->second;
00129 ++iterAlign;
00130 const Word &targetNonTerm = target.GetWord(targetNonTermInd);
00131 currNode = currNode->GetOrCreateNonTerminalChild(targetNonTerm);
00132 } else {
00133 currNode = currNode->GetOrCreateTerminalChild(word);
00134 }
00135
00136 assert(currNode != NULL);
00137 }
00138
00139 return *currNode;
00140 }
00141
00142 void RuleTrieScope3::SortAndPrune(std::size_t tableLimit)
00143 {
00144 if (tableLimit) {
00145 m_root.Sort(tableLimit);
00146 }
00147 }
00148
00149 bool RuleTrieScope3::HasPreterminalRule(const Word &w) const
00150 {
00151 const Node::TerminalMap &map = m_root.GetTerminalMap();
00152 Node::TerminalMap::const_iterator p = map.find(w);
00153 return p != map.end() && p->second.HasRules();
00154 }
00155
00156 }
00157 }
00158 }