ienumerable.h

 
#pragma once
 
#include <iterator>
#include <memory>
 
#include <system/collections/ienumerator.h>
#include <system/collections/virtualized_iterator.h>
#include <system/func.h>
#include <system/linq/igrouping.h>
 
namespace System { namespace Linq {
template <typename T> class IOrderedEnumerable;
}}
 
namespace System { namespace Collections { namespace Generic {
 
template<typename T> class ASPOSECPP_SHARED_CLASS List;
template<typename T> class EnumerableExt;
 
template<typename T>
class ASPOSECPP_SHARED_CLASS IEnumerable: virtual public Object
{
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::IEnumerable<T>, System::BaseTypesInfo<System::Object>);
 
public:
    typedef IEnumerator<T> IEnumeratorType;
 
    using ValueType = T;
 
    // There no need to define an empty virtual dtor, virtual dtor for inheritance already defined in the Object class
    virtual SharedPtr<IEnumerator<T> > GetEnumerator() = 0;
 
    // Implementation of some of LINQ extension methods as usual class methods
    // header <system/linq/enumerable.h> should be included in order to use
 
    T LINQ_Aggregate(const Func<T, T, T>& func);
 
    T LINQ_ElementAt(int index);
 
    T LINQ_ElementAtOrDefault(int index);
 
    T LINQ_First();
 
    T LINQ_First(const Func<T, bool>& predicate);
 
    T LINQ_FirstOrDefault();
 
    T LINQ_FirstOrDefault(std::function<bool(T)> predicate);
 
    T LINQ_Last();
 
    T LINQ_LastOrDefault();
 
    SharedPtr<List<T>> LINQ_ToList();
 
    int LINQ_Count();
 
    int LINQ_Count(const Func<T, bool>& predicate);
 
    System::ArrayPtr<T> LINQ_ToArray();
 
    bool LINQ_All(std::function<bool(T)> predicate);
 
    bool LINQ_Any();
 
    bool LINQ_Any(std::function<bool(T)> predicate);
 
    SharedPtr<IEnumerable<T>> LINQ_Where(std::function<bool(T)> predicate);
 
    bool LINQ_Contains(T value);
 
    template <typename ResultType>
    SharedPtr<IEnumerable<ResultType>> LINQ_Cast();
 
    template <typename Key>
    SharedPtr<Linq::IOrderedEnumerable<T>> LINQ_OrderBy(const Func<T, Key>& keySelector);
 
    template <typename Key>
    SharedPtr<Linq::IOrderedEnumerable<T>> LINQ_OrderByDescending(const Func<T, Key>& keySelector);
 
    template <typename ResultType>
    SharedPtr<IEnumerable<ResultType>> LINQ_OfType();
 
    template <typename ResultType>
    SharedPtr<IEnumerable<ResultType>> LINQ_Select(const Func<T, ResultType>& selector);
 
    template <typename ResultType>
    SharedPtr<IEnumerable<ResultType>> LINQ_Select(const Func<T, int32_t, ResultType>& selector);
 
    SharedPtr<IEnumerable<T>> LINQ_Concat(SharedPtr<IEnumerable<T>> sequence);
 
    SharedPtr<IEnumerable<T>> LINQ_Reverse();
 
    template <typename Key>
    System::SharedPtr<IEnumerable<System::SharedPtr<System::Linq::IGrouping<Key, T>>>>
        LINQ_GroupBy(System::Func<T, Key> keyPredicate);
 
    template <typename Key, typename Element>
    System::SharedPtr<IEnumerable<System::SharedPtr<System::Linq::IGrouping<Key, Element>>>>
        LINQ_GroupBy(System::Func<T, Key> keyPredicate, System::Func<T, Element> elementSelector);
 
    template <typename ResultType>
    SharedPtr<IEnumerable<ResultType>> LINQ_SelectMany(const Func<T, SharedPtr<IEnumerable<ResultType>>>& selector);
 
    SharedPtr<IEnumerable<T>> LINQ_Skip(int32_t count);
 
    SharedPtr<IEnumerable<T>> LINQ_Take(int32_t count);
 
    template <typename ResultType>
    ResultType LINQ_Min(const Func<T, ResultType>& selector);
 
    template <typename ResultType>
    ResultType LINQ_Max(const Func<T, ResultType>& selector);
    
            
    T LINQ_Average();
 
    template <typename ResultType>
    ResultType LINQ_Average(const Func<T, ResultType>& selector);
 
    using iterator = System::Details::VirtualizedIterator<T>;
    using const_iterator = System::Details::VirtualizedConstIterator<T>;
 
    iterator begin()
    {
        return iterator(virtualizeBeginIterator());
    }
    iterator end()
    {
        return iterator(virtualizeEndIterator());
    }
 
    const_iterator begin() const
    {
        return const_iterator(virtualizeBeginConstIterator());
    }
    const_iterator end() const
    {
        return const_iterator(virtualizeEndConstIterator());
    }
 
    const_iterator cbegin() const
    {
        return const_iterator(virtualizeBeginConstIterator());
    }
    const_iterator cend() const
    {
        return const_iterator(virtualizeEndConstIterator());
    }
 
    using virtualized_iterator = System::Details::VirtualizedIteratorBase<T>;
    using virtualized_iterator_element = T;
 
    virtual virtualized_iterator* virtualizeBeginIterator()
    {
        return GetEnumeratorAsVirtualizedIterator();
    }
    virtual virtualized_iterator* virtualizeEndIterator()
    {
        return new System::Details::EnumeratorBasedEndIterator<T>();
    }
    virtual virtualized_iterator* virtualizeBeginConstIterator() const
    {
        return GetEnumeratorAsVirtualizedIterator();
    }
    virtual virtualized_iterator* virtualizeEndConstIterator() const
    {
        return new System::Details::EnumeratorBasedEndIterator<T>();
    }
 
protected:
    ~IEnumerable() override {}
 
    virtualized_iterator* GetEnumeratorAsVirtualizedIterator()
    {
        IEnumerator<T> *iterator;
        {
            auto enumerator = GetEnumerator();
            if (enumerator->SharedCount() != 1)
            {
                enumerator->InitializeIterator();
                return new EnumeratorWrapperIterator<T>(enumerator);
            }
            iterator = enumerator->AsVirtualizedIterator();
        }
        iterator->MarkOwnedByVirtualizedIterator();
        return iterator;
    }
    virtualized_iterator* GetEnumeratorAsVirtualizedIterator() const
    {
        return const_cast<IEnumerable<T>*>(this)->GetEnumeratorAsVirtualizedIterator();
    }
};
 
}}} // namespace System::Collections::Generic