data.cykparser.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 CYKDATA_HPP
#define CYKDATA_HPP

#include "data.cykparser.cykgrid.hpp"
#include "data.cykparser.cykbackpointers.hpp"

namespace ucam {
namespace hifst {
struct CYKdata {

  cykparser_sentence_t sentence;

  grammar_categories_t categories;

  grammar_inversecategories_t vcat;

  CYKgrid cykgrid;

  CYKbackpointers bp;

  uint success;

  cykparser_ruledependencies_t rd;

  uint nnt;

  // Non-terminals are bounded by a maximum span threshold (i.e. typically --hifst.hrmaxspan=10).
  // However, certain non-terminals in a hiero-style grammar
  // must be able to reach higher spans. Most notably, this is the case of non-terminal S, used as glue rule.
  // The list of exceptions are included in nt_exceptions_maxspan.
  unordered_set<std::string> nt_exceptions_maxspan;

  int freeMemory() {
    for ( unsigned int k = 0; k < rd.size(); k++ ) {
      rd[k].clear();
    }
    rd.clear();
    cykgrid.reset();
    bp.reset();
    categories.clear();
    vcat.clear();
    sentence.clear();
    success = 0;
    nnt = 0;
    return 0;
  };

  inline uint getNumberWordsSentence() {
    return sentence.size();
  };

  void storeRules ( unordered_map<uint, std::vector<uint> >& c ) {
    for ( unsigned int cc = 1; cc <= nnt; cc++ ) {
      for ( unsigned int x = 0; x < sentence.size(); x++ ) {
        for ( unsigned int y = 0; y < sentence.size() - x; y++ ) {
          for ( unsigned int k = 0; k < cykgrid ( cc, x, y ).size(); ++k )
            c[cc * 1000000 + y * 1000 + x].push_back ( cykgrid ( cc, x, y, k ) );
        }
      }
    }
  };

  void storeRuleCounts ( unordered_map<uint, uint>& c ) {
    for ( unsigned int cc = 1; cc <= nnt; cc++ ) {
      for ( unsigned int x = 0; x < sentence.size(); x++ ) {
        for ( unsigned int y = 0; y < sentence.size() - x; y++ ) {
          if ( cykgrid ( cc, x, y ).size() )
            c[cc * 1000000 + y * 1000 + x] = cykgrid ( cc, x, y ).size();
        }
      }
    }
  };

};

}
} // end namespaces

#endif