cXmlReader.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cXmlReader_H
#define _INC_cXmlReader_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cXml.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cTextPos.h"
 
namespace GrayLib
{
        class GRAYLIB_LINK cXmlReader;
 
        class GRAYLIB_LINK cXmlReadVisitor : public cXml
        {
 
        public:
                cXmlReadVisitor() noexcept
                {
                }
                virtual ~cXmlReadVisitor()
                {
                }
 
                virtual HRESULT onElementStart(cXmlReader& rReader, const cXmlString& sElement, cXmlAttributeSet& Attribs, bool bEnd)
                {
                        UNREFERENCED_REFERENCE(rReader);        // UNREFERENCED_REFERENCE
                        UNREFERENCED_REFERENCE(sElement);
                        UNREFERENCED_REFERENCE(Attribs);
                        return bEnd ? S_FALSE : S_OK;
                }
                virtual HRESULT onText(cXmlReader& rReader, XMLNODE_TYPE eType, const cXmlString& sValue, bool bCDATA)
                {
                        UNREFERENCED_REFERENCE(rReader);
                        UNREFERENCED_PARAMETER(eType);
                        UNREFERENCED_REFERENCE(sValue);
                        UNREFERENCED_PARAMETER(bCDATA);
                        return S_OK;
                }
                virtual HRESULT onElementEnd(cXmlReader& rReader, const cXmlString& sElement)
                {
                        UNREFERENCED_REFERENCE(rReader);
                        UNREFERENCED_REFERENCE(sElement);
                        return S_OK;
                }
        };
 
        class GRAYLIB_LINK cXmlReader : public cTextReader, public cXml
        {
 
                friend class cXmlNode;
                typedef cTextReader SUPER_t;
 
#define cXmlNodeTypeDEF(a,b,c) friend class cXml##a;
#include "cXmlNodeTypes.tbl"
#undef cXmlNodeTypeDEF
 
        public:
                cTextPos m_PosNode;             
                CXML_ENCODING_TYPE m_eEncoding; 
                bool m_bCondenseWhitespace;             
                int m_iDepth;                                   
 
        private:
                StrLen_t GetCharSize() const;
                StrLen_t ParseChar(char* pszValueOut, StrLen_t* piLengthOut);
                void IncChar(StrLen_t nLen);
                bool IncChar()
                {
                        StrLen_t nLen = GetCharSize();
                        if (nLen <= 0)
                                return false;
                        IncChar(nLen);
                        return true;
                }
 
        protected:
                bool IsAlpha(wchar_t anyByte) const;
                bool IsAlphaNum(wchar_t anyByte) const;
                wchar_t ToLower(wchar_t v) const;
 
                bool IsStringEqual(const char* pszData, const char* pszEndTag, bool bIgnoreCase = false) const;
 
                bool ReadWhitespace();
 
                HRESULT ParseName(OUT cXmlString& rsName);
 
                HRESULT ParseStringTo(OUT cXmlString& rsText, const char* pszEndTag, bool bIgnoreWhitespace);
 
                HRESULT ParseAttrib(OUT cXmlString& sName, OUT cXmlString& sValue);
                HRESULT ParseAttribSet(OUT cXmlAttributeSet& Attribs);
 
                HRESULT ParseDeclaration(OUT cXmlAttributeSet& Attribs);
                HRESULT ParseUnknown(OUT cXmlString& sValue);
                HRESULT ParseComment(OUT cXmlString& sValue);
                HRESULT ParseText(OUT cXmlString& sValue, bool bCDATAExpected);
 
                HRESULT ParseNodeType();
                bool ParseMicrosoftBOM();
 
                HRESULT ParseElement(OUT cXmlString& sElement, OUT cXmlAttributeSet& Attribs);
 
                HRESULT ParseVisitType(cXmlReadVisitor* pVisitor, XMLNODE_TYPE eNodeType, bool bDoc, bool bCDATA);
 
        public:
                cXmlReader(const char* pszStart="", StrLen_t nLenMax = StrT::k_LEN_MAX, StrLen_t iTabSize = cStrConst::k_TabSize,
                        CXML_ENCODING_TYPE eEncoding = CXML_ENCODING_UNKNOWN, bool bCondenseWhitespace = true);
                ~cXmlReader();
 
                HRESULT ReturnError(HRESULT hRes) const;
 
                static CXML_ENCODING_TYPE GRAYCALL GetEncodingEnum(cXmlString sEncoding);
                static StrLen_t GRAYCALL FixNewLines(char* pszBuffer, StrLen_t nLenInp);
 
                void put_CondenseWhitespace(bool bCondense) noexcept
                {
                        m_bCondenseWhitespace = bCondense;
                }
                bool isCondensedWhitespace() const noexcept
                {
                        return m_bCondenseWhitespace;
                }
 
                HRESULT Parse(cXmlReadVisitor* pVisitor, cXmlString sElementParent);
                HRESULT Parse(cXmlReadVisitor* pVisitor);
 
                HRESULT ParseText(const char* pszText, cXmlReadVisitor* pVisitor);
                HRESULT ParseStream(cStreamInput& rInp, cXmlReadVisitor* pVisitor);
                HRESULT ParseFile(const FILECHAR_t* pszXMLFile, cXmlReadVisitor* pVisitor);
        };
}
#endif // _INC_cXmlReader_H