move Moses classes out of OnDiskPt - TargetPhrase

4 files changed, 86 insertions, 77 deletions

diff --git a/OnDiskPt/TargetPhrase.cpp b/OnDiskPt/TargetPhrase.cpp
index f0501a937..c232c9bc3 100644
--- a/OnDiskPt/TargetPhrase.cpp
+++ b/OnDiskPt/TargetPhrase.cpp
@@ -21,8 +21,6 @@
 #include <algorithm>
 #include <iostream>
 #include "moses/Util.h"
-#include "moses/TargetPhrase.h"
-#include "moses/TranslationModel/PhraseDictionary.h"
 #include "TargetPhrase.h"
 #include "OnDiskWrapper.h"
 #include "util/exception.hh"
@@ -251,74 +249,6 @@ size_t TargetPhrase::WriteScoresToMemory(char *mem) const
   return memUsed;
 }
 
-
-Moses::TargetPhrase *TargetPhrase::ConvertToMoses(const std::vector<Moses::FactorType> & inputFactors
-    , const std::vector<Moses::FactorType> &outputFactors
-    , const Vocab &vocab
-    , const Moses::PhraseDictionary &phraseDict
-    , const std::vector<float> &weightT
-    , bool isSyntax) const
-{
-  Moses::TargetPhrase *ret = new Moses::TargetPhrase(&phraseDict);
-
-  // words
-  size_t phraseSize = GetSize();
-  UTIL_THROW_IF2(phraseSize == 0, "Target phrase cannot be empty"); // last word is lhs
-  if (isSyntax) {
-    --phraseSize;
-  }
-
-  for (size_t pos = 0; pos < phraseSize; ++pos) {
-    GetWord(pos).ConvertToMoses(outputFactors, vocab, ret->AddWord());
-  }
-
-  // alignments
-  // int index = 0;
-  Moses::AlignmentInfo::CollType alignTerm, alignNonTerm;
-  std::set<std::pair<size_t, size_t> > alignmentInfo;
-  const PhrasePtr sp = GetSourcePhrase();
-  for (size_t ind = 0; ind < m_align.size(); ++ind) {
-    const std::pair<size_t, size_t> &entry = m_align[ind];
-    alignmentInfo.insert(entry);
-    size_t sourcePos = entry.first;
-    size_t targetPos = entry.second;
-
-    if (GetWord(targetPos).IsNonTerminal()) {
-      alignNonTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
-    } else {
-      alignTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
-    }
-
-  }
-  ret->SetAlignTerm(alignTerm);
-  ret->SetAlignNonTerm(alignNonTerm);
-
-  if (isSyntax) {
-    Moses::Word *lhsTarget = new Moses::Word(true);
-    GetWord(GetSize() - 1).ConvertToMoses(outputFactors, vocab, *lhsTarget);
-    ret->SetTargetLHS(lhsTarget);
-  }
-
-  // set source phrase
-  Moses::Phrase mosesSP(Moses::Input);
-  for (size_t pos = 0; pos < sp->GetSize(); ++pos) {
-    sp->GetWord(pos).ConvertToMoses(inputFactors, vocab, mosesSP.AddWord());
-  }
-
-  // scores
-  ret->GetScoreBreakdown().Assign(&phraseDict, m_scores);
-
-  // sparse features
-  ret->GetScoreBreakdown().Assign(&phraseDict, m_sparseFeatures);
-
-  // property
-  ret->SetProperties(m_property);
-
-  ret->EvaluateInIsolation(mosesSP, phraseDict.GetFeaturesToApply());
-
-  return ret;
-}
-
 uint64_t TargetPhrase::ReadOtherInfoFromFile(uint64_t filePos, std::fstream &fileTPColl)
 {
   assert(filePos == (uint64_t)fileTPColl.tellg());
diff --git a/OnDiskPt/TargetPhrase.h b/OnDiskPt/TargetPhrase.h
index b41b788d5..2197372fc 100644
--- a/OnDiskPt/TargetPhrase.h
+++ b/OnDiskPt/TargetPhrase.h
@@ -102,21 +102,23 @@ public:
     return m_scores[ind];
   }
 
-  Moses::TargetPhrase *ConvertToMoses(const std::vector<Moses::FactorType> &inputFactors
-                                      , const std::vector<Moses::FactorType> &outputFactors
-                                      , const Vocab &vocab
-                                      , const Moses::PhraseDictionary &phraseDict
-                                      , const std::vector<float> &weightT
-                                      , bool isSyntax) const;
   uint64_t ReadOtherInfoFromFile(uint64_t filePos, std::fstream &fileTPColl);
   uint64_t ReadFromFile(std::fstream &fileTP);
 
   virtual void DebugPrint(std::ostream &out, const Vocab &vocab) const;
 
+  const std::string &GetProperty() const {
+    return m_property;
+  }
+
   void SetProperty(const std::string &value) {
     m_property = value;
   }
 
+  const std::string &GetSparseFeatures() const {
+    return m_sparseFeatures;
+  }
+
   void SetSparseFeatures(const std::string &value) {
     m_sparseFeatures = value;
   }
diff --git a/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.cpp b/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.cpp
index 9ca2c9b0b..06c3bd262 100644
--- a/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.cpp
+++ b/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.cpp
@@ -230,7 +230,7 @@ PhraseDictionaryOnDisk::ConvertToMoses(
 	  for (size_t i = 0; i < targetPhrasesOnDisk->GetSize(); ++i) {
 	    const OnDiskPt::TargetPhrase &tp = targetPhrasesOnDisk->GetTargetPhrase(i);
 	    Moses::TargetPhrase *mosesPhrase
-	    = tp.ConvertToMoses(inputFactors, outputFactors, vocab,
+	    = ConvertToMoses(tp, inputFactors, outputFactors, vocab,
 	                        phraseDict, weightT, isSyntax);
 
 	    /*
@@ -248,6 +248,75 @@ PhraseDictionaryOnDisk::ConvertToMoses(
 	  return ret;
 }
 
+Moses::TargetPhrase *PhraseDictionaryOnDisk::ConvertToMoses(const OnDiskPt::TargetPhrase &targetPhraseOnDisk
+		  	  	  	  	  	  	  	  , const std::vector<Moses::FactorType> &inputFactors
+                                    , const std::vector<Moses::FactorType> &outputFactors
+                                    , const OnDiskPt::Vocab &vocab
+                                    , const Moses::PhraseDictionary &phraseDict
+                                    , const std::vector<float> &weightT
+                                    , bool isSyntax) const
+{
+  Moses::TargetPhrase *ret = new Moses::TargetPhrase(&phraseDict);
+
+  // words
+  size_t phraseSize = targetPhraseOnDisk.GetSize();
+  UTIL_THROW_IF2(phraseSize == 0, "Target phrase cannot be empty"); // last word is lhs
+  if (isSyntax) {
+	--phraseSize;
+  }
+
+  for (size_t pos = 0; pos < phraseSize; ++pos) {
+    targetPhraseOnDisk.GetWord(pos).ConvertToMoses(outputFactors, vocab, ret->AddWord());
+  }
+
+  // alignments
+  // int index = 0;
+  Moses::AlignmentInfo::CollType alignTerm, alignNonTerm;
+  std::set<std::pair<size_t, size_t> > alignmentInfo;
+  const OnDiskPt::PhrasePtr sp = targetPhraseOnDisk.GetSourcePhrase();
+  for (size_t ind = 0; ind < targetPhraseOnDisk.GetAlign().size(); ++ind) {
+	const std::pair<size_t, size_t> &entry = targetPhraseOnDisk.GetAlign()[ind];
+	alignmentInfo.insert(entry);
+	size_t sourcePos = entry.first;
+	size_t targetPos = entry.second;
+
+	if (targetPhraseOnDisk.GetWord(targetPos).IsNonTerminal()) {
+	  alignNonTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
+	} else {
+	  alignTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
+	}
+
+  }
+  ret->SetAlignTerm(alignTerm);
+  ret->SetAlignNonTerm(alignNonTerm);
+
+  if (isSyntax) {
+	Moses::Word *lhsTarget = new Moses::Word(true);
+	targetPhraseOnDisk.GetWord(targetPhraseOnDisk.GetSize() - 1).ConvertToMoses(outputFactors, vocab, *lhsTarget);
+	ret->SetTargetLHS(lhsTarget);
+  }
+
+  // set source phrase
+  Moses::Phrase mosesSP(Moses::Input);
+  for (size_t pos = 0; pos < sp->GetSize(); ++pos) {
+	sp->GetWord(pos).ConvertToMoses(inputFactors, vocab, mosesSP.AddWord());
+  }
+
+  // scores
+  ret->GetScoreBreakdown().Assign(&phraseDict, targetPhraseOnDisk.GetScores());
+
+  // sparse features
+  ret->GetScoreBreakdown().Assign(&phraseDict, targetPhraseOnDisk.GetSparseFeatures());
+
+  // property
+  ret->SetProperties(targetPhraseOnDisk.GetProperty());
+
+  ret->EvaluateInIsolation(mosesSP, phraseDict.GetFeaturesToApply());
+
+  return ret;
+
+}
+
 void PhraseDictionaryOnDisk::SetParameter(const std::string& key, const std::string& value)
 {
   if (key == "max-span-default") {
diff --git a/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.h b/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.h
index 7a0c06c4a..f3c923b72 100644
--- a/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.h
+++ b/moses/TranslationModel/RuleTable/PhraseDictionaryOnDisk.h
@@ -64,6 +64,14 @@ protected:
 
   void GetTargetPhraseCollectionBatch(InputPath &inputPath) const;
 
+  Moses::TargetPhrase *ConvertToMoses(const OnDiskPt::TargetPhrase &targetPhraseOnDisk
+		  	  	  	  	  	  	  	  , const std::vector<Moses::FactorType> &inputFactors
+                                      , const std::vector<Moses::FactorType> &outputFactors
+                                      , const OnDiskPt::Vocab &vocab
+                                      , const Moses::PhraseDictionary &phraseDict
+                                      , const std::vector<float> &weightT
+                                      , bool isSyntax) const;
+
 public:
   PhraseDictionaryOnDisk(const std::string &line);
   ~PhraseDictionaryOnDisk();