moses/src/TranslationOption.h

Go to the documentation of this file.

// $Id: TranslationOption.h 3394 2010-08-10 13:12:00Z bhaddow $

/***********************************************************************
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 */
        std::vector<TranslationOption*> m_linkedTransOpts; /* list of linked TOs which must be included with this in any hypothesis */
        
        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;
        }
        
        inline const std::vector<TranslationOption*> &GetLinkedTransOpts() const
        {
                return m_linkedTransOpts;
        }
        
        inline void AddLinkedTransOpt(TranslationOption* to)
        {
                m_linkedTransOpts.push_back(to);
        }

        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

---