data.ssgrammar.hpp

Go to the documentation of this file.

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use these files except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Copyright 2012 - Gonzalo Iglesias, Adrià de Gispert, William Byrne

#ifndef SENTENCESPECIFICGRAMMARDATA_HPP
#define SENTENCESPECIFICGRAMMARDATA_HPP

namespace ucam {
namespace hifst {

struct SentenceSpecificGrammarData {

  SentenceSpecificGrammarData() 
      : grammar ( NULL )
  {}

  const GrammarData *grammar;

  ssgrammar_rulesmap_t rulesWithRhsSpan1;
  ssgrammar_rulesmap_t  rulesWithRhsSpan2OrMore;

  unordered_map<std::size_t, std::string> extrarules;

  inline void reset() {
    rulesWithRhsSpan1.clear();
    rulesWithRhsSpan2OrMore.clear();
    extrarules.clear();
    grammar = NULL;
  }

  inline const std::string getRule ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRule ( idx );
    LINFO ( "ssgrammar idx=" << idx );
    return extrarules[idx];
  };

  inline const std::string getLHS ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getLHS ( idx );
    std::size_t pos = extrarules[idx].find_first_of ( " " );
    return extrarules[idx].substr ( 0, pos );
  };

  inline const std::string getRHSSource ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSSource ( idx );
    std::size_t pos = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos2 = extrarules[idx].find_first_of ( " ", pos );
    return extrarules[idx].substr ( pos, pos2 - pos );
  };

  inline const std::string getRHSSource ( std::size_t idx, uint rulepos ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSSource ( idx, rulepos );
    std::size_t pos = extrarules[idx].find_first_of ( " " );
    std::size_t j = pos , jold;
    for ( uint k = 0; k <= rulepos; ++k ) {
      jold = j;
      j = extrarules[idx].find_first_of ( "_ ", jold + 1 );
      if ( j == std::string::npos )
        if ( rulepos ) return "";
    }
    return extrarules[idx].substr ( jold + 1, j - jold - 1 );
  };

  inline const std::vector<std::string> getRHSSplitSource ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSSplitSource ( idx );
    std::vector<std::string> splitsource;
    boost::algorithm::split ( splitsource, getRHSSource ( idx ),
                              boost::algorithm::is_any_of ( "_" ) );
    return splitsource;
  };

  inline const uint getRHSSourceSize ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSSourceSize ( idx );
    std::size_t pos  = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos1 = extrarules[idx].find_first_of ( " " , pos ) + 1;
    return ucam::util::count_needles ( extrarules[idx], '_', pos, pos1 ) + 1 ;
  };

  inline const std::string getRHSTranslation ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSTranslation ( idx );
    std::size_t pos  = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos1 = extrarules[idx].find_first_of ( " ", pos ) + 1;
    std::size_t pos2 = extrarules[idx].find_first_of ( " ", pos1 );
    return extrarules[idx].substr ( pos1, pos2 - pos1 );
  };

  inline const std::vector<std::string> getRHSSplitTranslation (
    std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSSplitTranslation ( idx );
    std::vector<std::string> splittranslation;
    boost::algorithm::split ( splittranslation, getRHSTranslation ( idx ),
                              boost::algorithm::is_any_of ( "_" ) );
    return splittranslation;
  };

  inline const uint getRHSTranslationSize ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getRHSTranslationSize ( idx );
    std::size_t pos  = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos1 = extrarules[idx].find_first_of ( " ", pos ) + 1;
    std::size_t pos2 = extrarules[idx].find_first_of ( " ", pos1 );
    return ucam::util::count_needles ( extrarules[idx], '_', pos1, pos2 ) + 1;
  };

  inline const float getWeight ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getWeight ( idx );
    std::size_t pos  = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos1 = extrarules[idx].find_first_of ( " ", pos );
    std::size_t pos2 = extrarules[idx].find_first_of ( " ", pos1 + 1 );
    std::size_t pos3 = extrarules[idx].find_first_of ( " \n\0", pos2 + 1 );
    return ucam::util::toNumber<float> ( extrarules[idx].substr ( pos2,
                                         pos3 - pos2 ) );
  };

  void getLinks(std::size_t idx
                , std::vector<unsigned> &links) const {
    if ( extrarules.find ( idx ) == extrarules.end() ) {
      grammar->getLinks ( idx , links);
      return;
    }
    LERROR("Untested code");
    exit(EXIT_FAILURE);
    // std::size_t pos  = extrarules[idx].find_first_of ( " " ) + 1;
    // std::size_t pos1 = extrarules[idx].find_first_of ( " " , pos) + 1;
    // std::size_t pos2 = extrarules[idx].find_first_of ( " ", pos1) + 1;
    // std::size_t pos3 = extrarules[idx].find_first_of ( " \n\0", pos2);
    // if (extrarules[idx][pos3] == ' ') {
    //   std::size_t pos4 = extrarules[idx].find_first_of ( " \n\0", pos3 + 1 );
    //   return extrarules[idx].substr ( pos3, pos4 - pos3 );
    // }
    // return ""; // no affiliation or links
  }




  inline const bool isPhrase ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->isPhrase ( idx );
    std::size_t pos0  = extrarules[idx].find_first_of ( " " ) + 1;
    std::size_t pos = extrarules[idx].find_first_of ( " ", pos0 );
    for ( const char *c = extrarules[idx].c_str() + pos0;
          c <= extrarules[idx].c_str() + pos; ++c )
      if ( *c >= 'A' && *c <= 'Z' ) return false; //has non-terminals.
    return true; //pure phrase.
  };
  inline const std::size_t getIdx ( std::size_t idx ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->getIdx ( idx );
    return idx;
  };

  inline const bool isAcceptedByVocabulary ( const std::size_t idx,
      const unordered_set<std::string>& vcb ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      return grammar->isAcceptedByVocabulary ( idx, vcb );
    return true;
  };

  inline void getMappings ( std::size_t idx,
                            unordered_map<uint, uint> *mappings ) {
    if ( extrarules.find ( idx ) == extrarules.end() )
      grammar->getMappings ( idx, mappings );
    if ( isPhrase ( idx ) ) return;
    std::vector<std::string> source = getRHSSplitSource ( idx );
    std::vector<std::string> translation = getRHSSplitTranslation ( idx );
    getRuleMappings ( source, translation, mappings );
  };
};

inline bool phraseIsTerminalWord ( const std::string& phrase ) {
  for ( uint k = 0; k < phrase.size(); ++k ) {
    if ( phrase[k] >= 'A' && phrase[k] <= 'Z' ) return false;
    else if ( phrase[k] == '_' ) return false;
  }
  return true;
};

}
}  // end namespaces

#endif