csharp-to-cpp/apireference/xml__node_8h_source.html

#pragma once


#include <xml/xpath/ixpath_navigable.h>

#include <xml/xml_node_type.h>

#include <system/collections/ienumerable.h>


namespace System

{

namespace Collections

{

namespace Generic

{

template <typename> class IEnumerator;

} // namespace Generic

} // namespace Collections

class String;

namespace Text

{

class StringBuilder;

} // namespace Text

namespace Xml

{

class DocumentSchemaValidator;

class DocumentXmlWriter;

class DocumentXPathNavigator;

namespace Schema

{

class IXmlSchemaInfo;

class Parser;

} // namespace Schema

class XmlAttribute;

class XmlAttributeCollection;

class XmlCDataSection;

class XmlCharacterData;

class XmlChildEnumerator;

class XmlChildNodes;

class XmlDocument;

class XmlElement;

class XmlElementList;

class XmlEntity;

class XmlEntityReference;

class XmlLinkedNode;

class XmlLoader;

class XmlNamedNodeMap;

class XmlNamespaceManager;

enum class XmlNodeChangedAction;

class XmlNodeChangedEventArgs;

class XmlNodeList;

class XmlNodeReaderNavigator;

class XmlNotation;

class XmlSignificantWhitespace;

enum class XmlSpace;

class XmlText;

class XmlWhitespace;

class XmlWriter;

namespace XPath

{

class XPathNavigator;

enum class XPathNodeType;

} // namespace XPath

} // namespace Xml

} // namespace System


namespace System {


namespace Xml {


class ASPOSECPP_SHARED_CLASS XmlNode : public Collections::Generic::IEnumerable<SharedPtr<System::Xml::XmlNode>>, public XPath::IXPathNavigable

{

    typedef XmlNode ThisType;

    typedef Collections::Generic::IEnumerable<SharedPtr<System::Xml::XmlNode>> BaseType;

    typedef XPath::IXPathNavigable BaseType1;


    typedef ::System::BaseTypesInfo<BaseType, BaseType1> ThisTypeBaseTypesInfo;

    ASPOSECPP_SHARED_RTTI_INFO_DECL();


public:


    using Ptr = SharedPtr<XmlNode>;


private:

    friend class DocumentSchemaValidator;

    friend class DocumentXmlWriter;

    friend class DocumentXPathNavigator;

    friend class XmlAttribute;

    friend class XmlAttributeCollection;

    friend class XmlNamedNodeMap;

    friend class XmlCDataSection;

    friend class XmlCharacterData;

    friend class XmlLinkedNode;

    friend class XmlChildEnumerator;

    friend class XmlChildNodes;

    friend class XmlNodeList;

    friend class XmlDocument;

    friend class XmlElement;

    friend class XmlElementList;

    friend class XmlEntity;

    friend class XmlEntityReference;

    friend class XmlLoader;

    friend class XmlNodeReaderNavigator;

    friend class XmlNotation;

    friend class XmlSignificantWhitespace;

    friend class XmlText;

    friend class XmlWhitespace;

    friend class Schema::Parser;


public:


    virtual ASPOSECPP_SHARED_API String get_Name() = 0;

    virtual ASPOSECPP_SHARED_API String get_Value();

    virtual ASPOSECPP_SHARED_API void set_Value(String value);

    virtual ASPOSECPP_SHARED_API XmlNodeType get_NodeType() = 0;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_ParentNode() final;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNodeList> get_ChildNodes();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_PreviousSibling() final;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_NextSibling() final;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlAttributeCollection> get_Attributes() final;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDocument> get_OwnerDocument();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_FirstChild() final;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_LastChild() final;

    virtual ASPOSECPP_SHARED_API bool get_HasChildNodes();

    virtual ASPOSECPP_SHARED_API String get_NamespaceURI();

    virtual ASPOSECPP_SHARED_API String get_Prefix();

    virtual ASPOSECPP_SHARED_API void set_Prefix(String value);

    virtual ASPOSECPP_SHARED_API String get_LocalName() = 0;

    virtual ASPOSECPP_SHARED_API bool get_IsReadOnly();

    virtual ASPOSECPP_SHARED_API String get_InnerText();

    virtual ASPOSECPP_SHARED_API void set_InnerText(String value);

    virtual ASPOSECPP_SHARED_API String get_OuterXml();

    virtual ASPOSECPP_SHARED_API String get_InnerXml();

    virtual ASPOSECPP_SHARED_API void set_InnerXml(String value);

    virtual ASPOSECPP_SHARED_API SharedPtr<Schema::IXmlSchemaInfo> get_SchemaInfo();

    virtual ASPOSECPP_SHARED_API String get_BaseURI();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_PreviousText();


    ASPOSECPP_SHARED_API SharedPtr<XPath::XPathNavigator> CreateNavigator() override;

    ASPOSECPP_SHARED_API SharedPtr<XmlNode> SelectSingleNode(const String& xpath);

    ASPOSECPP_SHARED_API SharedPtr<XmlNode> SelectSingleNode(const String& xpath, const SharedPtr<XmlNamespaceManager>& nsmgr);

    ASPOSECPP_SHARED_API SharedPtr<XmlNodeList> SelectNodes(const String& xpath);

    ASPOSECPP_SHARED_API SharedPtr<XmlNodeList> SelectNodes(const String& xpath, const SharedPtr<XmlNamespaceManager>& nsmgr);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> InsertBefore(SharedPtr<XmlNode> newChild, SharedPtr<XmlNode> refChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> InsertAfter(SharedPtr<XmlNode> newChild, SharedPtr<XmlNode> refChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> ReplaceChild(SharedPtr<XmlNode> newChild, SharedPtr<XmlNode> oldChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> RemoveChild(SharedPtr<XmlNode> oldChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> PrependChild(SharedPtr<XmlNode> newChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> AppendChild(SharedPtr<XmlNode> newChild);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> CloneNode(bool deep) = 0;

    virtual ASPOSECPP_SHARED_API void Normalize();

    virtual ASPOSECPP_SHARED_API bool Supports(String feature, String version);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> Clone();

    ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IEnumerator<SharedPtr<XmlNode>>> GetEnumerator() override;

    virtual ASPOSECPP_SHARED_API void WriteTo(const SharedPtr<XmlWriter>& w) = 0;

    virtual ASPOSECPP_SHARED_API void WriteContentTo(const SharedPtr<XmlWriter>& w) = 0;

    virtual ASPOSECPP_SHARED_API void RemoveAll();

    virtual ASPOSECPP_SHARED_API String GetNamespaceOfPrefix(String prefix);

    virtual ASPOSECPP_SHARED_API String GetPrefixOfNamespace(String namespaceURI);


    virtual ASPOSECPP_SHARED_API SharedPtr<XmlElement> idx_get(String name);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlElement> idx_get(String localname, String ns);


protected:


    WeakPtr<XmlNode> parentNode;


    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_ParentNodeInternal();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_PreviousSiblingInternal();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_NextSiblingInternal();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlAttributeCollection> get_AttributesInternal();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_FirstChildInternal();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_LastChildInternal();

    virtual ASPOSECPP_SHARED_API bool get_IsContainer();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlLinkedNode> get_LastNode();

    virtual ASPOSECPP_SHARED_API void set_LastNode(SharedPtr<XmlLinkedNode> value);

    SharedPtr<XmlDocument> get_Document();

    virtual ASPOSECPP_SHARED_API System::Xml::XmlSpace get_XmlSpace();

    virtual ASPOSECPP_SHARED_API String get_XmlLang();

    virtual ASPOSECPP_SHARED_API XPath::XPathNodeType get_XPNodeType();

    virtual ASPOSECPP_SHARED_API String get_XPLocalName();

    virtual ASPOSECPP_SHARED_API bool get_IsText();


    XmlNode();

    XmlNode(const SharedPtr<XmlDocument>& doc);


    bool AncestorNode(const SharedPtr<XmlNode>& node);

    bool IsConnected();

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> AppendChildForLoad(const SharedPtr<XmlNode>& newChild, const SharedPtr<XmlDocument>& doc);

    virtual ASPOSECPP_SHARED_API bool IsValidChildType(XmlNodeType type);

    virtual ASPOSECPP_SHARED_API bool CanInsertBefore(SharedPtr<XmlNode> newChild, SharedPtr<XmlNode> refChild);

    virtual ASPOSECPP_SHARED_API bool CanInsertAfter(SharedPtr<XmlNode> newChild, SharedPtr<XmlNode> refChild);

    virtual ASPOSECPP_SHARED_API void CopyChildren(SharedPtr<XmlDocument> doc, SharedPtr<XmlNode> container, bool deep);

    static bool HasReadOnlyParent(SharedPtr<XmlNode> n);

    String GetNamespaceOfPrefixStrict(String prefix);

    String GetPrefixOfNamespaceStrict(String namespaceURI);

    virtual ASPOSECPP_SHARED_API void SetParent(SharedPtr<XmlNode> node);

    virtual ASPOSECPP_SHARED_API void SetParentForLoad(SharedPtr<XmlNode> node);

    static void SplitName(const String& name, String& prefix, String& localName);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> FindChild(XmlNodeType type);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNodeChangedEventArgs> GetEventArgs(SharedPtr<XmlNode> node, SharedPtr<XmlNode> oldParent, SharedPtr<XmlNode> newParent, String oldValue, String newValue, XmlNodeChangedAction action);

    virtual ASPOSECPP_SHARED_API void BeforeEvent(SharedPtr<XmlNodeChangedEventArgs> args);

    virtual ASPOSECPP_SHARED_API void AfterEvent(SharedPtr<XmlNodeChangedEventArgs> args);

    virtual ASPOSECPP_SHARED_API String GetXPAttribute(String localName, String namespaceURI);

    static void NestTextNodes(const SharedPtr<XmlNode>& prevNode, const SharedPtr<XmlNode>& nextNode);

    static void UnnestTextNodes(const SharedPtr<XmlNode>& prevNode, const SharedPtr<XmlNode>& nextNode);


    virtual ASPOSECPP_SHARED_API ~XmlNode();


    #ifdef ASPOSE_GET_SHARED_MEMBERS

    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;

    #endif


private:


    SharedPtr<XmlNode> NormalizeWinner(const SharedPtr<XmlNode>& firstNode, const SharedPtr<XmlNode>& secondNode);

    void AppendChildText(const SharedPtr<Text::StringBuilder>& builder);


};


} // namespace Xml

} // namespace System


System::Collections::Generic::IEnumerable
Interface of object providing enumerator on contained elements.
Definition: ienumerable.h:25

System::SmartPtr
Pointer class to wrap types being allocated on heap. Use it to manage memory for classes inheriting O...
Definition: smart_ptr.h:180

System::String
String class used across the library. Is a substitute for C# System.String when translating code....
Definition: string.h:122

System::WeakPtr
Subclass of System::SmartPtr which sets itself to weak mode at construction. Please note that this cl...
Definition: weak_ptr.h:18

System::Xml::XPath::IXPathNavigable
Provides an accessor to the XPathNavigator class.
Definition: ixpath_navigable.h:29

System::Xml::XmlAttributeCollection
Represents a collection of attributes that can be accessed by name or index.
Definition: xml_attribute_collection.h:35

System::Xml::XmlAttribute
Represents an attribute. Valid and default values for the attribute are defined in a document type de...
Definition: xml_attribute.h:50

System::Xml::XmlCDataSection
Represents a CDATA section.
Definition: xml_cdata_section.h:36

System::Xml::XmlCharacterData
Provides text manipulation methods that are used by several classes.
Definition: xml_character_data.h:36

System::Xml::XmlDocument
Represents an XML document. You can use this class to load, validate, edit, add, and position XML in ...
Definition: xml_document.h:100

System::Xml::XmlElement
Represents an element.
Definition: xml_element.h:51

System::Xml::XmlEntity
Represents an entity declaration, such as <!ENTITY... >.
Definition: xml_entity.h:32

System::Xml::XmlEntityReference
Represents an entity reference node.
Definition: xml_entity_reference.h:32

System::Xml::XmlLinkedNode
Returns the node immediately preceding or following this node.
Definition: xml_linked_node.h:32

System::Xml::XmlNamedNodeMap
Represents a collection of nodes that can be accessed by name or index.
Definition: xml_named_node_map.h:43

System::Xml::XmlNamespaceManager
Resolves, adds, and removes namespaces to a collection and provides scope management for these namesp...
Definition: xml_namespace_manager.h:44

System::Xml::XmlNodeChangedEventArgs
Provides data for the XmlDocument::NodeChanged, XmlDocument::NodeChanging, XmlDocument::NodeInserted,...
Definition: xml_node_changed_event_args.h:30

System::Xml::XmlNode
Represents a single node in the XML document.
Definition: xml_node.h:75

System::Xml::XmlNode::get_Name
virtual String get_Name()=0
Returns the qualified name of the node, when overridden in a derived class.

System::Xml::XmlNode::set_Value
virtual void set_Value(String value)
Sets the value of the node.

System::Xml::XmlNode::get_Value
virtual String get_Value()
Returns the value of the node.

System::Xml::XmlNode::get_ParentNode
virtual SharedPtr< XmlNode > get_ParentNode() final
Returns the parent of this node (for nodes that can have parents).

System::Xml::XmlNode::get_NodeType
virtual XmlNodeType get_NodeType()=0
Returns the type of the current node, when overridden in a derived class.

System::Xml::XmlNodeList
Represents an ordered collection of nodes.
Definition: xml_node_list.h:33

System::Xml::XmlNotation
Represents a notation declaration, such as <!NOTATION... >.
Definition: xml_notation.h:31

System::Xml::XmlSignificantWhitespace
Represents white space between markup in a mixed content node or white space within an xml:space='pre...
Definition: xml_significant_whitespace.h:37

System::Xml::XmlText
Represents the text content of an element or attribute.
Definition: xml_text.h:37

System::Xml::XmlWhitespace
Represents white space in element content.
Definition: xml_whitespace.h:36

System::Xml::XmlWriter
Represents a writer that provides a fast, non-cached, forward-only way to generate streams or files t...
Definition: xml_writer.h:45

System::Drawing::Imaging::ColorAdjustType::Text
@ Text
Defines color adjustment information for text.

System::Xml::XPath::XPathNodeType
XPathNodeType
Defines the XPath node types that can be returned from the XPathNavigator class.
Definition: xpath_node_type.h:17

System::Xml::XmlSpace
XmlSpace
Specifies the current xml:space scope.
Definition: xml_space.h:15

System::Xml::ValidationType::Schema
@ Schema
Validate according to XML Schema definition language (XSD) schemas, including inline XML Schemas....

System::Xml::XmlOutputMethod::Xml
@ Xml
Serialize according to the XML 1.0 rules.

System::Xml::XmlNodeChangedAction
XmlNodeChangedAction
Specifies the type of node change.
Definition: xml_node_changed_action.h:15

System::Xml::XmlNodeType
XmlNodeType
Specifies the type of node.
Definition: xml_node_type.h:15

System
Definition: db_command.h:9