DocumentElements.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022 CEA LIST <gael.de-chalendar@cea.fr>
//
// SPDX-License-Identifier: MIT
 
/************************************************************************
 * @file   DocumentElements.h
 * @author Besancon Romaric
 * @date   Wed Oct 29 13:22:02 2003
 * @author Gael de Chalendar
 * @date   Wed Apr 08 2015
 ***********************************************************************/
 
#include "documentsreader_export.h"
#include "linguisticProcessing/LinguisticProcessingCommon.h"
#include "common/Data/LimaString.h"
#include "common/Data/genericDocumentProperties.h"
#include "documentProperty.h"
#include "linguisticProcessing/core/StructuredXmlDocumentHandler.h"
 
#include <deque>
#include <string>
 
#include <QtCore/QTextStream>
 
 
#ifndef DOCUMENTELEMENTS_H
#define DOCUMENTELEMENTS_H
 
namespace Lima {
namespace DocumentsReader {
 
typedef enum
{
    NODE_NOTYPE,       
    NODE_ROOT,         
    NODE_DISCARDABLE,  
    NODE_INDEXING,     
    NODE_HIERARCHY,    
    NODE_PRESENTATION, 
    NODE_IGNORED,      
    NODE_PROPERTY,     
} FieldType;
 
 
class DOCUMENTSREADER_EXPORT AbstractDocumentElement {
public:
  virtual ~AbstractDocumentElement() {}
 
  virtual bool isDiscarding() {return false;}
  virtual bool isPresentation() {return false;}
 
  virtual FieldType nodeType() {return NODE_NOTYPE;}
};
 
class DOCUMENTSREADER_EXPORT ContentElementPart : public AbstractDocumentElement, public std::pair<Lima::LimaString,unsigned int> {
public:
  ContentElementPart():std::pair<Lima::LimaString,unsigned int>(Lima::LimaString(),0) {}
  ContentElementPart(const Lima::LimaString& text, const unsigned int offset)
   : std::pair<Lima::LimaString,unsigned int>(text,offset) {}
  ~ContentElementPart() {}
  void addText(const Lima::LimaString& text) { first.append(text); }
  const Lima::LimaString& getText(void) const { return first; }
  unsigned int getOffset(void) const { return second; }
  Lima::LimaString& getText(void) { return first; }
};
 
class DOCUMENTSREADER_EXPORT AbstractStructuredDocumentElement : public AbstractDocumentElement, public std::deque<ContentElementPart*> {
public:
  virtual ~AbstractStructuredDocumentElement();
 
  // Ajoute une partie de contenu non contigue
  void addPart(const Lima::LimaString& text, const unsigned int offset);
 
  virtual bool hasPropType( ) { return false; }
  virtual const DocumentPropertyType& getPropType() { return m_propType; }
  virtual const Lima::LimaString& getPropertyValue() const { return m_propertyValue; }
 
  virtual const QString& getElementName() const {return m_elementName; };
 
  // Called when some character content is added
  virtual void addToCurrentOffset(const Lima::LimaString& value);
 
  // Accessor
  unsigned long int getOffset();
 
  // Accessor
  void setOffset( unsigned long int offset);
 
  void addSpaces(int nbSpaces);
 
protected:
  AbstractStructuredDocumentElement( const QString& elementName, unsigned int firstBytePos  );
 
  QString m_elementName; 
 
  unsigned long int m_offset; 
 
  DocumentPropertyType m_propType;
  Lima::LimaString m_propertyValue;
 
};
 
 
class DOCUMENTSREADER_EXPORT DiscardableDocumentElement : public AbstractStructuredDocumentElement
{
public:
  DiscardableDocumentElement( const QString& elementName, unsigned int firstBytePos  );
  ~DiscardableDocumentElement() {}
  bool isDiscarding() override {return true;}
  virtual FieldType nodeType() override {return NODE_DISCARDABLE;}
};
 
class DOCUMENTSREADER_EXPORT PropagatedProperties : public std::map<DocumentPropertyType, std::vector<std::string> >
{
public:
  virtual ~PropagatedProperties() {};
 
  friend DOCUMENTSREADER_EXPORT std::ostream& operator << (std::ostream&, const PropagatedProperties&);
  friend DOCUMENTSREADER_EXPORT QTextStream& operator << (QTextStream&, const PropagatedProperties&);
  friend DOCUMENTSREADER_EXPORT QDebug& operator << (QDebug&, const PropagatedProperties&);
 
  virtual void print(std::ostream&) const;
  virtual void print(QTextStream&) const;
  virtual void print(QDebug&) const;
};
 
 
 
class DOCUMENTSREADER_EXPORT AbstractStructuredDocumentElementWithProperties :
    public AbstractStructuredDocumentElement,
    public Lima::Common::Misc::GenericDocumentProperties
{
public:
  AbstractStructuredDocumentElementWithProperties(
      const QString& elementName,
      unsigned int firstBytePos ,
      const PropagatedProperties& toBePropagated );
  virtual ~AbstractStructuredDocumentElementWithProperties();
 
  void addProperty( const DocumentPropertyType& propType, const std::string& value );
 
 
  const PropagatedProperties& getPropertyList() const;
 
  void setPropagatedValue(
    const PropagatedProperties& toBePropagated );
 
protected:
  PropagatedProperties m_toBePropagated;
 
};
 
class DOCUMENTSREADER_EXPORT IndexingDocumentElement :
    public AbstractStructuredDocumentElementWithProperties
{
public:
  IndexingDocumentElement(
      const QString& elementName,
      unsigned int firstBytePos ,
      const DocumentPropertyType& propType,
      const PropagatedProperties& toBePropagated );
  ~IndexingDocumentElement();
 
  bool hasPropType( )  override { return( m_propType.getValueCardinality() != CARDINALITY_NONE ); }
  virtual FieldType nodeType() override {return NODE_INDEXING;}
 
};
 
class DOCUMENTSREADER_EXPORT HierarchyDocumentElement :
    public AbstractStructuredDocumentElementWithProperties
{
public:
  HierarchyDocumentElement( const QString& elementName, unsigned int firstBytePos ,
   const PropagatedProperties& toBePropagated  );
  ~HierarchyDocumentElement() {}
  virtual FieldType nodeType() override {return NODE_HIERARCHY;}
};
 
class PresentationDocumentElement : public AbstractStructuredDocumentElementWithProperties
{
public:
  PresentationDocumentElement(
      const QString& elementName,
      unsigned int firstBytePos ,
      const PropagatedProperties& toBePropagated );
  ~PresentationDocumentElement() {}
  bool isPresentation() override {return true;}
  virtual FieldType nodeType() override {return NODE_PRESENTATION;}
};
 
class DOCUMENTSREADER_EXPORT IgnoredDocumentElement : public AbstractStructuredDocumentElementWithProperties
{
public:
  IgnoredDocumentElement(
      const QString& elementName,
      unsigned int firstBytePos,
      const DocumentPropertyType& propType,
      const PropagatedProperties& toBePropagated  );
  ~IgnoredDocumentElement() {}
  virtual FieldType nodeType() override {return NODE_IGNORED;}
 
  bool hasPropType( ) override { return( m_propType.getValueCardinality() != CARDINALITY_NONE ); }
};
 
class DOCUMENTSREADER_EXPORT DocumentPropertyElement : public AbstractStructuredDocumentElement
{
public:
  DocumentPropertyElement(
      const QString& elementName,
      unsigned int firstBytePos ,
      const DocumentPropertyType& propType );
  bool hasPropType( ) override { return true; }
  ~DocumentPropertyElement() {}
  // Called when some character content is added
  void addToCurrentOffset(const Lima::LimaString& value) override;
  virtual FieldType nodeType() override {return NODE_PROPERTY;}
 
};
 
 
} // namespace DocumentsReader
} // namespace Lima
 
#endif