list.h

 
#pragma once
 
#include <system/details/collections_helper.h>
#include <system/details/comparer_type.h>
#include <system/object.h>
#include <system/collections/ilist.h>
#include <system/array.h>
#include <system/exceptions.h>
#include <system/collections/base_enumerator.h>
#include <system/collections/icomparer.h>
#include <system/collections/algorithms.h>
#include <system/collections/read_only_collection.h>
#include <system/predicate.h>
#include <system/comparison.h>
#include <system/action.h>
#include <system/converter.h>
#include <system/cycles_detection.h>
#include <system/multicast_delegate.h>
 
#include <fwd.h>
 
#include <vector>
#include <algorithm>
#include <utility>
#include <cstddef>
 
namespace System { namespace Collections { namespace Generic {
 
template<typename T> class List;
 
template<typename T>
class ListPtr : public SharedPtr<List<T>>
{
public:
    ListPtr(std::nullptr_t = nullptr) {}
    ListPtr(const SharedPtr<List<T> >& obj) : SharedPtr<List<T>>(obj) { }
 
    typename std::vector<T>::reference operator[](int idx) { return (*this)->operator[](idx); }
    typename std::vector<T>::const_reference operator[](int idx) const  { return (*this)->operator[](idx); }
 
    bool operator == (std::nullptr_t) const
    {
        return SmartPtr<List<T>>::operator == (nullptr);
    }
};
 
template<typename T>
class ASPOSECPP_SHARED_CLASS List
    : virtual public Object
    , public System::Collections::Generic::IList<T>
{
    ASPOSE_COLLECTION_POINTER_MODE_CONTROL(T)
 
public:
    typedef T ValueType;
    typedef IList<T> BaseType;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::List<T>, System::BaseTypesInfo<BaseType>);
 
public:
    typedef std::vector<T, ASPOSE_COLLECTION_ALLOCATOR_TYPE> vector_t;
 
    typedef typename vector_t::iterator iterator;
    typedef typename vector_t::const_iterator const_iterator;
    typedef typename vector_t::reverse_iterator reverse_iterator;
    typedef typename vector_t::const_reverse_iterator const_reverse_iterator;
 
protected:
    typedef SharedPtr<List<T> > ThisPtr;
    vector_t m_data;
 
public:
    typedef SharedPtr<IEnumerable<T> > IEnumerablePtr;
    typedef SharedPtr<IEnumerator<T> > IEnumeratorPtr;
 
    List() : ASPOSE_COLLECTION_INIT_ALLOCATOR() {}
    List(int capacity) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        if (capacity < 0)
        {
            throw ArgumentOutOfRangeException(u"capacity");
        }
        m_data.reserve(capacity);
    }
    List(IEnumerablePtr collection) : ASPOSE_COLLECTION_INIT_ALLOCATOR()
    {
        AddRange(collection);
        TrimExcess();
    }
 
    void AddInitializer(int size, const T inits[])
    {
        for (int i = 0; i < size; ++i)
            m_data.push_back(inits[i]);
    }
 
    iterator begin() noexcept { return m_data.begin(); }
    iterator end() noexcept { return m_data.end(); }
 
    const_iterator begin() const noexcept { return m_data.begin(); }
    const_iterator end() const noexcept { return m_data.end(); }
 
    const_iterator cbegin() const noexcept { return m_data.cbegin(); }
    const_iterator cend() const noexcept { return m_data.cend(); }
 
    reverse_iterator rbegin() noexcept { return m_data.rbegin(); }
    reverse_iterator rend() noexcept { return m_data.rend(); }
 
    const_reverse_iterator rbegin() const noexcept { return m_data.rbegin(); }
    const_reverse_iterator rend() const noexcept { return m_data.rend(); }
 
    const_reverse_iterator crbegin() const noexcept { return m_data.crbegin(); }
    const_reverse_iterator crend() const noexcept { return m_data.crend(); }
 
    // IEnumerable<T> interface
    class Enumerator : public SimpleEnumerator<vector_t>
    {
    public:
        Enumerator(const ThisPtr& data) : SimpleEnumerator<vector_t>(data, data->m_data) { }
        RTTI_INFO_TEMPLATE_CLASS(List<T>::Enumerator, System::BaseTypesInfo<System::Object>);
    };
    IEnumeratorPtr GetEnumerator() override
    {
        return MakeObject<Enumerator>(std::move(MakeSharedPtr(this)));
    }
 
    // end of IEnumerable<T> interface
 
    // ICollection<T> interface
    int get_Count() const override
    {
        return (int)m_data.size();
    }
    void Add(const T& item) override
    {
        m_data.push_back(item);
    }
    void Clear() override
    {
        m_data.clear();
    }
    bool Contains(const T& item) const override
    {
        return FindInData(m_data.begin(), m_data.end(), item) != m_data.end();
    }
    bool Remove(const T& item) override
    {
        iterator it = FindInData(m_data.begin(), m_data.end(), item);
        if (it != m_data.end())
        {
            m_data.erase(it);
            return true;
        }
        return false;
    }
 
    //inherits get_IsReadOnly()
    void CopyTo(System::ArrayPtr<T> array, int arrayIndex) override
    {
        this->CopyTo(0, array, arrayIndex, ASPOSECPP_CHECKED_CAST(int, m_data.size()));
    }
 
    // end of ICollection<T> interface
 
    // IList<T> interface
    int IndexOf(const T& item) const override
    {
        const_iterator it = FindInData(m_data.begin(), m_data.end(), item);
        if (it != m_data.end())
        {
            return ASPOSECPP_CHECKED_CAST(int, it - m_data.begin());
        }
 
        return -1;
    }
    void Insert(int index, const T& item) override
    {
        if (index < 0 || static_cast<size_t>(index) > m_data.size()) {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        m_data.insert(m_data.begin() + index, item);
    }
    void RemoveAt(int index) override
    {
        if (Details::IsOutOfBounds(index, m_data)) {
            throw ArgumentOutOfRangeException(u"index");
        }
        m_data.erase(m_data.begin() + index);
    }
 
    T idx_get(int index) const override
    {
        return operator[](index);
    }
    void idx_set(int index, T value) override
    {
        operator[](index) = value;
    }
 
    // end of IList<T> interface
    int get_Capacity() const
    {
        return (int)m_data.capacity();
    }
    void set_Capacity(int capacity)
    {
        if (capacity < (int)m_data.size()) {
            throw ArgumentOutOfRangeException(u"capacity");
        }
        m_data.reserve(capacity);
    }
 
    void AddRange(IEnumerablePtr collection)
    {
        InsertRange(static_cast<int>(m_data.size()), collection);
    }
 
    SharedPtr<System::Collections::ObjectModel::ReadOnlyCollection<T>> AsReadOnly()
    {
        return MakeObject<System::Collections::ObjectModel::ReadOnlyCollection<T>>(this);
    }
 
    int BinarySearch(const T &item) const
    {
        return _net_binnary_search(m_data, 0, ASPOSECPP_CHECKED_CAST(int, m_data.size()), item);
    }
    int BinarySearch(const T &item, const SharedPtr<System::Collections::Generic::IComparer<T> >& comparer) const
    {
        return _net_binnary_search(m_data, 0, ASPOSECPP_CHECKED_CAST(int, m_data.size()), item, comparer);
    }
    int BinarySearch(int index, int count, const T &item, const SharedPtr<System::Collections::Generic::IComparer<T> >& comparer) const
    {
        if (index < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)) {
            throw ArgumentException(u"index or count");
        }
 
        return _net_binnary_search(m_data, index, count, item, comparer);
    }
 
    template <typename OutputType>
    SharedPtr<List<OutputType>> ConvertAll(Converter<T, OutputType> converter)
    {
        if (converter.IsNull()) {
            throw System::ArgumentNullException(u"converter");
        }
        SharedPtr<List<OutputType>> res = System::MakeObject<List<OutputType>>((int)m_data.size());
        for (size_t i = 0; i < m_data.size(); i++) {
            res->Add(converter(m_data[i]));
        }
        return res;
    }
 
    void CopyTo(const System::ArrayPtr<T>& array)
    {
        this->CopyTo(0, array, 0, ASPOSECPP_CHECKED_CAST(int, m_data.size()));
    }
    void CopyTo(int index, const System::ArrayPtr<T>& array, int arrayIndex, int count)
    {
        if (!array) {
            throw ArgumentNullException(u"array");
        }
 
        if (index < 0 || arrayIndex < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index, arrayIndex or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)
            || Details::IsOutOfSize(arrayIndex + count, array->data()) ) {
            throw ArgumentException(u"index, arrayIndex or count");
        }
 
        std::copy(m_data.begin() + index, m_data.begin() + index + count, array->data().begin() + arrayIndex);
    }
 
    bool Exists(System::Predicate<T> match)
    {
        if (match.IsNull()) {
            throw ArgumentNullException(u"match");
        }
        return FindIndex(match) != -1;
    }
    T Find(System::Predicate<T> predicate)
    {
        if (predicate.IsNull()) {
            throw ArgumentNullException(u"predicate");
        }
        for (iterator it = m_data.begin(); it != m_data.end(); ++it)
        {
            if (predicate(*it))
                return (*it);
        }
        return  System::Default<T>();
    }
    ListPtr<T> FindAll(System::Predicate<T> match)
    {
        if (match.IsNull()) {
            throw ArgumentNullException(u"match");
        }
        ListPtr<T> list = MakeObject<List<T>>();
        for (iterator it = m_data.begin(); it != m_data.end(); ++it)
        {
            if (match(*it))
                list->Add(*it);
        }
        return list;
    }
    int FindIndex(System::Predicate<T> match)
    {
        return FindIndex(0, ASPOSECPP_CHECKED_CAST(int, m_data.size()), match);
    }
    int FindIndex(int startIndex, System::Predicate<T> match)
    {
        return FindIndex(startIndex, ASPOSECPP_CHECKED_CAST(int, m_data.size()) - startIndex, match);
    }
    int FindIndex(int startIndex, int count, System::Predicate<T> match)
    {
        if (match.IsNull()) {
            throw ArgumentNullException(u"match");
        }
 
        if (count < 0 || startIndex < 0
            || Details::IsOutOfSize(startIndex + count, m_data))
        {
            throw ArgumentOutOfRangeException(u"startIndex or count");
        }
 
        if (m_data.empty()) {
            return -1;
        }
 
        int const num = startIndex + count;
        for (int index = startIndex; index < num; ++index)
        {
            auto& item = m_data[index];
            if (match(item)) {
                return index;
            }
        }
        return -1;
    }
    T FindLast(System::Predicate<T> match)
    {
        if (match.IsNull()) {
            throw ArgumentNullException(u"match");
        }
        T res = System::Default<T>();
        for (iterator it = m_data.begin(); it != m_data.end(); ++it)
        {
            if (match(*it))
                res = (*it);
        }
        return res;
    }
 
    void ForEach(System::Action<T> action)
    {
        if (action.IsNull()) {
            throw ArgumentNullException(u"action");
        }
        auto data_size = m_data.size();
        for (iterator it = m_data.begin(); it != m_data.end(); ++it)
        {
            action(*it);
            if (m_data.size() != data_size)
            {
                throw InvalidOperationException();
            }
        }
    }
 
    ThisPtr GetRange(int index, int count)
    {
        if (index < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)) {
            throw ArgumentException(u"index or count");
        }
 
        ThisPtr rv = MakeObject<List<T> >(count);
        for (auto i = index; i < (index + count); ++i)
        {
            rv->m_data.push_back(m_data[i]);
        }
 
        return rv;
    }
 
    int IndexOf(const T& item, int index) const
    {
        if (Details::IsOutOfBounds(index, m_data)) {
            throw ArgumentOutOfRangeException(u"index");
        }
        auto it = FindInData(m_data.begin() + index, m_data.end(), item);
        if (it != m_data.end())
        {
            return ASPOSECPP_CHECKED_CAST(int, it - m_data.begin());
        }
 
        return -1;
    }
 
    void InsertRange(int index, IEnumerablePtr collection)
    {
        if (!collection) {
            throw ArgumentNullException(u"collection");
        }
 
        if (index < 0 || static_cast<size_t>(index) > m_data.size()) {
            throw ArgumentOutOfRangeException(u"index");
        }
 
        if (collection.GetObjectOrNull() == this) {
            m_data.reserve(m_data.size() * 2);
            m_data.insert(m_data.begin() + index, m_data.begin(), m_data.end());
        }
        else
        {
            IEnumeratorPtr it = collection->GetEnumerator();
            while (it->MoveNext())
            {
                m_data.insert(m_data.begin() + index++, it->Current());
            }
        }
    }
 
    int32_t LastIndexOf(const T& item) const
    {
        auto rit = FindInData(m_data.rbegin(), m_data.rend(), item);
        if (rit != m_data.rend())
        {
            return ASPOSECPP_CHECKED_CAST(int, rit.base() - m_data.begin() - 1);
        }
 
        return -1;
    }
    
    int32_t LastIndexOf(const T& item, int32_t index) const
    {
        using namespace Collections::Generic::Details;
        if (index < 0 || IsOutOfBounds(index, m_data))
        {
            throw ArgumentOutOfRangeException(u"startIndex or count");
        }
 
        auto rbegin = m_data.rbegin() + m_data.size() - index - 1;
        auto rend = m_data.rend();
        auto rit = FindInData(rbegin, rend, item);
        if (rit != rend)
        {
            return ASPOSECPP_CHECKED_CAST(int, rit.base() - m_data.begin()) - 1;
        }
        return -1;
    }
 
    int32_t LastIndexOf(const T& item, int32_t index, int32_t count) const
    {
        using namespace Collections::Generic::Details;
        if (index < 0 || count < 0
                || IsOutOfBounds(index, m_data) || IsOutOfSize(count, m_data)
                || (index - count + 1) < 0)
        {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        auto rbegin = m_data.rbegin() + m_data.size() - index - 1;
        auto rend = rbegin + count;
        auto rit = FindInData(rbegin, rend, item);
 
        if (rit != rend)
        {
            return ASPOSECPP_CHECKED_CAST(int, rit.base() - m_data.begin()) - 1;
        }
        return -1;
    }
 
    int RemoveAll(Predicate<T> match)
    {
        if (match.IsNull()) {
            throw ArgumentNullException(u"match");
        }
 
        typename vector_t::size_type removed = 0;
 
        for (typename vector_t::size_type index = 0; index < m_data.size(); )
        {
            if (match(m_data[index]))
            {
                m_data.erase(m_data.begin() + index);
                ++removed;
            }
            else
            {
                ++index;
            }
        }
 
        return ASPOSECPP_CHECKED_CAST(int, removed);
    }
    void RemoveRange(int index, int count)
    {
        if (index < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)) {
            throw ArgumentException(u"index or count");
        }
 
        m_data.erase(m_data.begin() + index, m_data.begin() + index + count);
    }
    void Reverse()
    {
        std::reverse(m_data.begin(), m_data.end());
    }
    void Reverse(int index, int count)
    {
        if (index < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)) {
            throw ArgumentException(u"index or count");
        }
 
        std::reverse(m_data.begin() + index, m_data.begin() + index + count);
    }
    void Sort(const SharedPtr<System::Collections::Generic::IComparer<T> >& comparator)
    {
        ComparerAdapter<T> adapter(comparator);
        std::sort(m_data.begin(), m_data.end(), adapter);
    }
    void Sort()
    {
        std::sort(m_data.begin(), m_data.end(), Details::ComparerType<ValueType>());
    }
    void Sort(int index, int count, SharedPtr<System::Collections::Generic::IComparer<T> > comparator)
    {
        if (index < 0 || count < 0) {
            throw ArgumentOutOfRangeException(u"index or count");
        }
 
        if (Details::IsOutOfSize(index + count, m_data)) {
            throw ArgumentException(u"index or count");
        }
 
        ComparerAdapter<T> adapter(comparator);
        std::sort(m_data.begin() + index, m_data.begin() + index + count, adapter);
    }
    void Sort(Comparison<T> comparison, bool) //second (bool) param to solve ambiguous call issue
    {
        if (comparison.IsNull()) {
            throw ArgumentNullException(u"comparison");
        }
        std::sort(m_data.begin(), m_data.end(), comparison);
    }
 
    ArrayPtr<T> ToArray() const
    {
        typename vector_t::size_type size = m_data.size();
        auto result = MakeObject<Array<T> >(ASPOSECPP_CHECKED_CAST(int, size));
        std::copy(m_data.begin(), m_data.end(), result->data().begin());
 
        return result;
    }
    void TrimExcess()
    {
        m_data.shrink_to_fit();
    }
 
    bool TrueForAll(System::Predicate<T> match)
    {
        if (match.IsNull())
        {
            throw ArgumentNullException(u"match");
        }
        for (iterator it = m_data.begin(); it != m_data.end(); ++it)
        {
            if (!match(*it))
                return false;
        }
        return true;
    }
 
    typename vector_t::reference operator[](int index)
    {
        if (Details::IsOutOfBounds(index, m_data)) {
            throw ArgumentOutOfRangeException(u"index");
        }
        return m_data[static_cast<typename vector_t::size_type>(index)];
    }
    typename vector_t::const_reference operator[](int index) const
    {
        if (Details::IsOutOfBounds(index, m_data)) {
            throw ArgumentOutOfRangeException(u"index");
        }
        return m_data[static_cast<typename vector_t::size_type>(index)];
    }
 
    vector_t& data() { return m_data; }
    const vector_t& data() const { return m_data; }
    void _add_range(std::initializer_list<T> list)
    {
        std::for_each(list.begin(), list.end(), [this](const T &v) { m_data.push_back(v); });
    }
 
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, iterator>(begin(), end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndIterator() override
    {
        return new System::Details::NativeIteratorWrapper<T, iterator>(end(), end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeBeginConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, const_iterator>(begin(), end());
    }
    System::Details::VirtualizedIteratorBase<T>* virtualizeEndConstIterator() const override
    {
        return new System::Details::NativeConstIteratorWrapper<T, const_iterator>(end(), end());
    }
 
private:
    template <typename Q, typename I>
    typename std::enable_if<Details::IsEqualExist<Q>::value, I>::type FindInData(I begin, I end, const Q &item) const
    {
        return std::find(begin, end, item);
    }
    template <typename Q, typename I>
    typename std::enable_if<!Details::IsEqualExist<Q>::value, I>::type FindInData(I begin, I end, const Q &item) const
    {
        throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION);
    }
    template <typename Q, typename I>
    I FindInData(I begin, I end, const System::SharedPtr<Q> &item) const
    {
        return std::find_if(begin, end, [&item](const System::SharedPtr<Q> &element)
        {
            return element == nullptr ? item == nullptr : element.ToObjectPtr()->Equals(item.ToObjectPtr());
        });
    }
 
protected:
    ~List() override {}
 
#ifdef __DBG_FOR_EACH_MEMBER
    public:
        void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
        {
            visitor.add_self(this);
            DBG::for_each_of_Object(this, m_data, visitor);
        }
 
        const char* DBG_class_name() const override { return "List<T>"; }
#endif
 
#ifdef ASPOSE_GET_SHARED_MEMBERS
    DEFINE_GET_SHARED_MEMBERS(m_data)
#endif
};
 
}}} // namespace System::Collections::Generic