constraint.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       constraint.h
 * @author     besancon (besanconr@zoe.cea.fr)
 * @date       Tue Nov 26 2002
 * copyright   Copyright (C) 2002 by CEA LIST
 * Project     Automaton
 * 
 * @brief      this class is the description of the constraints applied 
 * on the transitions of the automata
 * 
 * 
 ***********************************************************************/
 
#ifndef CONSTRAINT_H
#define CONSTRAINT_H
 
#include "AutomatonExport.h"
#include "constraintFunction.h"
#include "constraintCheckList.h"
#include "automatonReaderWriter.h"
#include "linguisticProcessing/core/LinguisticAnalysisStructure/AnalysisGraph.h"
#include "common/ProcessUnitFramework/AnalysisContent.h"
#include "common/Data/LimaString.h"
#include <vector>
#include <fstream>
 
namespace Lima {
namespace LinguisticProcessing {
namespace Automaton {
 
class LIMA_AUTOMATON_EXPORT Constraint
{
friend class AutomatonReader;
friend class AutomatonWriter;
 
 public:
  Constraint(); 
  Constraint(const uint64_t i, 
             const std::string& functionName, 
             const ConstraintAction a,
             MediaId language,
             const LimaString& complement=LimaString(),
             const bool negative=false); 
  Constraint(const Constraint&);
  ~Constraint();
  Constraint& operator = (const Constraint&);
  
  friend LIMA_AUTOMATON_EXPORT std::ostream& operator << (std::ostream&, const Constraint&);
  friend LIMA_AUTOMATON_EXPORT QDebug& operator << (QDebug&, const Constraint&);
  friend bool operator == (const Constraint&,const Constraint&);
 
  static const uint64_t noindex=UINT_MAX;
 
  void reinit();
  
  uint64_t index() const;
  ConstraintFunction* functionAddr() const;
  std::string functionName() const;
  ConstraintAction action() const;
  LimaString str() const;
  void setIndex(const uint64_t);
  void setFunctionAddr(ConstraintFunction* f);
  void setAction(const ConstraintAction);
 
  bool checkConstraint(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                       const LinguisticGraphVertex& vertex,
                       AnalysisContent& analysis,
                       ConstraintCheckList& constraintCheckList) const;
 
  bool apply(const LinguisticAnalysisStructure::AnalysisGraph& graph,
             AnalysisContent& analysis,
             ConstraintCheckList& constraintCheckList,
             const bool success,
             RecognizerMatch* result) const;
 
 private:
  uint64_t m_index;  
  ConstraintFunction* m_functionAddr; 
  ConstraintAction m_action;  
  bool m_negative;              
  // private functions 
  void writeConstraintAction(std::ofstream& file,
                             const ConstraintAction& a);
  ConstraintAction readConstraintAction(std::ifstream& file);
 
  // for debug output
  std::string checkStringDebug(const LinguisticAnalysisStructure::AnalysisGraph& graph,
                               const LinguisticGraphVertex vertex) const;
  std::string applyStringDebug(const LinguisticGraphVertex firstArg=0,
                               const LinguisticGraphVertex secondArg=0) const;
  std::string actionString() const;
  
};
 
//**********************************************************************
// inline functions
inline uint64_t Constraint::index() const { return m_index; }
inline ConstraintAction Constraint::action() const { return m_action; }
inline void Constraint::setIndex(const uint64_t i) { m_index = i; }
inline void Constraint::setAction(const ConstraintAction a) { m_action = a; }
 
inline ConstraintFunction* Constraint::functionAddr() const { 
  return m_functionAddr; 
}
inline void Constraint::setFunctionAddr(ConstraintFunction* f) { 
  m_functionAddr=f; 
}
 
 
 
} // end namespace
} // end namespace
} // end namespace
 
 
#endif