ChainsDisambiguator.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
 
#ifndef LIMA_LINGUISTICPROCESSING_SYNTACTICANALYSIS_CHAINSDISAMBIGUATOR_H
#define LIMA_LINGUISTICPROCESSING_SYNTACTICANALYSIS_CHAINSDISAMBIGUATOR_H
 
#include "SyntacticAnalysisExport.h"
#include "linguisticProcessing/core/LinguisticAnalysisStructure/LinguisticGraph.h"
#include "linguisticProcessing/core/LinguisticAnalysisStructure/ChainIdStruct.h"
#include "linguisticProcessing/core/SyntacticAnalysis/SyntacticData.h"
#include "common/MediaticData/mediaticData.h"
#include "linguisticProcessing/common/PropertyCode/PropertyAccessor.h"
 
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <stdexcept>
 
#ifdef WIN32
#undef min
#undef max
#endif
 
namespace Lima {
namespace LinguisticProcessing {
namespace SyntacticAnalysis {
 
#define SADLOGINIT  LOGINIT("LP::SyntacticAnalysis::Disamb")
 
class LIMA_SYNTACTICANALYSIS_EXPORT Elem
{
public:
  Elem(uint64_t id, unsigned char type=0) : m_id(id), m_type(type) {}
  Elem(const Elem& elem) : m_id(elem.m_id), m_type(elem.m_type), m_elems(elem.m_elems) {}
  virtual ~Elem() {}
  Elem& operator=(const Elem& elem);
  
  inline uint64_t id() const {return m_id;}
  
  inline unsigned char type() const {return m_type;}
  
  inline const std::vector< uint64_t >& elems() const {return m_elems;}
  
  inline std::vector< uint64_t >& elems() {return m_elems;}
  
private:
  uint64_t m_id;
  unsigned char m_type;
  std::vector< uint64_t > m_elems;
};
 
class LIMA_SYNTACTICANALYSIS_EXPORT Key
{
public:
  Key(uint64_t id, const std::set< uint64_t>& chainsToIgnore = std::set< uint64_t>()) : 
      m_id(id), m_chainsToIgnore(chainsToIgnore) {}
      
  Key(const Key& key) : m_id(key.m_id), m_chainsToIgnore(key.m_chainsToIgnore) {}
  
  virtual ~Key() {}
  
  Key& operator=(const Key& key);
  
  inline uint64_t id() const {return m_id;}
  inline const std::set< uint64_t >& chainsToIgnore() const {return m_chainsToIgnore;}
  inline std::set< uint64_t >& chainsToIgnore() {return m_chainsToIgnore;}
   
   
private:
  uint64_t m_id;
  std::set< uint64_t > m_chainsToIgnore;
};
 
class LIMA_SYNTACTICANALYSIS_EXPORT Path 
{
public:
  Path(
    uint64_t id, 
    const std::set< uint64_t>& chainsToIgnore, 
    unsigned char type=0,
    uint64_t chainId=std::numeric_limits<uint64_t>::max());
    
  Path(const Path& path);
  
  virtual ~Path() {}
  
  Path& operator=(const Path& path);
  
  bool operator<(const Path& path) const;
  
  inline const Key& key() const {return m_key;}
  inline const std::list< Elem >& elems() const {return m_elems;}
  inline uint64_t idealConjVerbNb() const {return m_idealConjVerbNb;}
  inline uint64_t conjVerbNb() const {return m_conjVerbNb;}
  inline uint64_t outChainsWordsNb() const {return m_outChainsWordsNb;}
  inline uint64_t chainsNb() const {return m_chainsNb;}
  inline Key& key() {return m_key;}
  inline std::list< Elem >& elems() {return m_elems;}
  inline uint64_t& idealConjVerbNb() {return m_idealConjVerbNb;}
  inline uint64_t& conjVerbNb() {return m_conjVerbNb;}
  inline uint64_t& outChainsWordsNb() {return m_outChainsWordsNb;}
  inline uint64_t& chainsNb() {return m_chainsNb;}
  inline void key(const Key& key) {m_key = key;}
  inline void elems(const std::list< Elem >& elems) {m_elems = elems;}
  inline void idealConjVerbNb(uint64_t idealConjVerbNb) {m_idealConjVerbNb = idealConjVerbNb;}
  inline void conjVerbNb(uint64_t conjVerbNb) {m_conjVerbNb = conjVerbNb;}
  inline void outChainsWordsNb(uint64_t outChainsWordsNb) {m_outChainsWordsNb = outChainsWordsNb;}
  inline void chainsNb(uint64_t chainsNb) {m_chainsNb = chainsNb;}
  inline void depsNb(uint64_t depsNb) { m_depsNb = depsNb; }
  inline uint64_t depsNb() const { return m_depsNb; }
  
  void updateParams(
      const LinguisticCode& microCateg, 
      bool incrChainsNb, 
      bool incrOutChainsWordsNb,
      MediaId language);
      
private:
  Key m_key;
  std::list< Elem > m_elems;
  
 
  uint64_t m_idealConjVerbNb;
  uint64_t m_conjVerbNb;
  uint64_t m_outChainsWordsNb;
  uint64_t m_chainsNb;
  uint64_t m_depsNb;
};
 
class LIMA_SYNTACTICANALYSIS_EXPORT ChainsDisambiguator
{
public:
  ChainsDisambiguator(SyntacticData* data,
                      const LinguisticGraphVertex& s,
                      const LinguisticGraphVertex& t,
                      MediaId language,
                      uint64_t depGraphMaxBranchingFactor);
 
  ChainsDisambiguator(const ChainsDisambiguator& cd);
  
  virtual ~ChainsDisambiguator() {}
  
  ChainsDisambiguator& operator=(const ChainsDisambiguator& cd);
  
  void initPaths();
  
  void computePaths();
  
  void applyDisambiguisation();
  
private:
 
  
  void cancelCurrentChain(Elem elem, Path& hyp);
  
  
  void startWithSeveralChainsOnNewVertex(
      LinguisticGraphVertex nextVertex,
      const std::set< LinguisticAnalysisStructure::ChainIdStruct >& nextVertexChains, 
      const Path& currentHyp);
  
  uint64_t computeDepsNb(const Path& path);
  
  std::deque< Path > m_hypsStack;
  
  std::multiset< Path > m_completePaths;
  
  SyntacticData* m_data;
  
  LinguisticGraphVertex m_srcVertex;
  
  LinguisticGraphVertex m_tgtVertex;
  
  MediaId m_language;
  
  uint64_t m_depGraphMaxBranchingFactor;
  
  const Common::PropertyCode::PropertyAccessor* m_microAccessor;
};
 
LIMA_SYNTACTICANALYSIS_EXPORT std::ostream& operator<<(std::ostream &os, const Key& k);
LIMA_SYNTACTICANALYSIS_EXPORT std::ostream& operator<<(std::ostream &os, const Elem& e);
LIMA_SYNTACTICANALYSIS_EXPORT std::ostream& operator<<(std::ostream &os, const Path& p);
 
} // closing namespace SyntacticAnalysis
} // closing namespace LinguisticProcessing
} // closing namespace Lima
 
#endif // LIMA_LINGUISTICPROCESSING_SYNTACTICANALYSIS_CHAINSDISAMBIGUATOR_H