FXXML.h

/********************************************************************************
*                                                                               *
*                       X M L   R e a d e r  &  W r i t e r                     *
*                                                                               *
*********************************************************************************
* Copyright (C) 2016,2024 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library 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 library 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 <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXXML_H
#define FXXML_H

#ifndef FXPARSEBUFFER_H
#include "FXParseBuffer.h"
#endif

namespace FX {


class FXAPI FXXML : public FXParseBuffer {
public:
  enum Error {
    ErrOK,              
    ErrEmpty,           
    ErrSave,            
    ErrLoad,            
    ErrSpace,           
    ErrEquals,          
    ErrName,            
    ErrString,          
    ErrToken,           
    ErrDigit,           
    ErrHexDigit,        
    ErrSemiColon,       
    ErrReference,       
    ErrNoMatch,         
    ErrEof              
    };
  enum {
    CRLF = 0x0001,      
    REFS = 0x0002,      
    };
  enum {
    UTF8    = 1,        
    UTF16LE = 2,        
    UTF16BE = 3,        
    UTF32LE = 4,        
    UTF32BE = 5         
    };
protected:
  class Element;        // Element info
protected:
  FXlong     offset;    // Position from start
  Element   *current;   // Current element instance
  FXint      column;    // Column number
  FXint      line;      // Line number
  FXString   vers;      // Version
  FXuint     enc;       // Encoding
private:
  FXuint guess();
  void spaces();
  FXbool name();
  FXbool match(FXchar ch);
  FXbool match(const FXchar* str,FXint len);
  Error parsestring(FXString& str);
  Error parsexml();
  Error parseversion();
  Error parseencoding();
  Error parsestandalone();
  Error parseelementdecl();
  Error parseexternalid();
  Error parseinternalsubset();
  Error parsedeclarations();
  Error parseprocessing();
  Error parsecomment();
  Error parseattribute(Element& elm);
  Error parsestarttag(Element& elm);
  Error parseendtag(Element& elm);
  Error parsecdata(Element& elm);
  Error parsecontents(Element& elm);
  Error parseelement();
private:
  static const FXchar *const errors[];
private:
  FXXML(const FXXML&);
  FXXML& operator=(const FXXML&);
public:

  FXCallback<Error () > startDocumentCB;

  FXCallback<Error (const FXString&,const FXStringDictionary&) > startElementCB;

  FXCallback<Error (const FXString&) > charactersCB;

  FXCallback<Error (const FXString&) > commentCB;

  FXCallback<Error (const FXString&,const FXString&) > processingCB;

  FXCallback<Error (const FXString&) > endElementCB;

  FXCallback<Error () > endDocumentCB;

public:

  FXXML();

  FXXML(FXchar* buffer,FXuval sz=4096,Direction d=Load);

  FXbool open(FXchar* buffer=nullptr,FXuval sz=4096,Direction d=Load);

  FXuval size() const { return endptr-begptr; }

  Direction direction() const { return dir; }

  FXint getLine() const { return line; }

  FXint getColumn() const { return column; }

  FXlong getOffset() const { return offset; }

  Error parse();

  Error startDocument();

  Error startElement(const FXString& tag);

  Error startElement(const FXString& tag,const FXStringDictionary& atts);

  Error characters(const FXString& text);

  Error comment(const FXString& text);

  Error processing(const FXString& target,const FXString& text);

  Error endElement(const FXString& tag);

  Error endDocument();

  static const FXchar* getError(Error err){ return errors[err]; }

  FXbool close();

  static FXbool decode(FXString& dst,const FXString& src,FXuint flags=CRLF|REFS);

  static FXbool encode(FXString& dst,const FXString& src,FXuint flags=CRLF|REFS);

  virtual ~FXXML();
  };

}

#endif