AnalysisGraph.h

Go to the documentation of this file.

// Copyright 2002-2020 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
/***************************************************************************
 *   Copyright (C) 2004-2020 by CEA LIST                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef LIMA_LINGUISTICPROCESSING_LINGUISTICANALYSISSTRUCTUREANALYSISGRAPH_H
#define LIMA_LINGUISTICPROCESSING_LINGUISTICANALYSISSTRUCTUREANALYSISGRAPH_H
 
 
#include "LinguisticAnalysisStructureExport.h"
#include "LinguisticGraph.h"
#include "common/ProcessUnitFramework/AnalysisContent.h"
#include "linguisticProcessing/common/PropertyCode/PropertyAccessor.h"
 
namespace Lima
{
namespace Common
{
namespace AnnotationGraphs
{
  class AnnotationData;
}
}
namespace LinguisticProcessing
{
}
}
 
namespace Lima
{
 
namespace LinguisticProcessing
{
 
namespace LinguisticAnalysisStructure
{
 
class LIMA_LINGUISTICANALYSISSTRUCTURE_EXPORT AnalysisGraph : public AnalysisData
{
public:
  AnalysisGraph(const std::string& graphId,
  MediaId language,
  bool deleteTokenWhenDestroyed,
  bool deleteDataWhenDestroyed);
  AnalysisGraph(const std::string& graphId,
  MediaId language,
  bool deleteTokenWhenDestroyed,
  bool deleteDataWhenDestroyed,
  const AnalysisGraph& graph);
 
  virtual ~AnalysisGraph();
 
  const LinguisticGraphVertex& firstVertex(void) const { return m_firstVertex; }
 
  const LinguisticGraphVertex& lastVertex(void) const { return m_lastVertex; }
 
  const LinguisticGraph* getGraph(void) const { return m_graph; }
 
  LinguisticGraph* getGraph(void) { return m_graph; }
 
  const std::string& getGraphId(void) const { return m_graphId; }
 
  LinguisticGraphVertex nextMainPathVertex(
    LinguisticGraphVertex start,
    const Common::PropertyCode::PropertyAccessor& microAccessor,
    const std::list<LinguisticCode> microFilters,
    LinguisticGraphVertex end);
 
  LinguisticGraphVertex nextChainsBreakFrom(
    const LinguisticGraphVertex& v,
    const Common::PropertyCode::PropertyAccessor& macroAccessor,
    const LinguisticCode& ponctu,
    const Common::PropertyCode::PropertyAccessor& microAccessor,
    LinguisticGraphVertex& nextSentenceBreak);
 
    //bool isFirstWordOfSentence(const LinguisticGraphVertex& v, MediaId language) const;
 
    void populateAnnotationGraph(
                   Common::AnnotationGraphs::AnnotationData* annotData,
                   const std::string& src);
 
  inline bool ownsTokens() const {return m_deleteTokenWhenDestroyed;}
 
  inline bool ownsMorphData() const {return m_deleteDataWhenDestroyed;}
 
private:
 
  AnalysisGraph(const AnalysisGraph&);
  AnalysisGraph& operator = (const AnalysisGraph&);
  void createGraph();
 
  void deleteGraph();
 
  LinguisticGraph* m_graph;
 
  LinguisticGraphVertex m_firstVertex;
 
  LinguisticGraphVertex m_lastVertex;
 
  bool m_deleteTokenWhenDestroyed;
 
  bool m_deleteDataWhenDestroyed;
 
  MediaId m_language;
  std::string m_graphId;
};
 
 
template<class T> inline
void getFollowingNodes(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                       const LinguisticGraphVertex v,
                       T& output_container)
{
  LinguisticGraphOutEdgeIt outEdge,outEdge_end;
  boost::tie (outEdge,outEdge_end)=out_edges(v,*(graph.getGraph()));
  for (; outEdge!=outEdge_end; outEdge++)
  {
    output_container.insert(target(*outEdge,*(graph.getGraph())));
  }
}
 
template<class T> inline
T getFollowingNodes(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                    const LinguisticGraphVertex v)
{
  T followingNodes;
  getFollowingNodes<T>(graph, v, followingNodes);
  return followingNodes;
}
 
inline
LinguisticGraphVertex getOneFollowingNode(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                                          const LinguisticGraphVertex v)
{
  LinguisticGraphOutEdgeIt outEdge,outEdge_end;
  boost::tie (outEdge,outEdge_end)=out_edges(v,*(graph.getGraph()));
  LinguisticGraphVertex result;
  while (outEdge!=outEdge_end)
  {
    result=target(*outEdge,*(graph.getGraph()));
    outEdge++;
    if (outEdge!=outEdge_end)
    {
      throw std::logic_error("getOneFollowingNode assumes that there is one and only one following node. Multiple nodes detected.");
    }
    return result;
  }
 
  throw std::logic_error("getOneFollowingNode assumes that there is one and only one following node. No preceding nodes found.");
}
 
template<class T> inline
void getPrecedingNodes(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                       const LinguisticGraphVertex& v,
                       T& output_container)
{
  LinguisticGraphInEdgeIt inEdge,inEdge_end;
  boost::tie (inEdge,inEdge_end)=in_edges(v,*(graph.getGraph()));
  for (; inEdge!=inEdge_end; inEdge++)
  {
    output_container.insert(source(*inEdge,*(graph.getGraph())));
  }
}
 
template<class T> inline
T getPrecedingNodes(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                    const LinguisticGraphVertex v)
{
  T precedingNodes;
  getPrecedingNodes<T>(graph, v, precedingNodes);
  return precedingNodes;
}
 
inline
LinguisticGraphVertex getOnePrecedingNode(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                                          const LinguisticGraphVertex v)
{
  LinguisticGraphInEdgeIt inEdge,inEdge_end;
  boost::tie (inEdge,inEdge_end)=in_edges(v,*(graph.getGraph()));
  LinguisticGraphVertex result;
  while (inEdge!=inEdge_end)
  {
    result=source(*inEdge,*(graph.getGraph()));
    inEdge++;
    if (inEdge!=inEdge_end)
    {
      throw std::logic_error("getOnePrecedingNode assumes that there is one and only one preceding node. Multiple nodes detected.");
    }
    return result;
  }
 
  throw std::logic_error("getOnePrecedingNode assumes that there is one and only one preceding node. No preceding nodes found.");
}
 
}
 
}
 
}
 
#endif