00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "PhraseDictionaryNodeMemory.h"
00023 #include "moses/TargetPhrase.h"
00024 #include "moses/TranslationModel/PhraseDictionary.h"
00025
00026 using namespace std;
00027
00028 namespace Moses
00029 {
00030
00031 void PhraseDictionaryNodeMemory::Prune(size_t tableLimit)
00032 {
00033
00034 for (TerminalMap::iterator p = m_sourceTermMap.begin(); p != m_sourceTermMap.end(); ++p) {
00035 p->second.Prune(tableLimit);
00036 }
00037 for (NonTerminalMap::iterator p = m_nonTermMap.begin(); p != m_nonTermMap.end(); ++p) {
00038 p->second.Prune(tableLimit);
00039 }
00040
00041
00042 m_targetPhraseCollection->Prune(true, tableLimit);
00043 }
00044
00045 void PhraseDictionaryNodeMemory::Sort(size_t tableLimit)
00046 {
00047
00048 for (TerminalMap::iterator p = m_sourceTermMap.begin(); p != m_sourceTermMap.end(); ++p) {
00049 p->second.Sort(tableLimit);
00050 }
00051 for (NonTerminalMap::iterator p = m_nonTermMap.begin(); p != m_nonTermMap.end(); ++p) {
00052 p->second.Sort(tableLimit);
00053 }
00054
00055
00056 m_targetPhraseCollection->Sort(true, tableLimit);
00057 }
00058
00059 PhraseDictionaryNodeMemory*
00060 PhraseDictionaryNodeMemory::GetOrCreateChild(const Word &sourceTerm)
00061 {
00062 return &m_sourceTermMap[sourceTerm];
00063 }
00064
00065 #if defined(UNLABELLED_SOURCE)
00066 PhraseDictionaryNodeMemory *PhraseDictionaryNodeMemory::GetOrCreateNonTerminalChild(const Word &targetNonTerm)
00067 {
00068 UTIL_THROW_IF2(!targetNonTerm.IsNonTerminal(),
00069 "Not a non-terminal: " << targetNonTerm);
00070
00071 return &m_nonTermMap[targetNonTerm];
00072 }
00073 #else
00074 PhraseDictionaryNodeMemory *PhraseDictionaryNodeMemory::GetOrCreateChild(const Word &sourceNonTerm, const Word &targetNonTerm)
00075 {
00076 UTIL_THROW_IF2(!sourceNonTerm.IsNonTerminal(),
00077 "Not a non-terminal: " << sourceNonTerm);
00078 UTIL_THROW_IF2(!targetNonTerm.IsNonTerminal(),
00079 "Not a non-terminal: " << targetNonTerm);
00080
00081 NonTerminalMapKey key(sourceNonTerm, targetNonTerm);
00082 return &m_nonTermMap[NonTerminalMapKey(sourceNonTerm, targetNonTerm)];
00083 }
00084 #endif
00085
00086 const PhraseDictionaryNodeMemory *PhraseDictionaryNodeMemory::GetChild(const Word &sourceTerm) const
00087 {
00088 UTIL_THROW_IF2(sourceTerm.IsNonTerminal(),
00089 "Not a terminal: " << sourceTerm);
00090
00091 TerminalMap::const_iterator p = m_sourceTermMap.find(sourceTerm);
00092 return (p == m_sourceTermMap.end()) ? NULL : &p->second;
00093 }
00094
00095 #if defined(UNLABELLED_SOURCE)
00096 const PhraseDictionaryNodeMemory *PhraseDictionaryNodeMemory::GetNonTerminalChild(const Word &targetNonTerm) const
00097 {
00098 UTIL_THROW_IF2(!targetNonTerm.IsNonTerminal(),
00099 "Not a non-terminal: " << targetNonTerm);
00100
00101 NonTerminalMap::const_iterator p = m_nonTermMap.find(targetNonTerm);
00102 return (p == m_nonTermMap.end()) ? NULL : &p->second;
00103 }
00104 #else
00105 const PhraseDictionaryNodeMemory *PhraseDictionaryNodeMemory::GetChild(const Word &sourceNonTerm, const Word &targetNonTerm) const
00106 {
00107 UTIL_THROW_IF2(!sourceNonTerm.IsNonTerminal(),
00108 "Not a non-terminal: " << sourceNonTerm);
00109 UTIL_THROW_IF2(!targetNonTerm.IsNonTerminal(),
00110 "Not a non-terminal: " << targetNonTerm);
00111
00112 NonTerminalMapKey key(sourceNonTerm, targetNonTerm);
00113 NonTerminalMap::const_iterator p = m_nonTermMap.find(key);
00114 return (p == m_nonTermMap.end()) ? NULL : &p->second;
00115 }
00116 #endif
00117
00118 void PhraseDictionaryNodeMemory::Remove()
00119 {
00120 m_sourceTermMap.clear();
00121 m_nonTermMap.clear();
00122 m_targetPhraseCollection->Remove();
00123 }
00124
00125 std::ostream& operator<<(std::ostream &out, const PhraseDictionaryNodeMemory &node)
00126 {
00127 out << node.GetTargetPhraseCollection();
00128 return out;
00129 }
00130
00131 TO_STRING_BODY(PhraseDictionaryNodeMemory)
00132
00133 }
00134