parser.h

/***************************************************************************************************************************************************/
/*  DocToText - A multifaceted, data extraction software development toolkit that converts all sorts of files to plain text and html.              */
/*  Written in C++, this data extraction tool has a parser able to convert PST & OST files along with a brand new API for better file processing.  */
/*  To enhance its utility, DocToText, as a data extraction tool, can be integrated with other data mining and data analytics applications.        */
/*  It comes equipped with a high grade, scriptable and trainable OCR that has LSTM neural networks based character recognition.                   */
/*                                                                                                                                                 */
/*  This document parser is able to extract metadata along with annotations and supports a list of formats that include:                           */
/*  DOC, XLS, XLSB, PPT, RTF, ODF (ODT, ODS, ODP), OOXML (DOCX, XLSX, PPTX), iWork (PAGES, NUMBERS, KEYNOTE), ODFXML (FODP, FODS, FODT),           */
/*  PDF, EML, HTML, Outlook (PST, OST), Image (JPG, JPEG, JFIF, BMP, PNM, PNG, TIFF, WEBP) and DICOM (DCM)                                         */
/*                                                                                                                                                 */
/*  Copyright (c) SILVERCODERS Ltd                                                                                                                 */
/*  http://silvercoders.com                                                                                                                        */
/*                                                                                                                                                 */
/*  Project homepage:                                                                                                                              */
/*  http://silvercoders.com/en/products/doctotext                                                                                                  */
/*  https://www.docwire.io/                                                                                                                        */
/*                                                                                                                                                 */
/*  The GNU General Public License version 2 as published by the Free Software Foundation and found in the file COPYING.GPL permits                */
/*  the distribution and/or modification of this application.                                                                                      */
/*                                                                                                                                                 */
/*  Please keep in mind that any attempt to circumvent the terms of the GNU General Public License by employing wrappers, pipelines,               */
/*  client/server protocols, etc. is illegal. You must purchase a commercial license if your program, which is distributed under a license         */
/*  other than the GNU General Public License version 2, directly or indirectly calls any portion of this code.                                    */
/*  Simply stop using the product if you disagree with this viewpoint.                                                                             */
/*                                                                                                                                                 */
/*  According to the terms of the license provided by SILVERCODERS and included in the file COPYING.COM, licensees in possession of                */
/*  a current commercial license for this product may use this file.                                                                               */
/*                                                                                                                                                 */
/*  This program is provided WITHOUT ANY WARRANTY, not even the implicit warranty of merchantability or fitness for a particular purpose.          */
/*  It is supplied in the hope that it will be useful.                                                                                             */
/***************************************************************************************************************************************************/
 
 
#ifndef PARSER_HPP
#define PARSER_HPP
 
#include <any>
#include <string>
#include <functional>
#include <memory>
 
#include "formatting_style.h"
#include "parser_manager.h"
#include "parser_parameters.h"
#include "defines.h"
 
namespace doctotext
{
 
class StandardTag
{
public:
  inline static const std::string TAG_P = "p"; 
  inline static const std::string TAG_CLOSE_P = "/p"; 
  inline static const std::string TAG_BR = "br"; 
  inline static const std::string TAG_B = "b"; 
  inline static const std::string TAG_CLOSE_B = "/b"; 
  inline static const std::string TAG_I = "i"; 
  inline static const std::string TAG_CLOSE_I = "/i"; 
  inline static const std::string TAG_U = "u"; 
  inline static const std::string TAG_CLOSE_U = "/u"; 
  inline static const std::string TAG_TABLE = "table"; 
  inline static const std::string TAG_CLOSE_TABLE = "/table"; 
  inline static const std::string TAG_TR = "tr"; 
  inline static const std::string TAG_CLOSE_TR = "/tr"; 
  inline static const std::string TAG_TD = "td"; 
  inline static const std::string TAG_CLOSE_TD = "/td"; 
  inline static const std::string TAG_TEXT = "#text"; 
  inline static const std::string TAG_LINK = "a"; 
  inline static const std::string TAG_CLOSE_LINK = "/a"; 
  inline static const std::string TAG_STYLE = "style"; 
  inline static const std::string TAG_CLOSE_STYLE = "/style"; 
 
  inline static const std::string TAG_LIST = "list"; 
  inline static const std::string TAG_CLOSE_LIST = "/list"; 
  inline static const std::string TAG_LIST_ITEM = "list-item"; 
  inline static const std::string TAG_CLOSE_LIST_ITEM = "/list-item"; 
 
  inline static const std::string TAG_MAIL = "mail"; 
  inline static const std::string TAG_CLOSE_MAIL = "/mail"; 
  inline static const std::string TAG_MAIL_BODY = "mail-body"; 
  inline static const std::string TAG_CLOSE_MAIL_BODY = "/mail-body"; 
  inline static const std::string TAG_ATTACHMENT = "attachment"; 
  inline static const std::string TAG_CLOSE_ATTACHMENT = "/attachment"; 
  inline static const std::string TAG_FOLDER = "folder"; 
  inline static const std::string TAG_CLOSE_FOLDER = "/folder"; 
 
  inline static const std::string TAG_METADATA = "metadata"; 
  inline static const std::string TAG_COMMENT = "comment"; 
 
  inline static const std::string TAG_PAGE = "new-page"; 
  inline static const std::string TAG_CLOSE_PAGE = "/new-page"; 
};
 
struct DllExport Info
{
  std::string tag_name; 
  std::map<std::string, std::any> attributes; 
  bool cancel = false; 
  bool skip = false; 
  std::string plain_text; 
 
  explicit Info(const std::string &tagName = "", const std::string &plainText = "", const std::map<std::string, std::any> &attrs = {})
  : tag_name(tagName),
    plain_text(plainText),
    attributes(attrs)
  {}
 
  template<typename T>
  std::optional<T> getAttributeValue(const std::string &name) const
  {
    auto attribute_value = attributes.find(name);
    if (attribute_value!= attributes.end() && attribute_value->second.type() == typeid(T))
    {
      return std::any_cast<T>(attribute_value->second);
    }
    return std::nullopt;
  }
};
 
typedef std::function<void(Info &info)> NewNodeCallback;
 
class DllExport Parser
{
public:
  explicit Parser(const std::shared_ptr<doctotext::ParserManager> &inParserManager = nullptr);
 
  virtual ~Parser() = default;
 
  virtual void parse() const = 0;
  virtual Parser &addOnNewNodeCallback(NewNodeCallback callback);
 
  virtual Parser &withParameters(const ParserParameters &parameters);
 
protected:
  FormattingStyle getFormattingStyle() const;
 
  std::ostream& getLogOutStream() const;
 
  bool isVerboseLogging() const;
 
  Info sendTag(const std::string& tag_name, const std::string& text = "", const std::map<std::string, std::any> &attributes = {}) const;
  Info sendTag(const Info &info) const;
 
  std::shared_ptr<doctotext::ParserManager> m_parser_manager;
  ParserParameters m_parameters;
 
private:
  struct DllExport Implementation;
  struct DllExport ImplementationDeleter { void operator() (Implementation*); };
  std::unique_ptr<Implementation, ImplementationDeleter> base_impl;
};
 
} // namespace doctotext
#endif //PARSER_HPP