csharp-to-cpp/apireference/xml__document_8h_source.html

#pragma once


#include <xml/xml_node_type.h>

#include <xml/xml_node_changed_event_handler.h>

#include <xml/xml_node.h>

#include <xml/schema/validation_event_handler.h>

#include <system/string.h>


namespace System

{

namespace Collections

{

namespace Generic

{

template <typename, typename> class Dictionary;

template <typename> class List;

} // namespace Generic

} // namespace Collections

namespace IO

{

class Stream;

class TextReader;

class TextWriter;

} // namespace IO

namespace Text

{

class Encoding;

} // namespace Text

template <typename... Args> class WeakReference;

namespace Xml

{

class DocumentSchemaValidator;

class DocumentXmlWriter;

class DocumentXPathNavigator;

class DomNameTable;

class EmptyEnumerator;

namespace Schema

{

class IXmlSchemaInfo;

class SchemaAttDef;

class SchemaElementDecl;

class SchemaInfo;

class XmlSchemaSet;

} // namespace Schema

class XmlAttribute;

class XmlAttributeCollection;

class XmlCDataSection;

class XmlCharacterData;

class XmlChildNodes;

class XmlComment;

class XmlDeclaration;

class XmlDocumentFragment;

class XmlDocumentType;

class XmlElement;

class XmlEntity;

class XmlEntityReference;

class XmlImplementation;

class XmlLinkedNode;

class XmlLoader;

class XmlName;

class XmlNamedNodeMap;

class XmlNameEx;

class XmlNameTable;

enum class XmlNodeChangedAction;

class XmlNodeChangedEventArgs;

class XmlNodeList;

class XmlNodeReader;

class XmlNodeReaderNavigator;

class XmlProcessingInstruction;

class XmlReader;

class XmlResolver;

class XmlSignificantWhitespace;

class XmlText;

class XmlTextReader;

class XmlUnspecifiedAttribute;

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 XmlDocument : public XmlNode

{

    typedef XmlDocument ThisType;

    typedef XmlNode BaseType;


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

    ASPOSECPP_SHARED_RTTI_INFO_DECL();


public:


    using Ptr = SharedPtr<XmlDocument>;


private:

    friend class DocumentSchemaValidator;

    friend class DocumentXmlWriter;

    friend class DocumentXPathNavigator;

    friend class XmlAttribute;

    friend class XmlNode;

    friend class XmlAttributeCollection;

    friend class XmlNamedNodeMap;

    friend class XmlCDataSection;

    friend class XmlCharacterData;

    friend class XmlChildNodes;

    friend class XmlComment;

    friend class XmlDocumentFragment;

    friend class XmlDocumentType;

    friend class XmlElement;

    friend class XmlEntityReference;

    friend class XmlImplementation;

    friend class XmlLoader;

    friend class XmlNameEx;

    friend class XmlNamedNodeMap;

    friend class XmlNodeReader;

    friend class XmlNodeReaderNavigator;

    friend class XmlSignificantWhitespace;

    friend class XmlText;

    friend class XmlUnspecifiedAttribute;

    friend class XmlWhitespace;


public:


    XmlNodeChangedEventHandler NodeInserting;

    XmlNodeChangedEventHandler NodeInserted;

    XmlNodeChangedEventHandler NodeRemoving;

    XmlNodeChangedEventHandler NodeRemoved;

    XmlNodeChangedEventHandler NodeChanging;

    XmlNodeChangedEventHandler NodeChanged;


    ASPOSECPP_SHARED_API XmlNodeType get_NodeType() override;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDocumentType> get_DocumentType();

    ASPOSECPP_SHARED_API SharedPtr<XmlImplementation> get_Implementation();

    ASPOSECPP_SHARED_API String get_Name() override;

    ASPOSECPP_SHARED_API String get_LocalName() override;

    ASPOSECPP_SHARED_API SharedPtr<XmlElement> get_DocumentElement();

    ASPOSECPP_SHARED_API SharedPtr<XmlDocument> get_OwnerDocument() override;

    ASPOSECPP_SHARED_API SharedPtr<Schema::XmlSchemaSet> get_Schemas();

    ASPOSECPP_SHARED_API void set_Schemas(const SharedPtr<Schema::XmlSchemaSet>& value);

    virtual ASPOSECPP_SHARED_API void set_XmlResolver(SharedPtr<System::Xml::XmlResolver> value);

    ASPOSECPP_SHARED_API SharedPtr<XmlNameTable> get_NameTable();

    ASPOSECPP_SHARED_API bool get_PreserveWhitespace();

    ASPOSECPP_SHARED_API void set_PreserveWhitespace(bool value);

    ASPOSECPP_SHARED_API bool get_IsReadOnly() override;

    ASPOSECPP_SHARED_API void set_InnerText(String value) override;

    ASPOSECPP_SHARED_API String get_InnerXml() override;

    ASPOSECPP_SHARED_API void set_InnerXml(String value) override;

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

    ASPOSECPP_SHARED_API String get_BaseURI() override;


    ASPOSECPP_SHARED_API XmlDocument();

    ASPOSECPP_SHARED_API XmlDocument(const SharedPtr<XmlNameTable>& nt);


    ASPOSECPP_SHARED_API SharedPtr<XmlNode> CloneNode(bool deep) override;

    ASPOSECPP_SHARED_API SharedPtr<XmlAttribute> CreateAttribute(const String& name);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlCDataSection> CreateCDataSection(const String& data);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlComment> CreateComment(const String& data);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDocumentType> CreateDocumentType(const String& name, const String& publicId, const String& systemId, const String& internalSubset);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDocumentFragment> CreateDocumentFragment();

    ASPOSECPP_SHARED_API SharedPtr<XmlElement> CreateElement(const String& name);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlEntityReference> CreateEntityReference(const String& name);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlProcessingInstruction> CreateProcessingInstruction(const String& target, const String& data);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDeclaration> CreateXmlDeclaration(const String& version, const String& encoding, const String& standalone);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlText> CreateTextNode(const String& text);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlSignificantWhitespace> CreateSignificantWhitespace(const String& text);

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

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWhitespace> CreateWhitespace(const String& text);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNodeList> GetElementsByTagName(String name);

    ASPOSECPP_SHARED_API SharedPtr<XmlAttribute> CreateAttribute(const String& qualifiedName, const String& namespaceURI);

    ASPOSECPP_SHARED_API SharedPtr<XmlElement> CreateElement(const String& qualifiedName, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNodeList> GetElementsByTagName(String localName, String namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlElement> GetElementById(String elementId);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> ImportNode(SharedPtr<XmlNode> node, bool deep);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlAttribute> CreateAttribute(const String& prefix, const String& localName, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlElement> CreateElement(const String& prefix, const String& localName, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> CreateNode(XmlNodeType type, const String& prefix, const String& name, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> CreateNode(const String& nodeTypeString, const String& name, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> CreateNode(XmlNodeType type, const String& name, const String& namespaceURI);

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> ReadNode(SharedPtr<XmlReader> reader);

    virtual ASPOSECPP_SHARED_API void Load(String filename);

    virtual ASPOSECPP_SHARED_API void Load(SharedPtr<IO::Stream> inStream);

    virtual ASPOSECPP_SHARED_API void Load(SharedPtr<IO::TextReader> txtReader);

    virtual ASPOSECPP_SHARED_API void Load(SharedPtr<XmlReader> reader);

    virtual ASPOSECPP_SHARED_API void LoadXml(String xml);

    virtual ASPOSECPP_SHARED_API void Save(String filename);

    virtual ASPOSECPP_SHARED_API void Save(SharedPtr<IO::Stream> outStream);

    virtual ASPOSECPP_SHARED_API void Save(SharedPtr<IO::TextWriter> writer);

    virtual ASPOSECPP_SHARED_API void Save(SharedPtr<XmlWriter> w);

    ASPOSECPP_SHARED_API void WriteTo(const SharedPtr<XmlWriter>& w) override;

    ASPOSECPP_SHARED_API void WriteContentTo(const SharedPtr<XmlWriter>& xw) override;

    ASPOSECPP_SHARED_API void Validate(Schema::ValidationEventHandler validationEventHandler);

    ASPOSECPP_SHARED_API void Validate(Schema::ValidationEventHandler validationEventHandler, const SharedPtr<XmlNode>& nodeToValidate);


protected:


    bool fEntRefNodesPresent;

    bool fCDataNodesPresent;

    String strDocumentName;

    String strDocumentFragmentName;

    String strCommentName;

    String strTextName;

    String strCDataSectionName;

    String strEntityName;

    String strID;

    String strXmlns;

    String strXml;

    String strSpace;

    String strLang;

    String strEmpty;

    String strNonSignificantWhitespaceName;

    String strSignificantWhitespaceName;

    String strReservedXmlns;

    String strReservedXml;

    String baseURI;

    bool bSetResolver;

    SharedPtr<Object> objLock;

    static SharedPtr<System::Xml::EmptyEnumerator> EmptyEnumerator;

    static SharedPtr<Schema::IXmlSchemaInfo> NotKnownSchemaInfo;

    static SharedPtr<Schema::IXmlSchemaInfo> ValidSchemaInfo;

    static SharedPtr<Schema::IXmlSchemaInfo> InvalidSchemaInfo;


    SharedPtr<System::Xml::Schema::SchemaInfo> get_DtdSchemaInfo();

    void set_DtdSchemaInfo(const SharedPtr<System::Xml::Schema::SchemaInfo>& value);

    ASPOSECPP_SHARED_API SharedPtr<XmlNode> get_ParentNodeInternal() override;

    virtual ASPOSECPP_SHARED_API SharedPtr<XmlDeclaration> get_Declaration();

    SharedPtr<XmlElement> get_DocumentElementInternal();

    ASPOSECPP_SHARED_API bool get_IsContainer() override;

    ASPOSECPP_SHARED_API SharedPtr<XmlLinkedNode> get_LastNode() override;

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

    bool get_CanReportValidity();

    bool get_HasSetResolver();

    SharedPtr<XmlNamedNodeMap> get_Entities();

    void set_Entities(const SharedPtr<XmlNamedNodeMap>& value);

    bool get_IsLoading();

    void set_IsLoading(bool value);

    bool get_ActualLoadingStatus();

    void set_ActualLoadingStatus(bool value);

    SharedPtr<System::Text::Encoding> get_TextEncoding();

    String get_Version();

    String get_Encoding();

    String get_Standalone();

    ASPOSECPP_SHARED_API XPath::XPathNodeType get_XPNodeType() override;

    bool get_HasEntityReferences();

    SharedPtr<XmlAttribute> get_NamespaceXml();


    ASPOSECPP_SHARED_API XmlDocument(const SharedPtr<XmlImplementation>& imp);


    ASPOSECPP_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(XmlDocument, CODEPORTING_ARGS(SharedPtr<XmlImplementation> imp));


    static void CheckName(const String& name);

    SharedPtr<XmlName> AddXmlName(const String& prefix, const String& localName, const String& namespaceURI, const SharedPtr<Schema::IXmlSchemaInfo>& schemaInfo);

    SharedPtr<XmlName> GetXmlName(const String& prefix, const String& localName, const String& namespaceURI, const SharedPtr<Schema::IXmlSchemaInfo>& schemaInfo);

    SharedPtr<XmlName> AddAttrXmlName(const String& prefix, const String& localName, const String& namespaceURI, const SharedPtr<Schema::IXmlSchemaInfo>& schemaInfo);

    bool AddIdInfo(const SharedPtr<XmlName>& eleName, const SharedPtr<XmlName>& attrName);

    SharedPtr<XmlName> GetIDInfoByElement(const SharedPtr<XmlName>& eleName);

    void AddElementWithId(const String& id, const SharedPtr<XmlElement>& elem);

    void RemoveElementWithId(const String& id, const SharedPtr<XmlElement>& elem);

    SharedPtr<System::Xml::XmlResolver> GetResolver();

    ASPOSECPP_SHARED_API bool IsValidChildType(XmlNodeType type) override;

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

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

    void SetDefaultNamespace(const String& prefix, const String& localName, String& namespaceURI);

    void AddDefaultAttributes(const SharedPtr<XmlElement>& elem);


    virtual ASPOSECPP_SHARED_API SharedPtr<XPath::XPathNavigator> CreateNavigator(SharedPtr<XmlNode> node);


    static bool IsTextNode(XmlNodeType nt);


    virtual ASPOSECPP_SHARED_API SharedPtr<XmlAttribute> CreateDefaultAttribute(const String& prefix, const String& localName, const String& namespaceURI);


    XmlNodeType ConvertToNodeType(const String& nodeTypeString);

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

    SharedPtr<XmlNodeChangedEventArgs> GetInsertEventArgsForLoad(const SharedPtr<XmlNode>& node, const SharedPtr<XmlNode>& newParent);

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

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

    SharedPtr<XmlAttribute> GetDefaultAttribute(const SharedPtr<XmlElement>& elem, const String& attrPrefix, const String& attrLocalname, const String& attrNamespaceURI);

    SharedPtr<XmlEntity> GetEntityNode(const String& name);

    void SetBaseURI(const String& inBaseURI);

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


    virtual ASPOSECPP_SHARED_API ~XmlDocument();


    #ifdef ASPOSE_GET_SHARED_MEMBERS

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

    #endif


private:


    SharedPtr<XmlImplementation> _implementation;

    SharedPtr<DomNameTable> _domNameTable;

    SharedPtr<XmlLinkedNode> _lastChild;

    SharedPtr<XmlNamedNodeMap> _entities;

    SharedPtr<Collections::Generic::Dictionary<String, SharedPtr<Collections::Generic::List<WeakReference<>>>>> _htElementIdMap;

    SharedPtr<Collections::Generic::Dictionary<SharedPtr<XmlName>, SharedPtr<XmlName>>> _htElementIDAttrDecl;

    SharedPtr<System::Xml::Schema::SchemaInfo> _schemaInfo;

    SharedPtr<Schema::XmlSchemaSet> _schemas;

    bool _reportValidity;

    bool _actualLoadingStatus;

    bool _preserveWhitespace;

    bool _isLoading;

    SharedPtr<System::Xml::XmlResolver> _resolver;

    SharedPtr<XmlAttribute> _namespaceXml;


    SharedPtr<XmlName> GetIDInfoByElement_(const SharedPtr<XmlName>& eleName);

    WeakReference<> GetElement(const SharedPtr<Collections::Generic::List<WeakReference<>>>& elementList, const SharedPtr<XmlElement>& elem);

    bool HasNodeTypeInPrevSiblings(XmlNodeType nt, const SharedPtr<XmlNode>& refNode);

    bool HasNodeTypeInNextSiblings(XmlNodeType nt, const SharedPtr<XmlNode>& refNode);

    SharedPtr<Schema::SchemaElementDecl> GetSchemaElementDecl(const SharedPtr<XmlElement>& elem);

    SharedPtr<XmlAttribute> PrepareDefaultAttribute(const SharedPtr<Schema::SchemaAttDef>& attdef, const String& attrPrefix, const String& attrLocalname, String attrNamespaceURI);

    SharedPtr<XmlNode> NormalizeText(SharedPtr<XmlNode> n);

    SharedPtr<XmlNode> ImportNodeInternal(const SharedPtr<XmlNode>& node, bool deep);

    void ImportAttributes(const SharedPtr<XmlNode>& fromElem, const SharedPtr<XmlNode>& toElem);

    void ImportChildren(const SharedPtr<XmlNode>& fromNode, const SharedPtr<XmlNode>& toNode, bool deep);

    SharedPtr<XmlTextReader> SetupReader(const SharedPtr<XmlTextReader>& tr);


    static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;


};


} // namespace Xml

} // namespace System


System::Collections::Generic::List
List forward declaration.
Definition: list.h:127

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::WeakReference<>
Represents a weak reference, which references an object while still allowing that object to be delete...
Definition: weak_reference.h:107

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::XmlComment
Represents the content of an XML comment.
Definition: xml_comment.h:36

System::Xml::XmlDocumentFragment
Represents a lightweight object that is useful for tree insert operations.
Definition: xml_document_fragment.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::XmlDocument::CreateElement
SharedPtr< XmlElement > CreateElement(const String &qualifiedName, const String &namespaceURI)
Creates an XmlElement with the qualified name and XmlNode::get_NamespaceURI.

System::Xml::XmlDocument::set_Schemas
void set_Schemas(const SharedPtr< Schema::XmlSchemaSet > &value)
Sets the XmlSchemaSet object associated with this XmlDocument.

System::Xml::XmlDocument::Validate
void Validate(Schema::ValidationEventHandler validationEventHandler, const SharedPtr< XmlNode > &nodeToValidate)
Validates the XmlNode object specified against the XML Schema Definition Language (XSD) schemas in th...

System::Xml::XmlDocument::CreateAttribute
virtual SharedPtr< XmlAttribute > CreateAttribute(const String &prefix, const String &localName, const String &namespaceURI)
Creates an XmlAttribute with the specified XmlNode::get_Prefix, XmlDocument::get_LocalName,...

System::Xml::XmlDocument::CreateComment
virtual SharedPtr< XmlComment > CreateComment(const String &data)
Creates an XmlComment containing the specified data.

System::Xml::XmlDocument::get_NameTable
SharedPtr< XmlNameTable > get_NameTable()
Returns the XmlNameTable associated with this implementation.

System::Xml::XmlDocument::get_Name
String get_Name() override
Returns the qualified name of the node.

System::Xml::XmlDocument::Load
virtual void Load(SharedPtr< IO::Stream > inStream)
Loads the XML document from the specified stream.

System::Xml::XmlDocument::CloneNode
SharedPtr< XmlNode > CloneNode(bool deep) override
Creates a duplicate of this node.

System::Xml::XmlDocument::CreateAttribute
SharedPtr< XmlAttribute > CreateAttribute(const String &qualifiedName, const String &namespaceURI)
Creates an XmlAttribute with the specified qualified name and XmlNode::get_NamespaceURI.

System::Xml::XmlDocument::CreateWhitespace
virtual SharedPtr< XmlWhitespace > CreateWhitespace(const String &text)
Creates an XmlWhitespace node.

System::Xml::XmlDocument::XmlDocument
XmlDocument(const SharedPtr< XmlImplementation > &imp)
Initializes a new instance of the XmlDocument class with the specified XmlImplementation.

System::Xml::XmlDocument::Validate
void Validate(Schema::ValidationEventHandler validationEventHandler)
Validates the XmlDocument against the XML Schema Definition Language (XSD) schemas contained in the X...

System::Xml::XmlDocument::CreateDocumentType
virtual SharedPtr< XmlDocumentType > CreateDocumentType(const String &name, const String &publicId, const String &systemId, const String &internalSubset)
Returns a new XmlDocumentType object.

System::Xml::XmlDocument::CreateEntityReference
virtual SharedPtr< XmlEntityReference > CreateEntityReference(const String &name)
Creates an XmlEntityReference with the specified name.

System::Xml::XmlDocument::CreateNavigator
SharedPtr< XPath::XPathNavigator > CreateNavigator() override
Creates a new XPathNavigator object for navigating this document.

System::Xml::XmlDocument::CreateTextNode
virtual SharedPtr< XmlText > CreateTextNode(const String &text)
Creates an XmlText with the specified text.

System::Xml::XmlDocument::get_NodeType
XmlNodeType get_NodeType() override
Returns the type of the current node.

System::Xml::XmlDocument::CreateDefaultAttribute
virtual SharedPtr< XmlAttribute > CreateDefaultAttribute(const String &prefix, const String &localName, const String &namespaceURI)
Creates a default attribute with the specified prefix, local name and namespace URI.

System::Xml::XmlDocument::NodeInserted
XmlNodeChangedEventHandler NodeInserted
Occurs when a node belonging to this document has been inserted into another node.
Definition: xml_document.h:146

System::Xml::XmlDocument::Save
virtual void Save(SharedPtr< IO::TextWriter > writer)
Saves the XML document to the specified TextWriter.

System::Xml::XmlDocument::ImportNode
virtual SharedPtr< XmlNode > ImportNode(SharedPtr< XmlNode > node, bool deep)
Imports a node from another document to the current document.

System::Xml::XmlDocument::WriteContentTo
void WriteContentTo(const SharedPtr< XmlWriter > &xw) override
Saves all the children of the XmlDocument node to the specified XmlWriter.

System::Xml::XmlDocument::XmlDocument
XmlDocument(const SharedPtr< XmlNameTable > &nt)
Initializes a new instance of the XmlDocument class with the specified XmlNameTable.

System::Xml::XmlDocument::get_DocumentType
virtual SharedPtr< XmlDocumentType > get_DocumentType()
Returns the node containing the DOCTYPE declaration.

System::Xml::XmlDocument::XmlDocument
XmlDocument()
Initializes a new instance of the XmlDocument class.

System::Xml::XmlDocument::GetElementsByTagName
virtual SharedPtr< XmlNodeList > GetElementsByTagName(String localName, String namespaceURI)
Returns an XmlNodeList containing a list of all descendant elements that match the specified XmlDocum...

System::Xml::XmlDocument::Save
virtual void Save(SharedPtr< IO::Stream > outStream)
Saves the XML document to the specified stream.

System::Xml::XmlDocument::Load
virtual void Load(String filename)
Loads the XML document from the specified URL.

System::Xml::XmlDocument::CreateProcessingInstruction
virtual SharedPtr< XmlProcessingInstruction > CreateProcessingInstruction(const String &target, const String &data)
Creates an XmlProcessingInstruction with the specified name and data.

System::Xml::XmlDocument::CreateAttribute
SharedPtr< XmlAttribute > CreateAttribute(const String &name)
Creates an XmlAttribute with the specified name.

System::Xml::XmlDocument::CreateNode
virtual SharedPtr< XmlNode > CreateNode(XmlNodeType type, const String &name, const String &namespaceURI)
Creates an XmlNode with the specified XmlNodeType, XmlDocument::get_Name, and XmlNode::get_NamespaceU...

System::Xml::XmlDocument::NodeRemoving
XmlNodeChangedEventHandler NodeRemoving
Occurs when a node belonging to this document is about to be removed from the document.
Definition: xml_document.h:148

System::Xml::XmlDocument::Load
virtual void Load(SharedPtr< IO::TextReader > txtReader)
Loads the XML document from the specified TextReader.

System::Xml::XmlDocument::get_BaseURI
String get_BaseURI() override
Returns the base URI of the current node.

System::Xml::XmlDocument::ReadNode
virtual SharedPtr< XmlNode > ReadNode(SharedPtr< XmlReader > reader)
Creates an XmlNode object based on the information in the XmlReader. The reader must be positioned on...

System::Xml::XmlDocument::set_PreserveWhitespace
void set_PreserveWhitespace(bool value)
Sets a value indicating whether to preserve white space in element content.

System::Xml::XmlDocument::get_InnerXml
String get_InnerXml() override
Returns the markup representing the children of the current node.

System::Xml::XmlDocument::get_IsReadOnly
bool get_IsReadOnly() override
Returns a value indicating whether the current node is read-only.

System::Xml::XmlDocument::set_InnerXml
void set_InnerXml(String value) override
Sets the markup representing the children of the current node.

System::Xml::XmlDocument::NodeInserting
XmlNodeChangedEventHandler NodeInserting
Occurs when a node belonging to this document is about to be inserted into another node.
Definition: xml_document.h:144

System::Xml::XmlDocument::set_XmlResolver
virtual void set_XmlResolver(SharedPtr< System::Xml::XmlResolver > value)
Sets the XmlResolver to use for resolving external resources.

System::Xml::XmlDocument::CreateNavigator
virtual SharedPtr< XPath::XPathNavigator > CreateNavigator(SharedPtr< XmlNode > node)
Creates an XPathNavigator object for navigating this document positioned on the XmlNode specified.

System::Xml::XmlDocument::CreateSignificantWhitespace
virtual SharedPtr< XmlSignificantWhitespace > CreateSignificantWhitespace(const String &text)
Creates an XmlSignificantWhitespace node.

System::Xml::XmlDocument::get_Schemas
SharedPtr< Schema::XmlSchemaSet > get_Schemas()
Returns the XmlSchemaSet object associated with this XmlDocument.

System::Xml::XmlDocument::set_InnerText
void set_InnerText(String value) override
Throws an InvalidOperationException in all cases.

System::Xml::XmlDocument::CreateXmlDeclaration
virtual SharedPtr< XmlDeclaration > CreateXmlDeclaration(const String &version, const String &encoding, const String &standalone)
Creates an XmlDeclaration node with the specified values.

System::Xml::XmlDocument::get_DocumentElement
SharedPtr< XmlElement > get_DocumentElement()
Returns the root XmlElement for the document.

System::Xml::XmlDocument::CreateElement
virtual SharedPtr< XmlElement > CreateElement(const String &prefix, const String &localName, const String &namespaceURI)
Creates an element with the specified XmlNode::get_Prefix, XmlDocument::get_LocalName,...

System::Xml::XmlDocument::NodeChanging
XmlNodeChangedEventHandler NodeChanging
Occurs when the XmlNode::get_Value of a node belonging to this document is about to be changed.
Definition: xml_document.h:152

System::Xml::XmlDocument::GetElementById
virtual SharedPtr< XmlElement > GetElementById(String elementId)
Returns the XmlElement with the specified ID.

System::Xml::XmlDocument::get_SchemaInfo
SharedPtr< Schema::IXmlSchemaInfo > get_SchemaInfo() override
Returns the Post-Schema-Validation-Infoset (PSVI) of the node.

System::Xml::XmlDocument::CreateElement
SharedPtr< XmlElement > CreateElement(const String &name)
Creates an element with the specified name.

System::Xml::XmlDocument::get_Implementation
SharedPtr< XmlImplementation > get_Implementation()
Returns the XmlImplementation object for the current document.

System::Xml::XmlDocument::MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION
MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(XmlDocument, CODEPORTING_ARGS(SharedPtr< XmlImplementation > imp))

System::Xml::XmlDocument::get_LocalName
String get_LocalName() override
Returns the local name of the node.

System::Xml::XmlDocument::CreateCDataSection
virtual SharedPtr< XmlCDataSection > CreateCDataSection(const String &data)
Creates an XmlCDataSection containing the specified data.

System::Xml::XmlDocument::CreateDocumentFragment
virtual SharedPtr< XmlDocumentFragment > CreateDocumentFragment()
Creates an XmlDocumentFragment.

System::Xml::XmlDocument::NodeChanged
XmlNodeChangedEventHandler NodeChanged
Occurs when the XmlNode::get_Value of a node belonging to this document has been changed.
Definition: xml_document.h:154

System::Xml::XmlDocument::CreateNode
virtual SharedPtr< XmlNode > CreateNode(const String &nodeTypeString, const String &name, const String &namespaceURI)
Creates an XmlNode with the specified node type, XmlDocument::get_Name, and XmlNode::get_NamespaceURI...

System::Xml::XmlDocument::Save
virtual void Save(SharedPtr< XmlWriter > w)
Saves the XML document to the specified XmlWriter.

System::Xml::XmlDocument::GetElementsByTagName
virtual SharedPtr< XmlNodeList > GetElementsByTagName(String name)
Returns an XmlNodeList containing a list of all descendant elements that match the specified name.

System::Xml::XmlDocument::LoadXml
virtual void LoadXml(String xml)
Loads the XML document from the specified string.

System::Xml::XmlDocument::NodeRemoved
XmlNodeChangedEventHandler NodeRemoved
Occurs when a node belonging to this document has been removed from its parent.
Definition: xml_document.h:150

System::Xml::XmlDocument::get_OwnerDocument
SharedPtr< XmlDocument > get_OwnerDocument() override
Returns the XmlDocument to which the current node belongs.

System::Xml::XmlDocument::get_PreserveWhitespace
bool get_PreserveWhitespace()
Returns a value indicating whether to preserve white space in element content.

System::Xml::XmlDocument::WriteTo
void WriteTo(const SharedPtr< XmlWriter > &w) override
Saves the XmlDocument node to the specified XmlWriter.

System::Xml::XmlDocument::Save
virtual void Save(String filename)
Saves the XML document to the specified file. If the specified file exists, this method overwrites it...

System::Xml::XmlDocument::~XmlDocument
virtual ~XmlDocument()

System::Xml::XmlDocument::CreateNode
virtual SharedPtr< XmlNode > CreateNode(XmlNodeType type, const String &prefix, const String &name, const String &namespaceURI)
Creates a XmlNode with the specified XmlNodeType, XmlNode::get_Prefix, XmlDocument::get_Name,...

System::Xml::XmlDocument::Load
virtual void Load(SharedPtr< XmlReader > reader)
Loads the XML document from the specified XmlReader.

System::Xml::XmlDocumentType
Represents the document type declaration.
Definition: xml_document_type.h:37

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

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

System::Xml::XmlImplementation
Defines the context for a set of XmlDocument objects.
Definition: xml_implementation.h:29

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::XmlNode
Represents a single node in the XML document.
Definition: xml_node.h:75

System::Xml::XmlNodeReader
Represents a reader that provides fast, non-cached forward only access to XML data in an XmlNode.
Definition: xml_node_reader.h:49

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::Collections::Generic::List
class ASPOSECPP_SHARED_CLASS List
Definition: ienumerable.h:18

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

System::Net::Sockets::SocketType::Stream
@ Stream
The type that supports reliable, two-way, connection-based byte streams without duplication of data a...

System::Xml::Schema::ValidationEventHandler
System::MulticastDelegate< void(SharedPtr< Object >, SharedPtr< ValidationEventArgs >)> ValidationEventHandler
Represents the callback method that will handle XML schema validation events and the ValidationEventA...
Definition: validation_event_handler.h:33

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::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::XmlNodeChangedEventHandler
System::MulticastDelegate< void(SharedPtr< Object >, SharedPtr< XmlNodeChangedEventArgs >)> XmlNodeChangedEventHandler
Represents the method that handles XmlDocument::NodeChanged, XmlDocument::NodeChanging,...
Definition: xml_node_changed_event_handler.h:25

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::Xml::XmlNodeType::XmlDeclaration
@ XmlDeclaration
The XML declaration (for example, <?xml version='1.0'?>). The XmlNodeType::XmlDeclaration node must b...

System
Definition: db_command.h:9

System::WeakReference
class ASPOSECPP_SHARED_CLASS WeakReference
Represents a weak reference, which references an object while still allowing that object to be delete...
Definition: weak_reference.h:13