collection.h

 
#ifndef _aspose_system_collections_object_model_collection_h
#define _aspose_system_collections_object_model_collection_h
 
#include <iterator>
 
#include <system/string.h>
#include <system/collections/list.h>
 
namespace System { namespace Collections { namespace ObjectModel {
 
template<class T>
class ASPOSECPP_SHARED_CLASS Collection : public Generic::IList<T>
{
    SharedPtr<Generic::IList<T>> items;
public:
    Collection() : items(MakeObject<System::Collections::Generic::List<T>>())
    {}
 
    Collection(SharedPtr<Generic::IList<T>> list) : items(list)
    {
        if (list == nullptr)
            throw ArgumentNullException(u"list");
    }
 
 
    SharedPtr<Generic::IList<T>>  get_Items()
    {
        return items;
    }
    const Generic::ListPtr<T>  get_Items() const
    {
        return items;
    }
 
    int get_Count() const override
    {
        return items->get_Count();
    }
    virtual T idx_get(int index) const override
    {
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        return items->idx_get(index);
    }
    virtual void idx_set(int index, T value) override
    {
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
        items->idx_set(index, value);
    }
    T& operator[](int index)
    {
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        return items->idx_get(index);
    }
    const T& operator[](int index) const
    {
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
        return items->idx_get(index);
    }
 
    virtual void Add(const T& item) override
    {
        int index = get_Count();
        InsertItem(index, item);
    }
    void Clear() override
    {
        ClearItems();
    }
    bool Contains(const T& item) const override
    {
        return items->Contains(item);
    }
    SharedPtr<Generic::IEnumerator<T> > GetEnumerator() override
    {
        return items->GetEnumerator();
    }
    int IndexOf(const T& item) const override
    {
        return items->IndexOf(item);
    }
    void Insert(int index, const T& item) override
    {
        if (index < 0 || index > get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        InsertItem(index, item);
    }
    bool Remove(const T& item) override
    {
        int index = items->IndexOf(item);
        if (index < 0)
        {
            return false;
        }
 
        RemoveItem(index);
        return true;
    }
    void RemoveAt(int index) override {
 
        if (index < 0 || index >= get_Count())
        {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        RemoveItem(index);
    }
 
    virtual void CopyTo(ArrayPtr<T> arr, int index) override
    {
        items->CopyTo(arr, index);
    }
    
    void SetTemplateWeakPtr(uint32_t argument) override
    {
        items->SetTemplateWeakPtr(argument);
    }
 
    template <typename U>
    class reverse_iterator_prototype: public Details::BaseIterator<std::bidirectional_iterator_tag, U, std::ptrdiff_t>
    {
        private:
            SharedPtr<Generic::IList<U>> m_list;
            int m_size;
            int m_index;
        public:
            reverse_iterator_prototype()
                : m_size(0)
                , m_index(-1)
            {}
            reverse_iterator_prototype(const SharedPtr<Generic::IList<U>> &list)
                : m_list(list)
                , m_size(list->get_Count())
                , m_index(m_size-1)
            {}
 
            const U operator*() const {
                return m_list->idx_get(m_index);
            }
 
            reverse_iterator_prototype& operator++()
            {
                if (m_index >= 0) {
                    --m_index;
                }
                return *this;
            }
 
            reverse_iterator_prototype& operator--()
            {
                if (m_index < m_size) {
                    ++m_index;
                }
                return *this;
            }
 
            bool operator!=(const reverse_iterator_prototype& it) const {
                return m_index != it.m_index;
            }
 
            bool operator==(const reverse_iterator_prototype& it) const {
                return m_index == it.m_index;
            }
    };
 
    typedef reverse_iterator_prototype<T> reverse_iterator;
    typedef reverse_iterator_prototype<T> const_reverse_iterator;
 
    reverse_iterator rbegin() noexcept { return reverse_iterator(items); }
    reverse_iterator rend() noexcept { return reverse_iterator(); }
 
    const_reverse_iterator rbegin() const noexcept { return reverse_iterator(items); }
    const_reverse_iterator rend() const noexcept { return reverse_iterator(); }
 
    const_reverse_iterator crbegin() const noexcept { return reverse_iterator(items); }
    const_reverse_iterator crend() const noexcept { return reverse_iterator(); }
 
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginIterator() override
    {
        return items->virtualizeBeginIterator();
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndIterator() override
    {
        return items->virtualizeEndIterator();
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginConstIterator() const override
    {
        return items->virtualizeBeginConstIterator();
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndConstIterator() const override
    {
        return items->virtualizeEndConstIterator();
    }
 
protected:
    ~Collection() override {}
 
    virtual void ClearItems()
    {
        items->Clear();
    }
    virtual void InsertItem(int index, const T& item)
    {
        items->Insert(index, item);
    }
    virtual void RemoveItem(int index)
    {
        items->RemoveAt(index);
    }
    virtual void SetItem(int index, const T& item)
    {
        items->idx_set(index, item);
    }
};
 
}}} // namespace System::Collections::ObjectModel
 
#endif // _aspose_system_collections_object_model_collection_h