---

judo.hpp

//============================================================================
// Project:       Jabber Universal Document Objects (Judo)
// Filename:      judo.h
// Description:   Primary header
// Created at:    Mon Jul  2 17:27:04 2001
// Modified at:   Tue Oct 16 10:28:40 2001
// 
//   License:
// 
// The contents of this file are subject to the Jabber Open Source License
// Version 1.0 (the "License").  You may not copy or use this file, in either
// source code or executable form, except in compliance with the License.  You
// may obtain a copy of the License at http://www.jabber.com/license/ or at
// http://www.opensource.org/.  
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the License
// for the specific language governing rights and limitations under the
// License.
//
//   Copyrights
//
// Portions created by or assigned to Jabber.com, Inc. are 
// Copyright (c) 1999-2001 Jabber.com, Inc.  All Rights Reserved.  
// 
// $Id: judo.hpp,v 1.2 2002/03/07 21:55:52 julian Exp $
//============================================================================

#ifndef INCL_JUDO_H
#define INCL_JUDO_H

#ifdef WIN32
#pragma warning (disable:4786)
#include <windows.h>
#endif

#include <assert.h>
#include "expat/expat.h"

#include <cstdio>
#include <cstring>
#include <list>
#include <map>
#include <string>
#include <set>
#include <algorithm>

#ifdef TEST
#define TESTER(s) friend class s;
#else
#define TESTER(s)
#endif

namespace judo
{
    class XMLAccumulator;

    class Node
    {
    public:
        enum Type
        {
            ntElement,
            ntCDATA
        };

        Node(const std::string& name, Type ntype)
            : _name(name), _type(ntype)
            {}
        virtual ~Node() {}
    public:
        const std::string& getName() const
            { return _name; }

        Node::Type getType() const
            { return _type; }

        virtual std::string toString() const = 0;

        virtual void accumulate(XMLAccumulator& acc) const = 0;

    protected:
        std::string        _name;
        Node::Type _type;    

        // Ensure that no one can initialize this variable without
        // using the proper constructor
        Node();
    };

    // Utility routines
    void   unescape(const char* src, unsigned int srcLen, std::string& dest, bool append = false);  
    std::string escape(const std::string& src);

    class XMLAccumulator
    {
    public:
        XMLAccumulator(std::string& s)
            : _result(s) {}

        void operator()(const Node* n)
            { n->accumulate(*this); }
        void operator()(const std::pair<const std::string, std::string> p)
            { _result += " " + p.first + "='" + 
                  escape(p.second) + "'";
            }
        template <class T>
        XMLAccumulator& operator<<(T data)
            { _result += data; return *this; }
    private:
        std::string& _result;
    };

    class CDATA : 
        public Node
    {
    public:
        CDATA(const char* text, unsigned int textsz, bool escaped = false)
            : Node("#CDATA", Node::ntCDATA)
            {
                if (escaped)
                {
                    unescape(text, textsz, _text);
                }
                else
                {
                    _text.assign(text, textsz);
                }
            }
        
        void setText(const char* text, unsigned int textsz, bool escaped = false)
            { 
                if (escaped)
                {
                    unescape(text, textsz, _text); 
                }
                else
                {
                    _text.assign(text, textsz);
                }
            }

        void appendText(const char* text, unsigned int textsz, bool escaped = false)
            { 
                if (escaped)
                {
                    unescape(text, textsz, _text, true); 
                }
                else
                {
                    _text.append(text, textsz);
                }
            }

        const std::string& getText() const
            { return _text; }

        std::string toString() const
            { return escape(_text); }

        void accumulate(XMLAccumulator& acc) const
            { acc << escape(_text); }

    private:
        TESTER(CDATATest)

        std::string _text;           
    };

    class Element: 
        public Node
    {
    public:
        Element(const std::string& name, const char** attribs = NULL);
        Element(const Element& e);
        ~Element();

        Element& operator=(const Element& e);

        Element* addElement(const std::string& name, const char** attribs = NULL);
        Element* addElement(const std::string& name, const std::string& cdata, 
                            bool escaped = false);
        CDATA*   addCDATA(const char* data, int datasz, bool escaped = false);  

        void   putAttrib(const std::string& name, const std::string& value);
        std::string getAttrib(const std::string& name) const;
        void   delAttrib(const std::string& name);
        bool   cmpAttrib(const std::string& name, const std::string& value) const;

        std::string toString() const;
        std::string toStringEx(bool recursive = false, bool closetag = false) const;

        void accumulate(XMLAccumulator& acc) const;

        std::string getCDATA() const;
        

        typedef std::list<Node*>::iterator iterator;
        typedef std::list<Node*>::const_iterator const_iterator;

        void appendChild(Node* child)
            { _children.push_back(child); }
        
        Node* detachChild(iterator it);
        
        bool empty() const
            { return _children.empty(); }

        int size() const
            { return _children.size(); }
        
        iterator begin()
            { return _children.begin(); }

        const_iterator begin() const
            { return _children.begin(); }

        iterator end()
            { return _children.end(); }

        const_iterator end() const
            { return _children.end(); }

        iterator find(const std::string& name, Node::Type type = Node::ntElement);

        const_iterator find(const std::string& name, Node::Type type = Node::ntElement) const;
        void Element::erase(Element::iterator it)
            { delete *it; _children.erase(it); }

        Element* findElement(const std::string& name);
        const Element* findElement(const std::string& name) const;
        void     eraseElement(const std::string& name);

        std::string getChildCData(const std::string& name) const;
        int         getChildCDataAsInt(const std::string& name, int defaultvalue) const;


    protected:
        TESTER(ElementTest)
        
        std::list<Node*>        _children;
        std::map<std::string,std::string> _attribs;
    };
    
    class ElementStreamEventListener
    {
    public:
        virtual ~ElementStreamEventListener() {}
        virtual void onDocumentStart(Element* e) = 0;

        virtual void onElement(Element* e) = 0;

        virtual void onCDATA(CDATA* c) 
            { delete c; }
            

        virtual void onDocumentEnd() = 0;
    };
    

    class ElementStream 
    {
    public:
        ElementStream(ElementStreamEventListener* l);
        virtual ~ElementStream();

        void push(const char* data, int datasz);
        void reset();

        static Element* parseAtOnce(const char* buffer);

        struct exception
        {
            class ParserError 
                {
                public:
                    ParserError(int code)
                        : _code(code), _message(XML_ErrorString(code))
                        {}
                    const std::string& getMessage() const
                        { return _message; }
                    int getCode() const
                        { return _code; }
                private:
                    int _code;
                    std::string _message;
                };
            class IncompleteParse{};
        };

    private:
        TESTER(ElementStreamTest)

        XML_Parser     _parser;
        bool           _parser_ready;
        std::list<Element*> _element_stack;
        bool           _document_started;
        bool           _document_ended;

        ElementStreamEventListener* _event_listener;

        // Expat callbacks
        static void onStartElement(void* userdata, const char* name, const char** attribs);
        static void onEndElement(void* userdata, const char* name);
        static void onCDATA(void* userdata, const char* cdata, int cdatasz);

        // Expat initializers
        void initExpat();
        void cleanupExpat();
       };
}
#endif

---