SyntacticData.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
 
// clazy:exclude=rule-of-two-soft
 
 
#ifndef LIMA_SYNTACTICANALYSIS_SYNTACTICDATA_H
#define LIMA_SYNTACTICANALYSIS_SYNTACTICDATA_H
 
#include "SyntacticAnalysisExport.h"
#include "DependencyGraph.h"
#include "linguisticProcessing/core/LinguisticAnalysisStructure/LinguisticGraph.h"
#include "linguisticProcessing/core/LinguisticAnalysisStructure/AnalysisGraph.h"
#include "linguisticProcessing/common/linguisticData/languageData.h" // for SyntacticRelationId
#include "common/ProcessUnitFramework/AnalysisContent.h"
 
#include <tuple>
 
namespace Lima {
namespace LinguisticProcessing {
 
namespace LinguisticAnalysisStructure
{
  class Token;
  class MorphoSyntacticData;
}
 
namespace SyntacticAnalysis {
 
class SyntagmDefStruct;
 
class LIMA_SYNTACTICANALYSIS_EXPORT SyntacticData : public AnalysisData
{
public:
typedef std::tuple< LinguisticGraphVertex, LinguisticGraphVertex, Common::MediaticData::SyntacticRelationId > Relation;
 
    SyntacticData(LinguisticAnalysisStructure::AnalysisGraph* pit, std::shared_ptr<SyntagmDefStruct> matrices);
 
    virtual ~SyntacticData();
 
    inline LinguisticGraph* graph() {return m_graph;}
    inline const LinguisticGraph* graph() const {return m_graph;}
 
    inline DependencyGraph* dependencyGraph() {return m_depGraph;}
    inline const DependencyGraph* dependencyGraph() const {return m_depGraph;}
 
    inline LinguisticAnalysisStructure::AnalysisGraph* iterator() {return m_anagraph;}
    inline const LinguisticAnalysisStructure::AnalysisGraph* iterator() const {return m_anagraph;}
 
    inline std::shared_ptr<SyntagmDefStruct> matrices() const {return m_matrices;}
    inline void matrices(std::shared_ptr<SyntagmDefStruct> matrices) {m_matrices=matrices;}
 
  inline std::vector<LinguisticAnalysisStructure::Token*>& ownedTokens() {return m_ownedTokens;}
  inline std::vector<LinguisticAnalysisStructure::MorphoSyntacticData*>& ownedMorphosyntacticData() {return m_ownedMorphData;}
  
    DependencyGraphVertex depVertexForTokenVertex(const LinguisticGraphVertex& v) const;
    LinguisticGraphVertex tokenVertexForDepVertex(const DependencyGraphVertex& v) const;
 
    uint64_t depsBetween(
        const LinguisticGraphVertex& srcVertex, 
        const LinguisticGraphVertex& tgtVertex);
    void setupDependencyGraph();
 
    std::vector<LinguisticGraphVertex> 
      findRelated(const LinguisticGraphVertex,
                  const Common::MediaticData::SyntacticRelationId& relation);
 
    std::vector<LinguisticGraphVertex> 
      findRelated(const LinguisticGraphVertex,
                  const std::set<Common::MediaticData::SyntacticRelationId>& relations);
 
 
    inline void clearStoredRelations() {m_relations.clear();}
    
    inline Relation relation()
    {
      if (m_relations.empty()) {
          return std::make_tuple(m_anagraph->firstVertex(), m_anagraph->lastVertex(), 0);
      }
        else
        {
          Relation r = m_relations.front(); // clazy:exclude=rule-of-two-soft
          m_relations.pop_front();
          return r;
        }
    }
 
    inline bool relation(const LinguisticGraphVertex& v1, 
                         const LinguisticGraphVertex& v2,
                         const Common::MediaticData::SyntacticRelationId relationType=0)
    {
//        SALOGINIT;
        Relation r = std::make_tuple(v1,v2,relationType);
      if (m_relations.empty() || !(m_relations.front() == r))
        {
          m_relations.push_back(r);
          return true;
        }
        else
        {
          return false;
        }  
    };
 
    std::pair<LinguisticGraphVertex, DependencyGraphVertex> addVertex();
 
    void addRelationNoChain(const Common::MediaticData::SyntacticRelationId& relType, 
                            const LinguisticGraphVertex& src, 
                            const LinguisticGraphVertex& dest);
 
    void modifyRelationNoChain(const Common::MediaticData::SyntacticRelationId& relType, 
                            const LinguisticGraphVertex& src, 
                            const LinguisticGraphVertex& dest,
                            const Common::MediaticData::SyntacticRelationId& newType);
                                
    inline bool storeRelationForSelectionalConstraint(const LinguisticGraphVertex& v1,
                          const LinguisticGraphVertex& v2,
                          const Common::MediaticData::SyntacticRelationId relationType=0)
    {
      m_relationStoredForSelectionalConstraint = std::make_tuple(v1,v2,relationType);
      return true;
    };
 
    inline Relation relationStoredForSelectionalConstraint()
    {
      return m_relationStoredForSelectionalConstraint; // clazy:exclude=rule-of-two-soft
    };
 
    bool removeDependency(const LinguisticGraphVertex& v1,
                          const LinguisticGraphVertex& v2,
                          const Common::MediaticData::SyntacticRelationId relationType=0);
 
  private:
    LinguisticAnalysisStructure::AnalysisGraph* m_anagraph;
 
    LinguisticGraph* m_graph;
 
    DependencyGraph* m_depGraph;
 
    std::shared_ptr<SyntagmDefStruct> m_matrices;
 
    std::pair<
        std::map< LinguisticGraphVertex, DependencyGraphVertex >,
        std::map< DependencyGraphVertex, LinguisticGraphVertex > > m_mapping;
 
    std::list< Relation > m_relations;
  
  std::vector<LinguisticAnalysisStructure::Token*> m_ownedTokens;
  std::vector<LinguisticAnalysisStructure::MorphoSyntacticData*> m_ownedMorphData;
 
  Relation m_relationStoredForSelectionalConstraint;
};
 
} // closing namespace SyntacticAnalysis
} // closing namespace LinguisticProcessing
} // closing namespace Lima
 
#endif