recognizer.h

Go to the documentation of this file.

// Copyright 2002-2013 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
/************************************************************************
 *
 * @file       recognizer.h
 * @author     besancon (besanconr@zoe.cea.fr)
 * @date       Tue Oct 15 2002
 * copyright   Copyright (C) 2002 by CEA LIST
 * Project     Automaton
 * 
 * @brief      recognizer for a certain type of expression : contains a
 * list of rules 
 * 
 ***********************************************************************/
 
#ifndef RECOGNIZER_H
#define RECOGNIZER_H
 
#include "AutomatonExport.h"
#include "rule.h"
#include "recognizerMatch.h"
#include "transitionUnit.h"
#include "transitionSearchStructure.h"
#include "automatonReaderWriter.h"
#include "linguisticProcessing/core/AnalysisDict/AbstractAnalysisDictionary.h"
#include "linguisticProcessing/core/LinguisticResources/AbstractResource.h"
#include "common/ProcessUnitFramework/AnalysisContent.h"
#include <stdexcept>
#include <map>
#include <set>
 
namespace Lima {
namespace LinguisticProcessing {
namespace Automaton {
 
enum OverlapResolutionStrategy {
  IGNORE_FIRST, 
  IGNORE_SECOND, 
  IGNORE_SMALLEST, 
  KEEP_ALL_OVERLAPS 
};
#define DEFAULT_OVERLAP_STRATEGY IGNORE_FIRST
 
// several rules are attached to one trigger
// -> maybe problems if a same unit is trigger of several rules with
//  different transition properties (nokeep, head...) : for the 
// moment, if leads to different triggers, hence problems for the index
// in the dictionary
 
typedef std::vector<Rule*> SetOfRules;
 
#define RECOGNIZER_CLASSID "AutomatonRecognizer"
 
class LIMA_AUTOMATON_EXPORT Recognizer : public AbstractResource
{
  Q_OBJECT
 
friend class AutomatonReader;
friend class AutomatonWriter;
 
 public:
  Recognizer(); 
  Recognizer(const Recognizer&);
  virtual ~Recognizer();
  Recognizer& operator = (const Recognizer&);
  
  // initialization function
  void init(
    Common::XMLConfigurationFiles::GroupConfigurationStructure& unitConfiguration,
    Manager* manager) override
  ;
  
  // access functions
  uint64_t numberOfRules() const;
 
  uint64_t addRuleInStorage(Rule* rule);
 
  uint64_t addRule(TransitionUnit* trigger, Rule* rule);
  
  void addRule(TransitionUnit* trigger, const uint64_t index);
 
  uint64_t apply(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                     const LinguisticGraphVertex& begin, 
                     const LinguisticGraphVertex& end,
                     AnalysisContent& analysis,
                     std::vector<RecognizerMatch>& result,
                     bool testAllVertices=false,
                     bool stopAtFirstSuccess=true,
                     bool onlyOneSuccessPerType=false,
                     bool returnAtFirstSuccess=false,
                     bool applySameRuleWhileSuccess=false) const;
  
  uint64_t apply(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                     const LinguisticGraphVertex& begin, 
                     const LinguisticGraphVertex& end,
                     const LinguisticGraphVertex& upstreamBound, 
                     const LinguisticGraphVertex& downstreamBound,
                     AnalysisContent& analysis,
                     std::vector<RecognizerMatch>& result,
                     bool testAllVertices,
                     bool stopAtFirstSuccess,
                     bool onlyOneSuccessPerType,
                     bool returnAtFirstSuccess,
                     bool applySameRuleWhileSuccess) const;
  
  uint64_t testOnVertex(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                            LinguisticGraphVertex& current,
                            const LinguisticGraphVertex& begin,
                            const LinguisticGraphVertex& end,
                            AnalysisContent& analysis,
                            std::vector<RecognizerMatch>& result,
                            bool stopAtFirstSuccess=true,
                            bool onlyOneSuccessPerType=false,
                            bool applySameRuleWhileSuccess=false) const;
  
    uint64_t 
      resolveOverlappingEntities(std::vector<RecognizerMatch>& listEntities,
                                 const OverlapResolutionStrategy& 
                                 strategy
                                 = DEFAULT_OVERLAP_STRATEGY) const;
  
  uint64_t testSetOfRules(const TransitionUnit& trigger,
                              const SetOfRules& rules,
                              const LinguisticAnalysisStructure::AnalysisGraph& graph,
                              const LinguisticGraphVertex& position,
                              const LinguisticGraphVertex& begin,
                              const LinguisticGraphVertex& end,
                              AnalysisContent& analysis,
                              std::vector<RecognizerMatch>& match,
                              std::set<Common::MediaticData::EntityType>* forbiddenTypes=0,
                              bool stopAtFirstSuccess=true,
                              bool onlyOneSuccessPerType=false,
                              bool applySameRuleWhileSuccess=false) const ;
 
  //read recognizer from a text file
  //void readFromTextFile(std::string filename);
 
  // output the list of triggers with their associated index
  void listTriggers() const;
 
  // text output
  friend LIMA_AUTOMATON_EXPORT std::ostream& operator << (std::ostream&, const Recognizer&);
 
  void initializeSearchStructure();
 
 //***************************************************************************
 protected:
  // set of transitions associated with a set of pointers
  // to rules
  class TriggerRule : public std::pair<TransitionUnit*, SetOfRules> {
  public:
    TriggerRule():
    std::pair<TransitionUnit*, SetOfRules>((TransitionUnit*)0,SetOfRules(0)) {}
    TriggerRule(TransitionUnit* t,const SetOfRules& s):
      std::pair<TransitionUnit*, SetOfRules>(t,s) {}
    ~TriggerRule() {}
    TransitionUnit* transitionUnit() const { return first; }
    void setTransitionUnit(TransitionUnit* t) { first=t; }
    const SetOfRules& setOfRules() const { return second; }
    SetOfRules& setOfRules() { return second; }
  };
  class CompareTriggerRule; // comparison function object on TriggerRule
 
  std::vector<TriggerRule> m_rules; 
  SetOfRules m_ruleStorage; // the place where the rules are actually 
                            //  stored (dont really need it, but make 
                            //  it simpler to free the memory)
  MediaId m_language;
 
  AutomatonControlParams m_automatonControlParams; 
 
  // for debug
  std::string m_filename;
 
  //************************************************************
  // a superstructure on top of m_rules to make the search faster
  TransitionSearchStructure<TriggerRule> m_searchStructure;
 
  void clearSearchStructure();
 
  // using TransitionSearchStructure
  void findNextSetOfRules(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                          LinguisticGraphVertex& vertex,
                          AnalysisContent& analysis,
                          const LinguisticAnalysisStructure::Token* token,
                          const LinguisticAnalysisStructure::MorphoSyntacticData* data, 
                          std::vector<TriggerRule*>& matchingSetOfRules) const;
  
  //**********************************************************************
  // helper functions for constructors and destructors
  void init();
  void copy(const Recognizer& a);
  void freeMem();
 
  void setNormalizedForm(const LimaString& norm,
                         RecognizerMatch& match) const ;
 
  // for the binary input/output
  uint64_t findRuleIndex(Rule*) const;
 
};
 
//**********************************************************************
// inline access functions
//**********************************************************************
inline uint64_t Recognizer::numberOfRules() const { 
  return m_rules.size();
}
 
} // namespace end
} // namespace end
} // namespace end
 
#endif