xpath_navigator.h

 
 
#pragma once
 
#include <xml/xpath/xpath_node_type.h>
#include <xml/xpath/xpath_namespace_scope.h>
#include <xml/xpath/xpath_item.h>
#include <xml/xpath/ixpath_navigable.h>
#include <xml/xml_node_order.h>
#include <xml/xml_namespace_scope.h>
#include <xml/schema/validation_event_handler.h>
#include <xml/ixml_namespace_resolver.h>
#include <system/array.h>
#include <cstdint>
 
 
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename, typename> class IDictionary;
template <typename> class IEqualityComparer;
} // namespace Generic
} // namespace Collections
class DateTime;
namespace Internal
{
namespace Xml
{
namespace Cache
{
class XPathDocumentBuilder;
class XPathDocumentElementDescendantIterator;
class XPathDocumentKindDescendantIterator;
class XPathNode;
class XPathNodeHelper;
} // namespace Cache
namespace XPath
{
class XPathArrayIterator;
} // namespace XPath
} // namespace Xml
} // namespace Internal
class TypeInfo;
namespace Xml
{
namespace Schema
{
class IXmlSchemaInfo;
class ValidationEventArgs;
class XmlSchemaAttribute;
class XmlSchemaElement;
class XmlSchemaSet;
class XmlSchemaType;
} // namespace Schema
class XmlNamespaceManager;
class XmlNameTable;
class XmlReader;
class XmlWriter;
namespace XPath
{
class XPathExpression;
class XPathNavigatorKeyComparer;
class XPathNavigatorReader;
class XPathNodeIterator;
} // namespace XPath
namespace Xsl
{
namespace XsltOld
{
class XsltCompileContext;
} // namespace XsltOld
} // namespace Xsl
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
namespace XPath {
 
class ASPOSECPP_SHARED_CLASS XPathNavigator : public XPathItem, public IXPathNavigable, public IXmlNamespaceResolver
{
    typedef XPathNavigator ThisType;
    typedef XPathItem BaseType;
    typedef IXPathNavigable BaseType1;
    typedef IXmlNamespaceResolver BaseType2;
 
    typedef ::System::BaseTypesInfo<BaseType, BaseType1, BaseType2> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XPathNavigator>;
 
private:
    friend class Internal::Xml::Cache::XPathDocumentBuilder;
    friend class XPathNodeIterator;
    friend class Internal::Xml::Cache::XPathDocumentElementDescendantIterator;
    friend class Internal::Xml::Cache::XPathDocumentKindDescendantIterator;
    friend class Internal::Xml::Cache::XPathNode;
    friend class Internal::Xml::Cache::XPathNodeHelper;
    friend class Internal::Xml::XPath::XPathArrayIterator;
    friend class XPathNavigatorReader;
    friend class XPathNodeIterator;
    friend class Xsl::XsltOld::XsltCompileContext;
 
private:
 
    class CheckValidityHelper : public System::Object
    {
        typedef CheckValidityHelper ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_DECL();
 
    public:
 
        bool get_IsValid();
 
        CheckValidityHelper(System::Xml::Schema::ValidationEventHandler nextEventHandler, const SharedPtr<XPathNavigatorReader>& reader);
 
        void ValidationCallback(const SharedPtr<Object>& sender, const SharedPtr<System::Xml::Schema::ValidationEventArgs>& args);
 
    protected:
 
        #ifdef ASPOSE_GET_SHARED_MEMBERS
        void GetSharedMembers(System::Object::shared_members_type& result) const override;
        #endif
 
 
    private:
 
        bool _isValid;
        System::Xml::Schema::ValidationEventHandler _nextEventHandler;
        SharedPtr<XPathNavigatorReader> _reader;
 
    };
 
 
public:
 
    ASPOSECPP_SHARED_API bool get_IsNode() override;
    ASPOSECPP_SHARED_API SharedPtr<System::Xml::Schema::XmlSchemaType> get_XmlType() override;
    ASPOSECPP_SHARED_API SharedPtr<Object> get_TypedValue() override;
    ASPOSECPP_SHARED_API TypeInfo get_ValueType() override;
    ASPOSECPP_SHARED_API bool get_ValueAsBoolean() override;
    ASPOSECPP_SHARED_API DateTime get_ValueAsDateTime() override;
    ASPOSECPP_SHARED_API double get_ValueAsDouble() override;
    ASPOSECPP_SHARED_API int32_t get_ValueAsInt() override;
    ASPOSECPP_SHARED_API int64_t get_ValueAsLong() override;
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNameTable> get_NameTable() = 0;
    static ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IEqualityComparer<SharedPtr<XPathNavigator>>> get_NavigatorComparer();
    virtual ASPOSECPP_SHARED_API XPathNodeType get_NodeType() = 0;
    virtual ASPOSECPP_SHARED_API String get_LocalName() = 0;
    virtual ASPOSECPP_SHARED_API String get_Name() = 0;
    virtual ASPOSECPP_SHARED_API String get_NamespaceURI() = 0;
    virtual ASPOSECPP_SHARED_API String get_Prefix() = 0;
    virtual ASPOSECPP_SHARED_API String get_BaseURI() = 0;
    virtual ASPOSECPP_SHARED_API bool get_IsEmptyElement() = 0;
    virtual ASPOSECPP_SHARED_API String get_XmlLang();
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> get_UnderlyingObject();
    virtual ASPOSECPP_SHARED_API bool get_HasAttributes();
    virtual ASPOSECPP_SHARED_API bool get_HasChildren();
    virtual ASPOSECPP_SHARED_API SharedPtr<System::Xml::Schema::IXmlSchemaInfo> get_SchemaInfo();
    virtual ASPOSECPP_SHARED_API bool get_CanEdit();
    virtual ASPOSECPP_SHARED_API String get_OuterXml();
    virtual ASPOSECPP_SHARED_API void set_OuterXml(String value);
    virtual ASPOSECPP_SHARED_API String get_InnerXml();
    virtual ASPOSECPP_SHARED_API void set_InnerXml(String value);
 
    virtual ASPOSECPP_SHARED_API void SetValue(String value);
    virtual ASPOSECPP_SHARED_API void SetTypedValue(SharedPtr<Object> typedValue);
    ASPOSECPP_SHARED_API SharedPtr<Object> ValueAs(const TypeInfo& returnType, SharedPtr<IXmlNamespaceResolver> nsResolver) override;
    ASPOSECPP_SHARED_API SharedPtr<XPathNavigator> CreateNavigator() override;
    ASPOSECPP_SHARED_API String LookupNamespace(const String& prefix) override;
    ASPOSECPP_SHARED_API String LookupPrefix(const String& namespaceURI) override;
    ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IDictionary<String, String>> GetNamespacesInScope(XmlNamespaceScope scope) override;
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNavigator> Clone() = 0;
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlReader> ReadSubtree();
    virtual ASPOSECPP_SHARED_API void WriteSubtree(SharedPtr<XmlWriter> writer);
    virtual ASPOSECPP_SHARED_API String GetAttribute(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API bool MoveToAttribute(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API bool MoveToFirstAttribute() = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToNextAttribute() = 0;
    virtual ASPOSECPP_SHARED_API String GetNamespace(String name);
    virtual ASPOSECPP_SHARED_API bool MoveToNamespace(String name);
    virtual ASPOSECPP_SHARED_API bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) = 0;
    ASPOSECPP_SHARED_API bool MoveToFirstNamespace();
    ASPOSECPP_SHARED_API bool MoveToNextNamespace();
    virtual ASPOSECPP_SHARED_API bool MoveToNext() = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToPrevious() = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToFirst();
    virtual ASPOSECPP_SHARED_API bool MoveToFirstChild() = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToParent() = 0;
    virtual ASPOSECPP_SHARED_API void MoveToRoot();
    virtual ASPOSECPP_SHARED_API bool MoveTo(SharedPtr<XPathNavigator> other) = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToId(String id) = 0;
    virtual ASPOSECPP_SHARED_API bool MoveToChild(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API bool MoveToChild(XPathNodeType type);
    virtual ASPOSECPP_SHARED_API bool MoveToFollowing(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API bool MoveToFollowing(String localName, String namespaceURI, SharedPtr<XPathNavigator> end);
    virtual ASPOSECPP_SHARED_API bool MoveToFollowing(XPathNodeType type);
    virtual ASPOSECPP_SHARED_API bool MoveToFollowing(XPathNodeType type, SharedPtr<XPathNavigator> end);
    virtual ASPOSECPP_SHARED_API bool MoveToNext(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API bool MoveToNext(XPathNodeType type);
    virtual ASPOSECPP_SHARED_API bool IsSamePosition(SharedPtr<XPathNavigator> other) = 0;
    virtual ASPOSECPP_SHARED_API bool IsDescendant(SharedPtr<XPathNavigator> nav);
    virtual ASPOSECPP_SHARED_API XmlNodeOrder ComparePosition(SharedPtr<XPathNavigator> nav);
    virtual ASPOSECPP_SHARED_API bool CheckValidity(SharedPtr<System::Xml::Schema::XmlSchemaSet> schemas, System::Xml::Schema::ValidationEventHandler validationEventHandler);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathExpression> Compile(String xpath);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNavigator> SelectSingleNode(String xpath);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNavigator> SelectSingleNode(String xpath, SharedPtr<IXmlNamespaceResolver> resolver);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNavigator> SelectSingleNode(SharedPtr<XPathExpression> expression);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> Select(String xpath);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> Select(String xpath, SharedPtr<IXmlNamespaceResolver> resolver);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> Select(SharedPtr<XPathExpression> expr);
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> Evaluate(String xpath);
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> Evaluate(String xpath, SharedPtr<IXmlNamespaceResolver> resolver);
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> Evaluate(SharedPtr<XPathExpression> expr);
    virtual ASPOSECPP_SHARED_API SharedPtr<Object> Evaluate(SharedPtr<XPathExpression> expr, SharedPtr<XPathNodeIterator> context);
    virtual ASPOSECPP_SHARED_API bool Matches(SharedPtr<XPathExpression> expr);
    virtual ASPOSECPP_SHARED_API bool Matches(String xpath);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectChildren(XPathNodeType type);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectChildren(String name, String namespaceURI);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectAncestors(XPathNodeType type, bool matchSelf);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectAncestors(String name, String namespaceURI, bool matchSelf);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectDescendants(XPathNodeType type, bool matchSelf);
    virtual ASPOSECPP_SHARED_API SharedPtr<XPathNodeIterator> SelectDescendants(String name, String namespaceURI, bool matchSelf);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> PrependChild();
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> AppendChild();
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> InsertAfter();
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> InsertBefore();
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> CreateAttributes();
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlWriter> ReplaceRange(SharedPtr<XPathNavigator> lastSiblingToReplace);
    virtual ASPOSECPP_SHARED_API void ReplaceSelf(String newNode);
    virtual ASPOSECPP_SHARED_API void ReplaceSelf(SharedPtr<XmlReader> newNode);
    virtual ASPOSECPP_SHARED_API void ReplaceSelf(SharedPtr<XPathNavigator> newNode);
    virtual ASPOSECPP_SHARED_API void AppendChild(String newChild);
    virtual ASPOSECPP_SHARED_API void AppendChild(SharedPtr<XmlReader> newChild);
    virtual ASPOSECPP_SHARED_API void AppendChild(SharedPtr<XPathNavigator> newChild);
    virtual ASPOSECPP_SHARED_API void PrependChild(String newChild);
    virtual ASPOSECPP_SHARED_API void PrependChild(SharedPtr<XmlReader> newChild);
    virtual ASPOSECPP_SHARED_API void PrependChild(SharedPtr<XPathNavigator> newChild);
    virtual ASPOSECPP_SHARED_API void InsertBefore(String newSibling);
    virtual ASPOSECPP_SHARED_API void InsertBefore(SharedPtr<XmlReader> newSibling);
    virtual ASPOSECPP_SHARED_API void InsertBefore(SharedPtr<XPathNavigator> newSibling);
    virtual ASPOSECPP_SHARED_API void InsertAfter(String newSibling);
    virtual ASPOSECPP_SHARED_API void InsertAfter(SharedPtr<XmlReader> newSibling);
    virtual ASPOSECPP_SHARED_API void InsertAfter(SharedPtr<XPathNavigator> newSibling);
    virtual ASPOSECPP_SHARED_API void DeleteRange(SharedPtr<XPathNavigator> lastSiblingToDelete);
    virtual ASPOSECPP_SHARED_API void DeleteSelf();
    virtual ASPOSECPP_SHARED_API void PrependChildElement(String prefix, String localName, String namespaceURI, String value);
    virtual ASPOSECPP_SHARED_API void AppendChildElement(String prefix, String localName, String namespaceURI, String value);
    virtual ASPOSECPP_SHARED_API void InsertElementBefore(String prefix, String localName, String namespaceURI, String value);
    virtual ASPOSECPP_SHARED_API void InsertElementAfter(String prefix, String localName, String namespaceURI, String value);
    virtual ASPOSECPP_SHARED_API void CreateAttribute(String prefix, String localName, String namespaceURI, String value);
    ASPOSECPP_SHARED_API String ToString() const override;
 
protected:
 
    static SharedPtr<XPathNavigatorKeyComparer> comparer;
 
    uint32_t get_IndexInParent();
 
    static ArrayPtr<char16_t> NodeTypeLetter;
    static ArrayPtr<char16_t> UniqueIdTbl;
 
    virtual ASPOSECPP_SHARED_API String get_UniqueId();
 
    static const int32_t AllMask;
    static const int32_t NoAttrNmspMask;
    static const int32_t TextMask;
    static ArrayPtr<int32_t> ContentKindMasks;
 
    bool MoveToPrevious(String localName, const String& namespaceURI);
    bool MoveToPrevious(XPathNodeType type);
    bool MoveToNonDescendant();
    static SharedPtr<XmlNamespaceManager> GetNamespaces(const SharedPtr<IXmlNamespaceResolver>& resolver);
    static int32_t GetContentKindMask(XPathNodeType type);
    static int32_t GetKindMask(XPathNodeType type);
    static bool IsText(XPathNodeType type);
    void BuildSubtree(const SharedPtr<XmlReader>& reader, const SharedPtr<XmlWriter>& writer);
 
    virtual ASPOSECPP_SHARED_API ~XPathNavigator();
 
private:
 
    String ToString_NonConst();
    SharedPtr<XmlReader> GetValidatingReader(const SharedPtr<XmlReader>& reader, const SharedPtr<System::Xml::Schema::XmlSchemaSet>& schemas, System::Xml::Schema::ValidationEventHandler validationEvent, const SharedPtr<System::Xml::Schema::XmlSchemaType>& schemaType, const SharedPtr<System::Xml::Schema::XmlSchemaElement>& schemaElement, const SharedPtr<System::Xml::Schema::XmlSchemaAttribute>& schemaAttribute);
    static SharedPtr<XPathExpression> CompileMatchPattern(const String& xpath);
    static int32_t GetDepth(const SharedPtr<XPathNavigator>& nav);
    XmlNodeOrder CompareSiblings(const SharedPtr<XPathNavigator>& n1, const SharedPtr<XPathNavigator>& n2);
    bool IsValidChildType(XPathNodeType type);
    bool IsValidSiblingType(XPathNodeType type);
    SharedPtr<XmlReader> CreateReader();
    SharedPtr<XmlReader> CreateContextReader(const String& xml, bool fromCurrentNode);
 
    static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;
 
};
 
} // namespace XPath
} // namespace Xml
} // namespace System