i_xml.h

Go to the documentation of this file.

/* Copyright, 2000, 2001 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL 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
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_I_XML_H
#define NL_I_XML_H

//#define NL_DONT_USE_EXTERNAL_CODE
#undef NL_DONT_USE_EXTERNAL_CODE

#ifndef NL_DONT_USE_EXTERNAL_CODE

#include "types_nl.h"
#include "stream.h"

// Include from libxml2
#include <libxml/parser.h>

namespace NLMISC {


struct EXmlParsingError : public EStream
{
    EXmlParsingError ( const std::string& str ) : EStream( str ) {}
};

class CIXml : public IStream
{
    friend void xmlGenericErrorFuncRead (void *ctx, const char *msg, ...);
public:

    CIXml ();

    // If tryBinaryMode is true, try to open the stream in both, XML and Binary if XML doesn't work.
    // In tryBinaryMode, the stream keep a pointer on the input stream passed to init();
    CIXml (bool tryBinaryMode);

    virtual ~CIXml ();

    bool            init (IStream &stream);

    void            release ();

    xmlNodePtr      getRootNode () const;

    static xmlNodePtr getFirstChildNode (xmlNodePtr parent, const char *childName);

    static xmlNodePtr getNextChildNode (xmlNodePtr last, const char *childName);

    static xmlNodePtr getFirstChildNode (xmlNodePtr parent, xmlElementType type);

    static xmlNodePtr getNextChildNode (xmlNodePtr last, xmlElementType type);

    static uint     countChildren (xmlNodePtr node, const char *childName);

    static uint     countChildren (xmlNodePtr node, xmlElementType type);

    static bool     getPropertyString (std::string &result, xmlNodePtr node, const char *property);

    static int      getIntProperty(xmlNodePtr node, const char *property, int defaultValue);

    static double   getFloatProperty(xmlNodePtr node, const char *property, float defaultValue);

    static std::string getStringProperty(xmlNodePtr node, const char *property, const std::string& defaultValue);

    static bool     getContentString (std::string &result, xmlNodePtr node);

private:

    virtual void    serial(uint8 &b);
    virtual void    serial(sint8 &b);
    virtual void    serial(uint16 &b);
    virtual void    serial(sint16 &b);
    virtual void    serial(uint32 &b);
    virtual void    serial(sint32 &b);
    virtual void    serial(uint64 &b);
    virtual void    serial(sint64 &b);
    virtual void    serial(float &b);
    virtual void    serial(double &b);
    virtual void    serial(bool &b);
#ifndef NL_OS_CYGWIN
    virtual void    serial(char &b);
#endif
    virtual void    serial(std::string &b);
    virtual void    serial(ucstring &b);
    virtual void    serialBuffer(uint8 *buf, uint len);
    virtual void    serialBit(bool &bit);

    virtual bool    xmlPushBeginInternal (const char *nodeName);
    virtual bool    xmlPushEndInternal ();
    virtual bool    xmlPopInternal ();
    virtual bool    xmlSetAttribInternal (const char *attribName);
    virtual bool    xmlBreakLineInternal ();
    virtual bool    xmlCommentInternal (const char *comment);

    // Internal functions
    void            serialSeparatedBufferIn ( std::string &value, bool checkSeparator = true );
    inline void     flushContentString ();

    // Push has began
    bool            _PushBegin;

    // Attribute present
    bool            _AttribPresent;

    // Attribute name
    std::string     _AttribName;

    // Current libxml node
    xmlNodePtr      _CurrentNode;

    // Current libxml header node opened
    xmlNodePtr      _CurrentElement;

    // Parser pointer
    xmlParserCtxtPtr    _Parser;

    // Current node text
    std::string     _ContentString;

    // Current index in the node string
    uint            _ContentStringIndex;

    // Error message
    std::string     _ErrorString;

    // Try binary mode
    bool            _TryBinaryMode;

    // If not NULL, binary mode detected, use this stream in serials
    IStream         *_BinaryStream;
};


} // NLMISC

#endif // NL_DONT_USE_EXTERNAL_CODE

#endif // NL_I_XML_H

/* End of o_xml.h */