xml_named_node_map.h

 
 
#pragma once
 
#include <system/object.h>
#include <system/collections/ienumerator.h>
#include <system/collections/ienumerable.h>
#include <cstdint>
 
 
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename> class List;
} // namespace Generic
} // namespace Collections
class String;
namespace Xml
{
class DocumentXmlWriter;
class DocumentXPathNavigator;
class XmlAttributeCollection;
class XmlDocument;
class XmlDocumentType;
class XmlNode;
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
class ASPOSECPP_SHARED_CLASS XmlNamedNodeMap : public Collections::Generic::IEnumerable<SharedPtr<System::Xml::XmlNode>>
{
    typedef XmlNamedNodeMap ThisType;
    typedef Collections::Generic::IEnumerable<SharedPtr<System::Xml::XmlNode>> BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlNamedNodeMap>;
 
private:
    friend class DocumentXmlWriter;
    friend class DocumentXPathNavigator;
    friend class XmlAttributeCollection;
    friend class XmlDocument;
    friend class XmlDocumentType;
 
protected:
 
    class SmallXmlNodeList : public System::Object
    {
        typedef SmallXmlNodeList ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_DECL();
 
    private:
 
        class SingleObjectEnumerator : public Collections::Generic::IEnumerator<SharedPtr<System::Xml::XmlNode>>
        {
            typedef SingleObjectEnumerator ThisType;
            typedef Collections::Generic::IEnumerator<SharedPtr<System::Xml::XmlNode>> BaseType;
 
            typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
            RTTI_INFO_DECL();
 
        public:
 
            const SharedPtr<XmlNode>& get_Current() const override;
 
            SingleObjectEnumerator(const SharedPtr<XmlNode>& value);
 
            bool MoveNext() override;
            void Reset() override;
            void Dispose() override;
 
            ASPOSECPP_SHARED_API System::Details::VirtualizedIteratorBase<SharedPtr<System::Xml::XmlNode>>* CloneIterator() const override;
 
        protected:
 
            #ifdef ASPOSE_GET_SHARED_MEMBERS
            void GetSharedMembers(System::Object::shared_members_type& result) const override;
            #endif
 
 
        private:
 
            SharedPtr<XmlNode> _loneValue;
            int32_t _position;
            mutable SharedPtr<XmlNode> m_CurrentHolder;
 
        };
 
 
    public:
 
        int32_t get_Count();
 
        SharedPtr<XmlNode> idx_get(int32_t index);
 
        void Add(const SharedPtr<XmlNode>& value);
        void RemoveAt(int32_t index);
        void Insert(int32_t index, const SharedPtr<XmlNode>& value);
        SharedPtr<Collections::Generic::IEnumerator<SharedPtr<XmlNode>>> GetEnumerator();
 
    protected:
 
        #ifdef ASPOSE_GET_SHARED_MEMBERS
        void GetSharedMembers(System::Object::shared_members_type& result) const override;
        #endif
 
 
    private:
 
        SharedPtr<XmlNode> _field;
        SharedPtr<Collections::Generic::List<SharedPtr<XmlNode>>> _list;
 
    public:
 
        class ASPOSECPP_SHARED_CLASS Iterator : public Details::BaseIterator<std::forward_iterator_tag, const decltype(_field)>
        {
        public:
            ASPOSECPP_SHARED_API Iterator(pointer ptr);
 
            ASPOSECPP_SHARED_API Iterator& operator++();
            ASPOSECPP_SHARED_API Iterator operator++(int);
 
            ASPOSECPP_SHARED_API bool operator==(const Iterator& other) const;
            ASPOSECPP_SHARED_API bool operator!=(const Iterator& other) const;
 
            ASPOSECPP_SHARED_API reference operator*() const;
 
        private:
            pointer m_ptr;
        };
 
        Iterator begin() const noexcept;
        Iterator end() const noexcept;
 
        Iterator cbegin() const noexcept;
        Iterator cend() const noexcept;
    };
 
public:
 
    virtual ASPOSECPP_SHARED_API int32_t get_Count();
 
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> GetNamedItem(String name);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> SetNamedItem(SharedPtr<XmlNode> node);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> RemoveNamedItem(String name);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> Item(int32_t index);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> GetNamedItem(String localName, String namespaceURI);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> RemoveNamedItem(String localName, String namespaceURI);
    ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IEnumerator<SharedPtr<XmlNode>>> GetEnumerator() override;
 
protected:
 
    WeakPtr<XmlNode> parent;
    SharedPtr<XmlNamedNodeMap::SmallXmlNodeList> nodes;
 
    XmlNamedNodeMap(const SharedPtr<XmlNode>& parent);
    MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(XmlNamedNodeMap, CODEPORTING_ARGS(SharedPtr<XmlNode> parent));
 
    int32_t FindNodeOffset(const String& name);
    int32_t FindNodeOffset(const String& localName, const String& namespaceURI);
    virtual ASPOSECPP_SHARED_API const SharedPtr<XmlNode>& AddNode(const SharedPtr<XmlNode>& node);
    virtual ASPOSECPP_SHARED_API const SharedPtr<XmlNode>& AddNodeForLoad(const SharedPtr<XmlNode>& node, const SharedPtr<XmlDocument>& doc);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> RemoveNodeAt(int32_t i);
    SharedPtr<XmlNode> ReplaceNodeAt(int32_t i, const SharedPtr<XmlNode>& node);
    virtual ASPOSECPP_SHARED_API SharedPtr<XmlNode> InsertNodeAt(int32_t i, SharedPtr<XmlNode> node);
 
    virtual ASPOSECPP_SHARED_API ~XmlNamedNodeMap();
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
public:
    using iterator = SmallXmlNodeList::Iterator;
 
    ASPOSECPP_SHARED_API iterator begin() const noexcept;
    ASPOSECPP_SHARED_API iterator end() const noexcept;
 
    ASPOSECPP_SHARED_API iterator cbegin() const noexcept;
    ASPOSECPP_SHARED_API iterator cend() const noexcept;
 
};
 
} // namespace Xml
} // namespace System