00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef moses_TargetPhrase_h
00022 #define moses_TargetPhrase_h
00023
00024 #include <algorithm>
00025 #include <vector>
00026 #include "TypeDef.h"
00027 #include "Phrase.h"
00028 #include "ScoreComponentCollection.h"
00029 #include "AlignmentInfo.h"
00030 #include "AlignmentInfoCollection.h"
00031 #include "moses/PP/PhraseProperty.h"
00032 #include "util/string_piece.hh"
00033
00034
00035 #include <boost/shared_ptr.hpp>
00036 #include <boost/unordered_map.hpp>
00037
00038 #ifdef HAVE_PROTOBUF
00039 #include "rule.pb.h"
00040 #endif
00041
00042 namespace Moses
00043 {
00044 class FeatureFunction;
00045 class InputPath;
00046 class InputPath;
00047 class PhraseDictionary;
00048
00051 class TargetPhrase: public Phrase
00052 {
00053 public:
00054 typedef std::map<FeatureFunction const*, boost::shared_ptr<Scores> > ScoreCache_t;
00055 ScoreCache_t const& GetExtraScores() const;
00056 Scores const* GetExtraScores(FeatureFunction const* ff) const;
00057 void SetExtraScores(FeatureFunction const* ff,boost::shared_ptr<Scores> const& scores);
00058
00059 typedef std::map<size_t const, std::vector<SPTR<std::vector<float> > > > CoordCache_t;
00060 std::vector<SPTR<std::vector<float> > > const* GetCoordList(size_t const spaceID) const;
00061 void PushCoord(size_t const spaceID, SPTR<std::vector<float> > const coord);
00062
00063 private:
00064 ScoreCache_t m_cached_scores;
00065 SPTR<CoordCache_t> m_cached_coord;
00066 WPTR<ContextScope> m_scope;
00067
00068 private:
00069 friend std::ostream& operator<<(std::ostream&, const TargetPhrase&);
00070 friend void swap(TargetPhrase &first, TargetPhrase &second);
00071
00072 float m_futureScore, m_estimatedScore;
00073 ScoreComponentCollection m_scoreBreakdown;
00074
00075 const AlignmentInfo* m_alignTerm, *m_alignNonTerm;
00076 const Word *m_lhsTarget;
00077 mutable Phrase *m_ruleSource;
00078
00079 typedef std::map<std::string, boost::shared_ptr<PhraseProperty> > Properties;
00080 Properties m_properties;
00081
00082 const PhraseDictionary *m_container;
00083
00084 mutable boost::unordered_map<const std::string, boost::shared_ptr<void> > m_data;
00085
00086 public:
00087 TargetPhrase(const PhraseDictionary *pt = NULL);
00088 TargetPhrase(std::string out_string, const PhraseDictionary *pt = NULL);
00089 TargetPhrase(const TargetPhrase ©);
00090 explicit TargetPhrase(const Phrase &targetPhrase, const PhraseDictionary *pt);
00091
00092
00093 TargetPhrase(ttasksptr &ttask, const PhraseDictionary *pt = NULL);
00094 TargetPhrase(ttasksptr &ttask, std::string out_string, const PhraseDictionary *pt = NULL);
00095 explicit TargetPhrase(ttasksptr &ttask, const Phrase &targetPhrase, const PhraseDictionary *pt);
00096
00097
00098
00099
00100 bool HasScope() const;
00101 SPTR<ContextScope> GetScope() const;
00102
00103 ~TargetPhrase();
00104
00105
00106 void EvaluateInIsolation(const Phrase &source, const std::vector<FeatureFunction*> &ffs);
00107
00108
00109
00110 void EvaluateInIsolation(const Phrase &source);
00111
00112
00113 void EvaluateWithSourceContext(const InputType &input, const InputPath &inputPath);
00114
00115 void UpdateScore(ScoreComponentCollection *futureScoreBreakdown = NULL);
00116
00117 void SetSparseScore(const FeatureFunction* translationScoreProducer, const StringPiece &sparseString);
00118
00119
00120 void SetXMLScore(float score);
00121
00122 #ifdef HAVE_PROTOBUF
00123 void WriteToRulePB(hgmert::Rule* pb) const;
00124 #endif
00125
00126
00127
00128
00129
00130
00131
00132 inline float GetFutureScore() const {
00133 return m_futureScore;
00134 }
00135
00136 inline const ScoreComponentCollection &GetScoreBreakdown() const {
00137 return m_scoreBreakdown;
00138 }
00139 inline ScoreComponentCollection &GetScoreBreakdown() {
00140 return m_scoreBreakdown;
00141 }
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152 void SetTargetLHS(const Word *lhs) {
00153 m_lhsTarget = lhs;
00154 }
00155 const Word &GetTargetLHS() const {
00156 return *m_lhsTarget;
00157 }
00158
00159 void SetAlignmentInfo(const StringPiece &alignString);
00160 void SetAlignTerm(const AlignmentInfo *alignTerm) {
00161 m_alignTerm = alignTerm;
00162 }
00163 void SetAlignNonTerm(const AlignmentInfo *alignNonTerm) {
00164 m_alignNonTerm = alignNonTerm;
00165 }
00166
00167
00168
00169 template<typename ALNREP>
00170 void
00171 SetAlignTerm(const ALNREP &coll) {
00172 m_alignTerm = AlignmentInfoCollection::Instance().Add(coll);
00173 }
00174
00175
00176
00177 template<typename ALNREP>
00178 void
00179 SetAlignNonTerm(const ALNREP &coll) {
00180 m_alignNonTerm = AlignmentInfoCollection::Instance().Add(coll);
00181 }
00182
00183
00184 const AlignmentInfo &GetAlignTerm() const {
00185 return *m_alignTerm;
00186 }
00187 const AlignmentInfo &GetAlignNonTerm() const {
00188 return *m_alignNonTerm;
00189 }
00190
00191 const Phrase *GetRuleSource() const {
00192 return m_ruleSource;
00193 }
00194
00195 const PhraseDictionary *GetContainer() const {
00196 return m_container;
00197 }
00198
00199 bool SetData(const std::string& key, boost::shared_ptr<void> value) const {
00200 std::pair< boost::unordered_map<const std::string, boost::shared_ptr<void> >::iterator, bool > inserted =
00201 m_data.insert( std::pair<const std::string, boost::shared_ptr<void> >(key,value) );
00202 if (!inserted.second) {
00203 return false;
00204 }
00205 return true;
00206 }
00207
00208 boost::shared_ptr<void> GetData(const std::string& key) const {
00209 boost::unordered_map<const std::string, boost::shared_ptr<void> >::const_iterator found = m_data.find(key);
00210 if (found == m_data.end()) {
00211 return boost::shared_ptr<void>();
00212 }
00213 return found->second;
00214 }
00215
00216
00217
00218
00219
00220 void SetRuleSource(const Phrase &ruleSource) const;
00221
00222 void SetProperties(const StringPiece &str);
00223 void SetProperty(const std::string &key, const std::string &value);
00224 const PhraseProperty *GetProperty(const std::string &key) const;
00225
00226 void Merge(const TargetPhrase ©, const std::vector<FactorType>& factorVec);
00227
00228 bool operator< (const TargetPhrase &compare) const;
00229 bool operator== (const TargetPhrase &compare) const;
00230
00231 TO_STRING();
00232 };
00233
00234 void swap(TargetPhrase &first, TargetPhrase &second);
00235
00236 std::ostream& operator<<(std::ostream&, const TargetPhrase&);
00237
00238 }
00239
00240 #endif