xmlparser.hpp

Go to the documentation of this file.

/*
 * libxcks
 * Copyright (C) 2022 Julien Couot
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef INC_XMLPARSER_HPP_2D5675B8_341A_487A_9504_5A2CAB588986
#define INC_XMLPARSER_HPP_2D5675B8_341A_487A_9504_5A2CAB588986
 
//---------------------------------------------------------------------------
#include <vector>
#include <utility>
#include <string>
 
#include <expat.h>
//---------------------------------------------------------------------------
 
 
namespace libxcks
{
class XMLParserException
{
 protected:
  std::string message;  
 
 public:
  // Default constructor.
  XMLParserException() noexcept;
 
  // Copy constructor.
  XMLParserException(const XMLParserException& source) noexcept;
 
  // Copy assignment operator.
  XMLParserException& operator=(const XMLParserException& source) noexcept;
 
  // Constructor with a message.
  XMLParserException(const std::string& msg) noexcept;
 
  // Destructor.
  virtual ~XMLParserException();
 
  // Returns the explanatory string.
  virtual std::string what() const noexcept;
 
  // Returns the message.
  virtual std::string getMessage() const noexcept;
 
  // Sets the message.
  virtual void setMessage(const std::string& msg) noexcept;
};
//---------------------------------------------------------------------------
 
 
using XMLParserAttribute = std::pair<std::string, std::string>;
 
 
class XMLParserAttributes final
{
 protected:
  std::vector<XMLParserAttribute> attributes;   
 
 public:
  static constexpr int Not_Found = -1;
 
  XMLParserAttributes() {}
 
  XMLParserAttributes(const XMLParserAttributes&) = delete;
 
  XMLParserAttributes& operator=(const XMLParserAttributes&) = delete;
 
  // Adds an attribute to the end of the list.
  void addAttribute(const std::string& name, const std::string& value);
 
  // Adds an attribute to the end of the list.
  void addAttribute(const XMLParserAttribute&& attribute);
 
  // Clears the attribute list for reuse.
  void clear();
 
  // Looks up an attribute's index by name.
  int getIndex(const std::string& name) const;
 
  // Returns the number of attributes in the list.
  size_t getCount() const;
 
  // Returns an attribute's name.
  bool getName(size_t index, std::string& name) const;
 
  // Returns an attribute's value by index.
  bool getValue(size_t index, std::string& value) const;
 
  // Looks up an attribute's value by name.
  bool getValue(const std::string& name, std::string& value) const;
};
//---------------------------------------------------------------------------
 
 
class XMLParser
{
 private:
  XML_Parser parser;   
  int xmlDepth;  
 
 protected:
  // Default constructor.
  XMLParser();
 
  // Destructor.
  virtual ~XMLParser();
 
  // Initializes the parser for parsing a new document.
  bool initParser();
 
  // Receives notification of the beginning of an element.
  virtual void startElement(const std::string& name, const XMLParserAttributes& atts) noexcept(false);
 
  // Receives notification of the end of an element.
  virtual void endElement(const std::string& name) noexcept(false);
 
  // Receives notification of character data.
  virtual void characters(const std::string& chars) noexcept(false);
 
  // Receive notification of a non-recoverable error.
  virtual void fatalError(XML_Error errorCode, const std::string& errorMessage, int line, int column) noexcept;
 
 private:
  // Static methods for binding expat handlers
  // Handler for the beginning of an element.
  static void XMLCALL startElementHandler(void* userData, const XML_Char* name, const XML_Char** atts) noexcept(false);
 
  // Handler for the end of an element.
  static void XMLCALL endElementHandler(void* userData, const XML_Char* name) noexcept(false);
 
  // Handler for character data.
  static void XMLCALL characterDataHandler(void* userData, const XML_Char* s, int len) noexcept(false);
 
 private:
  // Changes the current depth in XML tree structure.
  void setDepth(int depth);
 
 protected:
  // Returns the current depth in XML tree structure.
  int getDepth() const;
 
 public:
  // Parses the given file.
  bool parse(const std::string& filename);
 
  // Parses the given input stream.
  bool parse(std::istream& is);
};
//---------------------------------------------------------------------------
 
 
class XMLParserDefaultHandler
{
 public:
  XMLParserDefaultHandler() {}
 
  XMLParserDefaultHandler(const XMLParserDefaultHandler&) = delete;
 
  XMLParserDefaultHandler& operator=(const XMLParserDefaultHandler&) = delete;
 
  virtual ~XMLParserDefaultHandler() {}
 
  virtual void startElement(const std::string& name, const XMLParserAttributes& atts) noexcept(false)  {}
 
  virtual void endElement(const std::string& name) noexcept(false) {}
 
  virtual void characters(const std::string& chars) noexcept(false) {}
 
  virtual void fatalError(XML_Error errorCode, const std::string& errorMessage, int line, int column) noexcept {}
};
//---------------------------------------------------------------------------
}  // namespace libxcks
//---------------------------------------------------------------------------
 
#endif  // INC_XMLPARSER_HPP_2D5675B8_341A_487A_9504_5A2CAB588986