html.h

Go to the documentation of this file.

 
/*******************************************************************************
Copyright (c) 2014, Jan Koester jan.koester@gmx.net
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the <organization> nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
 
#include <sys/types.h>
 
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <memory>
 
#pragma once
namespace libhtmlpp {
    class DocElements;
    class HtmlElement;
    class HtmlString;
 
    enum ElementType{
        TextEl=0,
        HtmlEl=1,
        CommentEl=2,
        ScriptEL=3,
        SvgEL=4,
        TextAreaEL=5
    };
    class Element {
    public:
        virtual ~Element();
 
        Element(const Element &el);
 
        void insertAfter(Element* el);
        void insertBefore(Element* el);
 
        Element& operator=(const Element &hel);
        Element& operator=(const Element *hel);
 
        Element*       nextElement() const;
        Element*       prevElement() const;
        Element*       parentElement() const;
 
        virtual void   remove(Element* el);
 
        virtual int    getType() const=0;
    protected:
 
        Element();
 
        std::unique_ptr<Element> _nextElement;
        Element*                             _prevElement;
        Element*                             _parentElement = nullptr;
 
        friend class HtmlElement;
        friend class TextElement;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
 
    class HtmlElement : public Element {
    public:
        HtmlElement();
        HtmlElement(const std::string &tag);
        HtmlElement(const HtmlElement &hel);
        HtmlElement(const HtmlElement *hel);
        ~HtmlElement();
 
        HtmlElement& operator=(const HtmlElement &hel);
        HtmlElement& operator=(const HtmlElement *hel);
 
        bool operator==(const HtmlElement *hel);
        bool operator==(const HtmlElement &hel);
 
        void         setAttribute(const std::string &name, const std::string &value);
 
        void         setIntAttribute(const std::string &name, int value);
 
        const std::string getAtributte(const std::string &name) const;
 
        int          getIntAtributte(const std::string &name) const;
 
        void         insertChild(const Element* el);
        void         insertChild(const Element& el);
        void         appendChild(const Element* el);
        void         appendChild(const Element& el);
 
        void         setTagname(const std::string &name);
        const std::string getTagname() const;
 
        HtmlElement *getElementbyID(const std::string &id) const;
        HtmlElement *getElementbyTag(const std::string &tag) const;
 
        Element*     firstChild() const;
 
        struct Attributes {
            Attributes();
            ~Attributes();
 
            const std::string getKey() const;
            const std::string getValue() const;
            Attributes*       nextAttribute() const;
 
        private:
            std::vector<char>                _Key;
            std::vector<char>                _Value;
            std::unique_ptr<Attributes> _nextAttr;
 
            friend class HtmlElement;
            friend void  print(const Element& element, HtmlString &output,bool formated);
            friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
        };
 
        const Attributes* firstAttribute() const;
 
        int    getType() const;
        void   remove(Element* el);
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
    protected:
 
        std::unique_ptr<Element>  _childElement=nullptr;
 
        // preserveAttrCase: skip lowercasing attribute keys (SVG's own attributes
        // like viewBox/preserveAspectRatio are case-sensitive per the XML/SVG spec,
        // unlike regular HTML attributes).
        void _serialelize(const std::vector<char> &in, bool preserveAttrCase = false);
    private:
        //if text tagname must be zero
        std::vector<char> _TagName;
 
        //if text Attributes must be zero
        std::unique_ptr<Attributes>    _firstAttr;
        Attributes*                                _lastAttr;
 
        // Sets `node`'s parent to `parent`, and does the same for every
        // sibling reachable via nextElement() (they share the same parent)
        // -- recursing into each HtmlElement-shaped node's own child chain
        // (with that node as the new parent). Called after building or
        // copying a subtree, once its own sibling/child links are already
        // correct, rather than threaded through the parser/copy internals
        // themselves.
        static void _assignParentPointers(Element* node, Element* parent);
 
        friend class HtmlString;
        friend class HtmlTable;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
    class TextElement : public Element {
    public:
        TextElement();
        TextElement(const std::string &txt);
        TextElement(const TextElement &texel);
        ~TextElement();
 
        TextElement& operator=(const Element &hel);
        TextElement& operator=(const Element *hel);
 
        const std::string    getText();
        void                       setText(const std::string &txt);
 
        int         getType() const;
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
 
    protected:
        std::vector<char> _Text;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
    class CommentElement : public Element{
    public:
        CommentElement();
        CommentElement(const CommentElement &comel);
        ~CommentElement();
 
        CommentElement& operator=(const Element &hel);
        CommentElement& operator=(const Element *hel);
 
        const std::string getComment();
        void        setComment(const std::string &txt);
 
        int         getType() const;
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
    protected:
        std::vector<char> _Comment;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
    class ScriptElement : public HtmlElement{
    public:
        ScriptElement();
        ScriptElement(const ScriptElement &scriptsrc);
        ~ScriptElement();
 
        ScriptElement& operator=(const Element &hel);
        ScriptElement& operator=(const Element *hel);
 
        const std::string getScript();
        void                    setScript(const std::string  &txt);
 
        int         getType() const;
 
        void         insertChild(const Element* el)=delete;
        void         insertChild(const Element& el)=delete;
        void         appendChild(const Element* el)=delete;
        void         appendChild(const Element& el)=delete;
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
    protected:
 
        std::unique_ptr<Element> _childElement=nullptr;
 
        std::vector<char> _Script;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
    class SvgElement : public HtmlElement{
    public:
        SvgElement();
        SvgElement(const SvgElement &svgsrc);
        ~SvgElement();
 
        SvgElement& operator=(const Element &hel);
        SvgElement& operator=(const Element *hel);
 
        const std::vector<char> getSvg();
        void                    setSvg(const std::string  &svg);
 
        int         getType() const;
 
        void         insertChild(const Element* el)=delete;
        void         insertChild(const Element& el)=delete;
        void         appendChild(const Element* el)=delete;
        void         appendChild(const Element& el)=delete;
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
    protected:
 
        std::unique_ptr<Element> _childElement=nullptr;
 
        std::vector<char> _Svg;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
 
    class TextArea : public HtmlElement{
    public:
        TextArea();
        TextArea(const TextArea &textsrc);
        ~TextArea();
 
        TextArea& operator=(const Element &hel);
        TextArea& operator=(const Element *hel);
 
        const std::vector<char> getText();
        void                    setText(const std::string  &text);
 
        int            getType() const;
 
        void         insertChild(const Element* el)=delete;
        void         insertChild(const Element& el)=delete;
        void         appendChild(const Element* el)=delete;
        void         appendChild(const Element& el)=delete;
 
        static size_t parseElement(const std::vector<char> &in,std::unique_ptr<libhtmlpp::Element> &el,size_t start,bool &termination);
    protected:
 
        std::unique_ptr<Element> _childElement=nullptr;
 
        std::vector<char> _Text;
        friend class HtmlString;
        friend void  print(const Element& element, HtmlString &output,bool formated);
        friend void _copy(libhtmlpp::Element *dest,const libhtmlpp::Element *src);
    };
 
    void print(const Element& element, HtmlString &output,bool formated=false);
 
    class HtmlString {
    public:
 
        using value_type = char;
 
        HtmlString()=default;
        HtmlString(const HtmlString &str);
        HtmlString(char str);
        HtmlString(const std::string &str);
        ~HtmlString();
 
        void append(const std::string &src);
        void append(HtmlString& hstring);
 
        void push_back(const char  src);
 
        void insert(size_t pos, char src);
 
        HtmlString& operator+=(const std::string  &src);
        HtmlString& operator+=(HtmlString& hstring);
        HtmlString& operator=(const std::string &src);
        HtmlString& operator=(const HtmlString& src);
        char operator[](size_t pos) const;
 
        HtmlString& operator<<(const char* src);
        HtmlString& operator<<(const std::string &src);
        HtmlString& operator<<(HtmlString src);
        HtmlString& operator<<(int src);
        HtmlString& operator<<(char src);
        HtmlString& operator<<(size_t src);
 
        const char* operator*();
 
        size_t                    size() const;
        size_t                    length() const;
        void                      clear();
        bool                      empty();
 
        const std::vector<char>&  data() const;
        const std::string                  str() const;
        const char                         *c_str() const;
        libhtmlpp::Element &parse();
 
    private:
        std::unique_ptr<Element> _rootEl;
        void                 _buildTree();
        void _buildtreenode(DocElements *firstel,DocElements *lastel,std::unique_ptr<Element>&html);
        std::vector<char>    _Data;
        friend void HtmlEncode(const std::string &input,HtmlString *output);
        friend class HtmlPage;
    };
    void HtmlDecode(const std::string &input,HtmlString &output);
 
    void HtmlDecode(const std::string &input,std::string &output);
 
    void HtmlEncode(const std::string &input,std::string &output);
    class HtmlPage {
    public:
        HtmlPage();
        ~HtmlPage();
        void         loadFile(libhtmlpp::HtmlElement &html,const std::string &path);
        void         saveFile(libhtmlpp::HtmlElement &html,const std::string &path);
        void         loadString(libhtmlpp::HtmlElement &html,const std::string &src);
        void         loadString(libhtmlpp::HtmlElement &html,const HtmlString &node);
        void         loadString(libhtmlpp::HtmlElement &html,const HtmlString *node);
        bool         isHtml5();
    private:
        void         _CheckHeader(const HtmlString& page);
        bool         _Html5 = true;
    };
 
    class HtmlTable {
    public:
        HtmlTable();
        ~HtmlTable();
 
        class Column {
        public:
            std::string  Data;
             ~Column();
             Column(const Column &col);
             Column();
            Column(const std::string &data);
            Column(const HtmlString &data);
            Column(Column&& col) noexcept;
        private:
            std::unique_ptr<Column> _nextColumn;
            friend class HtmlTable;
        };
 
        class Row {
        public:
            Row();
            Row(const Row &row);
            ~Row();
 
            Row &operator<<(Column &&col);
            Row& operator<<(const Column &col);
            Row& operator<<(const HtmlString  &value);
            Row& operator<<(const std::string  &value);
            Row& operator<<(const char* value);
            Row& operator<<(int value);
 
            Column& operator[](size_t pos);
 
            void delColumn(size_t pos);
            void clear();
        private:
            std::unique_ptr<Column>  _firstColumn;
            Column                              *_lastColumn;
            std::unique_ptr<Row>        _nextRow;
            size_t  _count;
            friend class HtmlTable;
        };
 
        Row& operator<<(const Row &row);
        Row& operator[](size_t pos);
 
        void insert(HtmlElement *element);
        void parse(HtmlElement *element);
 
        void setHeader(int count,...);
        void deleteRow(size_t pos);
    private:
        std::unique_ptr<Row> _firstRow;
        Row                             *_lastRow;
        Row                              _header;
        size_t   _count;
    };
};
 
std::ostream& operator<<(std::ostream& os, const libhtmlpp::HtmlString& p);