mosesdecoder/moses/src/TranslationOption.h

Go to the documentation of this file.

// $Id$

/***********************************************************************
Moses - factored phrase-based language decoder
Copyright (C) 2006 University of Edinburgh

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
***********************************************************************/

#ifndef moses_TranslationOption_h
#define moses_TranslationOption_h

#include <map>
#include <vector>
#include "WordsBitmap.h"
#include "WordsRange.h"
#include "Phrase.h"
#include "TargetPhrase.h"
#include "Hypothesis.h"
#include "Util.h"
#include "TypeDef.h"
#include "ScoreComponentCollection.h"
#include "StaticData.h"

namespace Moses
{

class PhraseDictionary;
class GenerationDictionary;
class LexicalReordering;

class TranslationOption
{
  friend std::ostream& operator<<(std::ostream& out, const TranslationOption& possibleTranslation);

protected:

  TargetPhrase                                                  m_targetPhrase; /*< output phrase when using this translation option */
  Phrase                                      *m_sourcePhrase; /*< input phrase translated by this */
  const WordsRange              m_sourceWordsRange; /*< word position in the input that are covered by this translation option */
  float               m_futureScore; /*< estimate of total cost when using this translation option, includes language model probabilities */

  ScoreComponentCollection      m_scoreBreakdown;

  typedef std::map<const ScoreProducer *, const Scores *> _ScoreCacheMap;
  _ScoreCacheMap m_cachedScores;

public:
  TranslationOption(const WordsRange &wordsRange
                    , const TargetPhrase &targetPhrase
                    , const InputType &inputType);
  TranslationOption(const WordsRange &wordsRange
                    , const TargetPhrase &targetPhrase
                    , const InputType &inputType
                    , const UnknownWordPenaltyProducer* uwpProducer);
  TranslationOption(const TranslationOption &copy);

  TranslationOption(const TranslationOption &copy, const WordsRange &sourceWordsRange);

  ~TranslationOption() {
    delete m_sourcePhrase;
    for(_ScoreCacheMap::const_iterator it = m_cachedScores.begin(); it != m_cachedScores.end(); ++it)
      delete it->second;
  }

  bool IsCompatible(const Phrase& phrase, const std::vector<FactorType>& featuresToCheck) const;

  void MergeNewFeatures(const Phrase& phrase, const ScoreComponentCollection& score, const std::vector<FactorType>& featuresToMerge);

  inline const TargetPhrase &GetTargetPhrase() const {
    return m_targetPhrase;
  }

  inline const WordsRange &GetSourceWordsRange() const {
    return m_sourceWordsRange;
  }

  const Phrase *GetSourcePhrase() const {
    return m_sourcePhrase;
  }

  bool Overlap(const Hypothesis &hypothesis) const;

  inline size_t GetStartPos() const {
    return m_sourceWordsRange.GetStartPos();
  }

  inline size_t GetEndPos() const {
    return m_sourceWordsRange.GetEndPos();
  }

  inline size_t GetSize() const {
    return m_sourceWordsRange.GetEndPos() - m_sourceWordsRange.GetStartPos() + 1;
  }

  inline float GetFutureScore() const {
    return m_futureScore;
  }

  inline bool IsDeletionOption() const {
    return m_targetPhrase.GetSize() == 0;
  }

  inline const ScoreComponentCollection &GetScoreBreakdown() const {
    return m_scoreBreakdown;
  }

  inline const Scores *GetCachedScores(const ScoreProducer *scoreProducer) const {
    _ScoreCacheMap::const_iterator it = m_cachedScores.find(scoreProducer);
    if(it == m_cachedScores.end())
      return NULL;
    else
      return it->second;
  }

  void CalcScore(const TranslationSystem* system);

  void CacheScores(const ScoreProducer &scoreProducer, const Scores &score);

  TO_STRING();
};

}

#endif

---