XMLNode_as.h

Go to the documentation of this file.

// XMLNode_as.h:  ActionScript 3 "XMLNode" class, for Gnash.
//
//   Copyright (C) 2009, 2010, 2011. 2012 Free Software Foundation, Inc.
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//

#ifndef GNASH_ASOBJ3_XMLNODE_H
#define GNASH_ASOBJ3_XMLNODE_H

#include <list>
#include <string>
#include <cassert>

#include "Relay.h"

namespace gnash {
    class as_object;
    class Global_as;
    struct ObjectURI;
}

namespace gnash {


//
//
class XMLNode_as : public Relay
{
public:

    enum NodeType {
        Element = 1,
        Attribute = 2,
        Text = 3,
        Cdata = 4,
        EntityRef = 5,
        Entity = 6,
        ProcInstr = 7,
        Comment = 8,
        Document = 9,
        DocType = 10,
        DocFragment = 11,
        Notation = 12
    };

    XMLNode_as(Global_as& gl);

    virtual ~XMLNode_as();

    size_t length() const { return _children.size(); }

    const std::string& nodeName() const { return _name; }

    const std::string& nodeValue() const { return _value; }

    NodeType nodeType() const { return _type; }

    void nodeTypeSet(NodeType type) {
            _type = type;
    }

    void nodeNameSet(const std::string& name) { _name = name; }

    bool extractPrefix(std::string& prefix) const;

    void nodeValueSet(const std::string& value) { _value = value; }

    void getNamespaceForPrefix(const std::string& prefix, std::string& ns)
        const;

    //
    bool getPrefixForNamespace(const std::string& ns, std::string& prefix)
        const;

    void setNamespaceURI(const std::string& value) {
        _namespaceURI = value;
    }

    const std::string& getNamespaceURI() const {
        return _namespaceURI;
    }

    bool hasChildNodes() const;

    XMLNode_as* firstChild() const;
    XMLNode_as* lastChild() const;
    
    // Use a list for quick erasing
    typedef std::list<XMLNode_as*> Children;

    as_object* childNodes();

    XMLNode_as* previousSibling() const;
    XMLNode_as* nextSibling() const;

    //  
    XMLNode_as* cloneNode(bool deep) const;

    //
    //
    //
        void appendChild(XMLNode_as* node);

    //
    //
    //
    void removeChild(XMLNode_as* node);

    XMLNode_as* getParent() const {
        return _parent;
    }

    //
    void insertBefore(XMLNode_as* newnode, XMLNode_as* pos);

    //
    virtual void toString(std::ostream& str, bool encode = false) const;

    as_object* getAttributes() const { return _attributes; }

    //
    void setAttribute(const std::string& name, const std::string& value);

    //
    void setObject(as_object* o) {
        assert(!_object);
        assert(o);
        _object = o;
    }

    //
    as_object* object();

protected:

    //
        virtual void setReachable();

    Global_as& _global;

    //
    void clearChildren();

private:

    //
    void setParent(XMLNode_as* node) { _parent = node; }

    //
    void updateChildNodes();

    XMLNode_as(const XMLNode_as &node, bool deep);

    Children _children;

    as_object* _object;

    XMLNode_as* _parent;

    as_object* _attributes;

    as_object* _childNodes;

    std::string _name;

    std::string _value;

    NodeType _type;

    std::string _namespaceURI;

    static void stringify(const XMLNode_as& xml, std::ostream& xmlout,
            bool encode);

};

// Initialize the global XMLNode class
void xmlnode_class_init(as_object& where, const ObjectURI& uri);

void registerXMLNodeNative(as_object& where);

} // gnash namespace

// GNASH_ASOBJ3_XMLNODE_H
#endif

// local Variables:
// mode: C++
// indent-tabs-mode: t
// End: