CompoundTokenAnnotation.h

Go to the documentation of this file.

// Copyright 2002-2022 CEA LIST
// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
#ifndef LIMA_LINGUISTICPROCESSING_COMPOUNDS_COMPOUNDTOKENANNOTATION_H
#define LIMA_LINGUISTICPROCESSING_COMPOUNDS_COMPOUNDTOKENANNOTATION_H
 
#include "CompoundsExport.h"
#include "linguisticProcessing/common/annotationGraph/GenericAnnotation.h"
#include "linguisticProcessing/common/annotationGraph/AnnotationData.h"
#include "linguisticProcessing/core/Automaton/recognizerMatch.h"
 
 
#include <vector>
 
#ifdef WIN32
#undef min
#undef max
#endif
namespace Lima
{
 
namespace LinguisticProcessing
{
 
namespace Compounds
{
 
//enum SemanticTypes {
//  Determiner, /**< Used for determiners as articles, pronouns, etc. */
//  SemanticModifier, /**< Used for modifiers as adverbs */
//  Complementer /**< Used for complementers like noun complements or adjectives */
//};
 
class LIMA_COMPOUNDS_EXPORT ConceptModifier
{
public:
 
  ConceptModifier();
  ConceptModifier(const StringsPoolIndex& realization,
                          const Common::MediaticData::ConceptType type
                              = Common::MediaticData::ConceptType(std::numeric_limits< uint32_t >::max()),
                          const std::vector< uint64_t >& references
                          = std::vector< uint64_t>());
 
  virtual ~ConceptModifier();
 
 
  void dump(std::ostream& os,const FsaStringsPool& sp) const;
 
  inline StringsPoolIndex getRealization() const;
//   inline void setRealization(StringsPoolIndex realization);
  inline Common::MediaticData::ConceptType getConceptType() const;
  inline void setConceptType(Common::MediaticData::ConceptType type);
  inline const std::vector< uint64_t >& getReferencedAnnotations() const;
  std::vector< uint64_t >& getReferencedAnnotations();
  inline void setReferencedAnnotations(const std::vector< uint64_t >& references);
  inline int32_t getIntensity() const;
  inline void setIntensity(int32_t intensity);
 
private:
  StringsPoolIndex m_realization; 
  Common::MediaticData::ConceptType m_conceptType; 
  std::vector< uint64_t> m_referencedAnnotations; 
  int32_t m_intensity; 
};
 
 
class LIMA_COMPOUNDS_EXPORT CompoundTokenAnnotation : public std::vector< ConceptModifier >
{
public:
  CompoundTokenAnnotation() {}
  virtual ~CompoundTokenAnnotation() {}
 
  void dump(std::ostream& os,const FsaStringsPool& sp);
};
 
class LIMA_COMPOUNDS_EXPORT DumpCompoundTokenAnnotation : public Common::AnnotationGraphs::AnnotationData::Dumper {
public:
 
  DumpCompoundTokenAnnotation(const FsaStringsPool& sp) : m_sp(sp) {};
 
  virtual int dump(
      std::ostream& os,
      Common::AnnotationGraphs::GenericAnnotation& ga) const override;
 
private:
  const FsaStringsPool& m_sp;
};
 
 
inline StringsPoolIndex ConceptModifier::getRealization() const
{
  return m_realization;
}
 
// inline void ConceptModifier::setRealization(StringsPoolIndex realization)
// {
//   m_realization = realization;
// }
 
inline Common::MediaticData::ConceptType ConceptModifier::getConceptType() const
{
  return m_conceptType;
}
 
inline void ConceptModifier::setConceptType(Common::MediaticData::ConceptType type)
{
  m_conceptType = type;
}
 
inline const std::vector< uint64_t >& ConceptModifier::getReferencedAnnotations() const
{
  return m_referencedAnnotations;
}
 
inline std::vector< uint64_t >& ConceptModifier::getReferencedAnnotations()
{
  return m_referencedAnnotations;
}
 
inline void ConceptModifier::setReferencedAnnotations(const std::vector< uint64_t >& references)
{
  m_referencedAnnotations = references;
}
 
inline int32_t ConceptModifier::getIntensity() const
{
  return m_intensity;
}
 
inline void ConceptModifier::setIntensity(int32_t intensity)
{
  m_intensity = intensity;
}
 
} // Compounds
} // LinguisticProcessing
} // Lima
 
#endif