array.h

 
#ifndef _aspose_system_array_h_
#define _aspose_system_array_h_
 
#include <system/details/collections_helper.h>
#include <system/details/comparer_type.h>
#include <system/details/equality_helper.h>
#include <system/details/array_view.h>
#include <system/details/stack_array.h>
#include <system/object.h>
#include <system/collections/icomparer.h>
#include <system/collections/ienumerable.h>
#include <system/collections/ilist.h>
#include <system/exceptions.h>
#include <system/collections/algorithms.h>
#include <system/converter.h>
#include <system/predicate.h>
#include <system/action.h>
#include <system/select_type.h>
#include <system/cycles_detection.h>
#include <system/comparison.h>
#include <system/collections/read_only_collection.h>
 
#include <fwd.h>
 
#include <map>
#include <vector>
#include <functional>
#include <initializer_list>
#include <utility>
#include <limits>
#include <type_traits>
#include <algorithm>
 
#undef min
#undef max
 
namespace System { namespace Collections { namespace ObjectModel {
template<typename> class ReadOnlyCollection;
}}}
 
namespace System
{
    namespace Details {
        template <typename X, typename IdxType>
        inline typename Array<X>::UnderlyingType& GetByIndex(const SmartPtr<Array<X>> *ptr, IdxType idx)
        {
            return (**ptr).operator[](static_cast<int>(idx));
        }
 
        template <typename Integral, bool = std::numeric_limits<Integral>::is_signed>
        struct NegativeValueChecker
        {
            static void Check(const Integral &value)
            {
                if (value < 0)
                    throw System::OverflowException(u"Negative array size");
            }
        };
        template <typename Integral>
        struct NegativeValueChecker<Integral, false>
        {
            static void Check(const Integral&) {}
        };
 
        template <typename Integral, bool = (sizeof(Integral) > sizeof(int)) || (!std::numeric_limits<Integral>::is_signed && (sizeof(Integral) == sizeof(int)))>
        struct IntPositiveOverflowChecker
        {
            static void Check(const Integral& value)
            {
                if (value >= static_cast<Integral>((std::numeric_limits<int>::max)()))
                    throw System::OverflowException(u"Array size too big for signed integer");
            }
        };
        template <typename Integral>
        struct IntPositiveOverflowChecker<Integral, false>
        {
            static void Check(const Integral &value) { ASPOSE_UNUSED(value); }
        };
 
        template <typename Integral>
        int FixArraySize(const Integral &value)
        {
            NegativeValueChecker<Integral>::Check(value);
            IntPositiveOverflowChecker<Integral>::Check(value);
            return static_cast<int>(value);
        }
    }
 
    class ASPOSECPP_SHARED_CLASS ArrayBase : virtual public Object
    {
        typedef ArrayBase ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
    public:
        virtual int32_t get_Length() const = 0;
 
        virtual void* raw_data_ptr() = 0;
    };
 
    typedef System::ArrayPtr<uint8_t> ByteArrayPtr;
 
    template<typename T>
    ArrayPtr<T> MakeArray(std::initializer_list<T> init)
    {
        System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry;
        System::Details::MakeObjectLeakageDetector::SetSignature<Array<T>>(init);
 
        Detail::OwnNextObject ownershipSentry;
 
        Array<T> *const arr = new Array<T>(init);
 
        ownershipSentry.CreatedSuccessfully(arr);
        signature_sentry.CreatedSuccessfully(arr);
 
        return ArrayPtr<T>(arr);
    }
 
    template <class T, class... Args> ArrayPtr<T> MakeArray(Args&&... args)
    {
        System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry;
        System::Details::MakeObjectLeakageDetector::SetSignature<Array<T>>(std::forward<Args>(args)...);
 
        Detail::OwnNextObject ownershipSentry;
 
        Array<T>* const arr = new Array<T>(std::forward<Args>(args)...);
 
        ownershipSentry.CreatedSuccessfully(arr);
        signature_sentry.CreatedSuccessfully(arr);
 
        return ArrayPtr<T>(arr);
    }
 
    template <class T, class Integral, class... Args>
    typename std::enable_if<std::is_integral<Integral>::value, ArrayPtr<T>>::type MakeArray(Integral size, Args&&... args)
    {
        System::Details::MakeObjectLeakageDetector::SignatureBacktraceSentry signature_sentry;
        System::Details::MakeObjectLeakageDetector::SetSignature<Array<T>>(Details::FixArraySize(size), std::forward<Args>(args)...);
 
        Detail::OwnNextObject ownershipSentry;
 
        Array<T>* const arr = new Array<T>(Details::FixArraySize(size), std::forward<Args>(args)...);
 
        ownershipSentry.CreatedSuccessfully(arr);
        signature_sentry.CreatedSuccessfully(arr);
 
        return ArrayPtr<T>(arr);
    }
 
    template<typename T>
    class ASPOSECPP_SHARED_CLASS Array
        : public ArrayBase
        , public System::Collections::Generic::IList<T>
    {
        typedef Array<T> ThisType;
        typedef System::ArrayBase BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
    public:
        using ValueType = T;
        using UnderlyingType = typename System::Details::SelectType<T>::type;
 
    protected:
        typedef System::Details::CollectionHelpers::ContainerPointerMode<UnderlyingType> pointer_mode_t;
        typedef std::vector<UnderlyingType, typename pointer_mode_t::allocator_type> vector_t;
        pointer_mode_t m_pointer_mode;
        vector_t m_data;
#ifdef ASPOSE_GET_SHARED_MEMBERS
        DEFINE_GET_SHARED_MEMBERS(m_data)
#endif
    public:
        typedef SharedPtr<Collections::Generic::IEnumerable<T>> EnumerablePtr;
        typedef SharedPtr<Collections::Generic::IEnumerator<T>> EnumeratorPtr;
 
        class Enumerator : virtual public Object, public Collections::Generic::IEnumerator<T>
        {
            RTTI_INFO_TEMPLATE_CLASS(Array<T>::Enumerator, System::BaseTypesInfo<System::Object>);
 
        private:
            SharedPtr<Array<T>> m_array;
            int64_t m_idx;
 
        public:
            Enumerator(const SharedPtr<Array<T>>& arr) : m_array(arr), m_idx(-1) { }
            
            virtual ~Enumerator() {}
 
            virtual MakeConstRef_t<T> get_Current() const override
            {
                return (m_idx < 0 || m_idx >= (int64_t)m_array->m_data.size())
                    ? System::Default<T>()
                    : m_array->m_data[(size_t)m_idx];
            }
 
            virtual bool MoveNext() override
            {
                if (m_idx < (int64_t)m_array->m_data.size())
                    m_idx++;
 
                return m_idx < (int64_t)m_array->m_data.size();
            }
 
            virtual void Reset() override
            {
                m_idx = -1;
            }
 
#ifdef __DBG_FOR_EACH_MEMBER
        public:
            void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
            {
                visitor.add_self(this);
                visitor.add_member(this, m_array.get_shared(), "m_array");
            }
 
            const char* DBG_class_name() const override { return "Array<T>::Enumerator"; }
#endif
 
        protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
            virtual void GetSharedMembers(System::Object::shared_members_type& result) const override
            {
                Object::GetSharedMembers(result);
                result.Add("System::Array<T>::Enumerator::m_array", m_array);
            }
#endif
        };
 
        Array() : m_data(m_pointer_mode.GetAllocator()) {}
 
        Array(int count, const T& init = T()) : m_data(count, static_cast<UnderlyingType>(init), m_pointer_mode.GetAllocator()) { }
 
        template <typename ValueType>
        Array(typename std::enable_if<std::is_arithmetic<T>::value && std::is_arithmetic<ValueType>::value && std::is_convertible<ValueType, T>::value, int>::type count, ValueType init)
            : Array(count, ASPOSECPP_CHECKED_CAST(T, init)) {}
 
        Array(int count, const T inits[]) : m_data(count, static_cast<UnderlyingType>(T()), m_pointer_mode.GetAllocator())
        {
            for (int i = 0; i < count; ++i)
                m_data[i] = inits[i];
        }
 
        Array(vector_t&& value) : m_data(std::move(value), m_pointer_mode.GetAllocator()) {}
        
        Array(const vector_t &assgn) : m_data(assgn, m_pointer_mode.GetAllocator()) {}
 
        template <typename Q, typename = typename std::enable_if<std::is_same<Q, T>::value && !std::is_same<std::vector<Q>, vector_t>::value, std::vector<Q>>::type>
        Array(const std::vector<Q> &value) 
            : m_data(value.begin(), value.end(), m_pointer_mode.GetAllocator()) 
        {}
 
        template <typename Q, typename = typename std::enable_if<std::is_same<Q, T>::value && !std::is_same<std::vector<Q>, vector_t>::value, std::vector<Q>>::type>
        Array(std::vector<Q> &&value) 
            : m_data(m_pointer_mode.GetAllocator()) 
        {
            m_data.swap(value);
        }
 
        Array(std::initializer_list<UnderlyingType> init) : m_data(init, m_pointer_mode.GetAllocator()) {}
 
        template <std::size_t InitArraySize>
        Array(const std::array<UnderlyingType, InitArraySize> &init) : 
            Array(init, static_cast<std::make_index_sequence<InitArraySize>*>(nullptr))
        {}
 
        Array(std::initializer_list<bool> init, int = 0) : m_data(m_pointer_mode.GetAllocator())
        {
            for (auto it = init.begin(); it != init.end(); ++it)
                m_data.push_back(UnderlyingType(*it));
        }
 
        // IEnumerable<T> interface
 
        virtual EnumeratorPtr GetEnumerator() override
        {
            return MakeObject<Enumerator>(std::move(MakeSharedPtr(this)));
        }
 
        // end of IEnumerable<T> interface
 
        // ICollection<T> interface
        // Note: members which add, insert, or remove elements throw NotSupportedException.
 
        virtual int get_Count() const override
        {
            return get_Length();
        }
 
        virtual void Add(const T&) override
        {
            throw NotSupportedException(u"Array as ICollection<T>::Add");
        }
 
        virtual void Clear() override
        {
            throw NotSupportedException(u"Array as ICollection<T>::Clear");
        }
 
        void SetTemplateWeakPtr(uint32_t argument) override
        {
            m_pointer_mode.SetWeak(argument, m_data);
        }
 
private:
        template <typename Q = T>
        auto ContainsImpl(const Q* item) const -> decltype(std::declval<UnderlyingType>() == *item, void(0), bool())
        {
            return std::find_if(m_data.begin(), m_data.end(),
                                [&item](const T& value) { return Details::AreEqual(value, *item); }) != m_data.end();
        }
        
        bool ContainsImpl(...) const
        {
            throw NotImplementedException(ASPOSE_CURRENT_FUNCTION);
        }
public:
        virtual bool Contains(const T& item) const override
        {
            return ContainsImpl(&item);
        }
 
        virtual bool Remove(const T&) override
        {
            throw NotSupportedException(u"Array as ICollection<T>::Remove");
        }
 
        // Returns True when you cast or converted to an ICollection<T> object,
        // even though individual array elements can be modified.
 
        virtual bool get_IsReadOnly() const override
        {
            return true;
        }
 
        virtual void CopyTo(ArrayPtr<T> arr, int arrayIndex) override
        {
            this->CopyTo<T>(arr, static_cast<int64_t>(arrayIndex));
        }
 
        // end of ICollection<T> interface
 
        // IList<T> interface
private:
        template <std::size_t ...InitArrayIndexes>
        Array(const std::array<UnderlyingType, sizeof...(InitArrayIndexes)> &init, std::index_sequence<InitArrayIndexes...>*) : 
            m_data({ init[InitArrayIndexes]... }, m_pointer_mode.GetAllocator()) {}
 
 
        template <typename Q = T>
        auto IndexOfImpl(const Q* item) const -> decltype(std::declval<UnderlyingType>() == *item, void(0), int())
        {
            auto it = std::find_if(m_data.begin(), m_data.end(), [&item](const T& value) { return Details::AreEqual(value, *item); });
 
            return (it != m_data.end()) ? static_cast<int>(it - m_data.begin()) : -1;
        }
        
        int IndexOfImpl(...) const
        {
            throw NotImplementedException(ASPOSE_CURRENT_FUNCTION);
        }
 
public:
        virtual int IndexOf(const T& item) const override
        {
            return IndexOfImpl(&item);
        }
 
        virtual void Insert(int, const T&) override
        {
            throw NotSupportedException(u"Array as IList<T>::Insert");
        }
 
        virtual void RemoveAt(int) override
        {
            throw NotSupportedException(u"Array as IList<T>::RemoveAt");
        }
 
        virtual T idx_get(int index) const override
        {
            return operator[](index);
        }
 
        virtual void idx_set(int index, T value) override
        {
            operator[](index) = value;
        }
 
        // end of IList<T> interface
 
        ArrayPtr<T> Init(const T inits[])
        {
            for (size_t i = 0; i < m_data.size(); ++i)
                m_data[i] = inits[i];
 
            return MakeSharedPtr(this);
        }
 
        void Initialize()
        {
            for (size_t i = 0; i < m_data.size(); ++i)
                m_data[i] = T();
        }
 
        UnderlyingType& operator[](int index)
        {
            using namespace Collections::Generic::Details;
            if (IsOutOfBounds(index, m_data)) {
                throw ArgumentOutOfRangeException(u"index");
            }
            return m_data[static_cast<typename vector_t::size_type>(index)];
        }
 
        UnderlyingType const& operator[](int index) const
        {
            using namespace Collections::Generic::Details;
            if (IsOutOfBounds(index, m_data)) {
                throw ArgumentOutOfRangeException(u"index");
            }
            return m_data[static_cast<typename vector_t::size_type>(index)];
        }
 
        ArrayPtr<T> Clone()
        {
            System::ArrayPtr<T> clone = System::MakeObject< System::Array<T> >(static_cast<int>(m_data.size()));
            std::copy(m_data.begin(), m_data.end(), clone->data().begin());
            return clone;
        }
 
        static SharedPtr<Collections::ObjectModel::ReadOnlyCollection<T>> AsReadOnly(const SharedPtr<Array<T>>& array)
        {
            return System::MakeObject<Collections::ObjectModel::ReadOnlyCollection<T>>(array);
        }
 
        static int BinarySearch(System::ArrayPtr<T> arr, const T &item)
        {
            return Collections::Generic::_net_binnary_search(arr->m_data, 0, static_cast<int32_t>(arr->m_data.size()), item);
        }
 
        template<typename Y, typename Z>
        static int BinarySearch(System::ArrayPtr<T> arr, const Y& item, const SharedPtr<Collections::Generic::IComparer<Z>>& comparer)
        {
            throw NotImplementedException();
        }
 
        int GetLength(int dimension)
        {
            return static_cast<int>(GetLongLength(dimension));
        }
 
        int64_t GetLongLength(int dimension)
        {
            return upper_bound(m_data, dimension) + 1;
        }
 
        int GetLowerBound(int dimension) const
        {
            ASPOSE_UNUSED(dimension);
            return 0;
        }
 
        int GetUpperBound(int dimension)
        {
            return upper_bound(m_data, dimension);
        }
 
        template <typename InputType, typename OutputType>
        static ArrayPtr<OutputType> ConvertAll(ArrayPtr<InputType> input_array, Converter<InputType, OutputType> converter)
        {
            if (!input_array)
            {
                throw System::ArgumentNullException(u"arr");
            }
 
            if (converter.IsNull())
            {
                throw System::ArgumentNullException(u"converter");
            }
 
            System::ArrayPtr<OutputType> newArray = System::MakeObject< System::Array<OutputType> >(input_array->get_Length());
            for (int i = 0; i < input_array->get_Length(); i++)
            {
                newArray[i] = converter(input_array[i]);
            }
            return newArray;
        }
 
        template <typename InputType, typename OutputType>
        static ArrayPtr<OutputType> ConvertAll(ArrayPtr<InputType> input_array, std::function<OutputType(InputType)> converter)
        {
            return ConvertAll(input_array, Converter<InputType, OutputType>(converter));
        }
 
        static int FindIndex(System::ArrayPtr<T> arr, System::Predicate<T> match)
        {
            if (!arr || match.IsNull())
            {
                throw System::ArgumentNullException(u"arr or match");
            }
 
            for (int i = 0; i < arr->get_Length(); i++)
            {
                if (match(arr[i]))
                    return i;
            }
            return -1;
        }
 
        static T Find(System::ArrayPtr<T> arr, System::Predicate<T> match)
        {
            if (!arr || match.IsNull())
            {
                throw System::ArgumentNullException(u"arr or match");
            }
 
            for (auto val: arr->m_data)
                if (match(val))
                    return val;
            return T();
        }
 
        static System::ArrayPtr<T> FindAll(System::ArrayPtr<T> arr, System::Predicate<T> match)
        {
            if (!arr || match.IsNull())
            {
                throw System::ArgumentNullException(u"arr or match");
            }
 
            System::ArrayPtr<T> result = System::MakeObject<System::Array<T>>();
 
            for (auto val : arr->m_data)
                if (match(val))
                    result->data().push_back(val);
 
            return result;
        }
 
        static bool TrueForAll(System::ArrayPtr<T> arr, System::Predicate<T> match)
        {
            if (!arr || match.IsNull())
            {
                throw System::ArgumentNullException(u"arr or match");
            }
            for (auto val : arr->m_data)
                if (!match(val))
                    return false;
            return true;
        }
 
        int32_t get_Rank() const { throw System::NotImplementedException(ASPOSE_CURRENT_FUNCTION); };
 
        int32_t get_Length() const override
        {
            //TODO IF the array is multidimensional THEN OverflowException
            const int64_t len64 = get_LongLength();
 
            if (len64 > (std::numeric_limits<int32_t>::max)()) {
                throw OverflowException();
            }
            return static_cast<int32_t>(len64);
        }
 
        int64_t get_LongLength() const
        {
            return GetSizeTLength();
        }
 
        size_t GetSizeTLength() const
        {
            return recursive_size(m_data);
        }
 
        int Count() const { return get_Length(); }
 
        template<typename DstType>
        void CopyTo(const ArrayPtr<DstType> &dstArray, int64_t dstIndex) const
        {
            this->CopyTo(dstArray, 0, dstIndex, GetSizeTLength());
        }
 
        template<typename DstType>
        void CopyTo(const System::Details::ArrayView<DstType> &dstArray, int64_t dstIndex) const
        {
            this->CopyTo(dstArray, 0, dstIndex, GetSizeTLength());
        }
 
        template<typename DstType>
        void CopyTo(const ArrayPtr<DstType> &dstArray, int64_t srcIndex, int64_t dstIndex, int64_t count) const
        {
            using namespace Collections::Generic::Details;
 
            if (!dstArray) {
                throw ArgumentNullException(u"dstArray");
            }
            if (srcIndex < 0 || dstIndex < 0 || count < 0) {
                throw ArgumentOutOfRangeException(u"srcIndex, dstIndex or count");
            }
            if (IsOutOfSize(srcIndex + count, m_data)
                || IsOutOfSize(dstIndex + count, dstArray->data())) {
                throw ArgumentException(u"srcIndex, dstIndex or count");
            }
 
            // casts are safe because bounds have already checked.
 
            if (dstArray.GetObjectOrNull() == (Object*)(this) && dstIndex > srcIndex && dstIndex < srcIndex + count)
            {
                std::copy_backward(
                    m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex)
                    , m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                    , dstArray->data().begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, dstIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                );
            }
            else
            {
                std::copy(
                    m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex)
                    , m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                    , dstArray->data().begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, dstIndex)
                );
            }
        }
 
        template<typename DstType>
        void CopyTo(const System::Details::ArrayView<DstType> &dstArray, int64_t srcIndex, int64_t dstIndex, int64_t count) const
        {
            using namespace Collections::Generic::Details;
 
            if (!dstArray) {
                throw ArgumentNullException(u"dstArray");
            }
            if (srcIndex < 0 || dstIndex < 0 || count < 0) {
                throw ArgumentOutOfRangeException(u"srcIndex, dstIndex or count");
            }
            if (IsOutOfSize(srcIndex + count, m_data)
                || dstIndex + count > dstArray.get_Length()) {
                throw ArgumentException(u"srcIndex, dstIndex or count");
            }
 
            if (dstArray.data() == this->data().data()
                && dstIndex > srcIndex && dstIndex < srcIndex + count)
            {
                std::copy_backward(
                    m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex)
                    , m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                    , dstArray.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, dstIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                );
            }
            else
            {
                std::copy(
                    m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex)
                    , m_data.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, srcIndex) + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, count)
                    , dstArray.begin() + ASPOSECPP_CHECKED_CAST(std::ptrdiff_t, dstIndex)
                );
            }
        }
 
        static void ForEach(const ArrayPtr<T>& arr, System::Action<T> action)
        {
            if (action.IsNull())
                throw ArgumentNullException(u"action");
 
            for (auto val : arr->m_data)
                action(val);
        }
 
        template<typename ArrayType, typename ValueType>
        static int IndexOf(const ArrayPtr<ArrayType> &arr, const ValueType& value)
        {
            return IndexOf(arr, value, 0);
        }
 
        template<typename ArrayType, typename ValueType>
        static int IndexOf(const ArrayPtr<ArrayType> &arr, const ValueType& value, int startIndex)
        {
            return IndexOf(arr, value, startIndex, arr->get_Length() - startIndex);
        }
 
        template<typename ArrayType, typename ValueType>
        static int IndexOf(const ArrayPtr<ArrayType> &arr, const ValueType& value, int startIndex, int count)
        {
            using namespace Collections::Generic::Details;
            if (!arr) {
                throw ArgumentNullException(u"arr");
            }
            if (startIndex < 0 || count < 0 || IsOutOfSize(startIndex + count, arr->data())) {
                throw ArgumentOutOfRangeException(u"startIndex or count");
            }
 
            auto begin = arr->data().begin() + startIndex;
            auto end = begin + count;
            auto it =
                std::find_if(begin, end, [&value](const ArrayType& item) { return Details::AreEqual(item, value); });
 
            return (it != end) ? static_cast<int>(it - arr->data().begin()) : -1;
        }
 
        template<typename ArrayType, typename ValueType>
        static int LastIndexOf(const ArrayPtr<ArrayType>& arr, const ValueType& value, int startIndex, int count)
        {
            using namespace Collections::Generic::Details;
            if (!arr) {
                throw ArgumentNullException(u"arr");
            }
            if (startIndex < 0 || count < 0
                || IsOutOfSize(startIndex, arr->data()) || IsOutOfSize(count, arr->data())
                || (startIndex - count + 1) < 0) {
                throw ArgumentOutOfRangeException(u"startIndex or count");
            }
            auto rbegin = arr->data().rbegin() + arr->data().size() - startIndex - 1;
            auto rend = rbegin + count;
            auto rit = std::find_if(rbegin, rend, [&value](const ArrayType& item) { return Details::AreEqual(item, value); });
 
            return (rit != rend) ? ASPOSECPP_CHECKED_CAST(int, rit.base() - arr->data().begin() - 1) : -1;
        }
 
        template<typename ArrayType, typename ValueType>
        static int LastIndexOf(const ArrayPtr<ArrayType>& items, const ValueType& value, int startIndex)
        {
            return LastIndexOf(items, value, startIndex, (items->get_Length() == 0) ? 0 : startIndex + 1);
        }
 
        template<typename ArrayType, typename ValueType>
        static int LastIndexOf(const ArrayPtr<ArrayType>& items, const ValueType& value)
        {
            return LastIndexOf(items, value, items->get_Length() - 1, items->get_Length());
        }
 
        template<typename Type>
        static void Clear(const ArrayPtr<Type> &arr, int startIndex, int count)
        {
            using namespace Collections::Generic::Details;
            if (!arr) {
                throw ArgumentNullException(u"arr");
            }
            if (startIndex < 0 || count < 0 || IsOutOfSize(startIndex + count, arr->data())) {
                throw ArgumentOutOfRangeException(u"startIndex or count");
            }
 
            for (auto i = 0; i < count; ++i)
                arr->data().at(startIndex + i) = Type();
        }
 
        //  index and pastes them to another System.Array starting at the specified destination
        //  index. Guarantees that all changes are undone if the copy does not succeed completely.
        template <typename SrcType, typename DstType>
        static void ConstrainedCopy(const ArrayPtr<SrcType> &srcArray, int64_t srcIndex,
            const ArrayPtr<DstType> &dstArray, int64_t dstIndex, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray->CopyTo(dstArray, srcIndex, dstIndex, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(const ArrayPtr<SrcType> &srcArray,
            const ArrayPtr<DstType> &dstArray, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray->CopyTo(dstArray, 0, 0, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(System::Details::ArrayView<SrcType> srcArray,
            const ArrayPtr<DstType> &dstArray, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray.CopyTo(dstArray, 0, 0, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(const ArrayPtr<SrcType> &srcArray,
            System::Details::ArrayView<DstType> dstArray, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray->CopyTo(dstArray, 0, 0, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(System::Details::ArrayView<SrcType> srcArray,
            System::Details::ArrayView<DstType> dstArray, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray.CopyTo(dstArray, 0, 0, count);
        }
 
        template<typename SrcType, std::size_t N, typename DstType>
        static void Copy(System::Details::StackArray<SrcType, N> &srcArray,
            const ArrayPtr<DstType> &dstArray, int64_t count)
        {
            Copy(static_cast<System::Details::ArrayView<SrcType> >(srcArray), dstArray, count);
        }
 
        template<typename SrcType, typename DstType, std::size_t N>
        static void Copy(const ArrayPtr<SrcType> &srcArray,
            System::Details::StackArray<DstType, N> &dstArray, int64_t count)
        {
            Copy(srcArray, static_cast<System::Details::ArrayView<DstType> >(dstArray), count);
        }
 
        template<typename SrcType, std::size_t NS, typename DstType, std::size_t ND>
        static void Copy(System::Details::StackArray<SrcType, NS> &srcArray,
            System::Details::StackArray<DstType, ND> &dstArray, int64_t count)
        {
            Copy(static_cast<System::Details::ArrayView<SrcType> >(srcArray),
                static_cast<System::Details::ArrayView<DstType> >(dstArray), count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(const ArrayPtr<SrcType> &srcArray, int64_t srcIndex,
            const ArrayPtr<DstType> &dstArray, int64_t dstIndex, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray->CopyTo(dstArray, srcIndex, dstIndex, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(System::Details::ArrayView<SrcType> srcArray, int64_t srcIndex,
            const ArrayPtr<DstType> &dstArray, int64_t dstIndex, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray.CopyTo(dstArray, srcIndex, dstIndex, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(const ArrayPtr<SrcType> &srcArray, int64_t srcIndex,
            System::Details::ArrayView<DstType> dstArray, int64_t dstIndex, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray->CopyTo(dstArray, srcIndex, dstIndex, count);
        }
 
        template<typename SrcType, typename DstType>
        static void Copy(System::Details::ArrayView<SrcType> srcArray, int64_t srcIndex,
            System::Details::ArrayView<DstType> dstArray, int64_t dstIndex, int64_t count)
        {
            if (!srcArray) {
                throw ArgumentNullException(u"srcArray");
            }
            srcArray.CopyTo(dstArray, srcIndex, dstIndex, count);
        }
 
        template<typename SrcType, std::size_t N, typename DstType>
        static void Copy(System::Details::StackArray<SrcType, N> &srcArray, int64_t srcIndex,
            const ArrayPtr<DstType> &dstArray, int64_t dstIndex, int64_t count)
        {
            Copy(static_cast<System::Details::ArrayView<SrcType> >(srcArray), srcIndex, dstArray, dstIndex, count);
        }
 
        template<typename SrcType, typename DstType, std::size_t N>
        static void Copy(const ArrayPtr<SrcType> &srcArray, int64_t srcIndex,
            System::Details::StackArray<DstType, N> &dstArray, int64_t dstIndex, int64_t count)
        {
            Copy(srcArray, srcIndex, static_cast<System::Details::ArrayView<DstType> >(dstArray), dstIndex, count);
        }
 
        template<typename SrcType, std::size_t NS, typename DstType, std::size_t ND>
        static void Copy(System::Details::StackArray<SrcType, NS> &srcArray, int64_t srcIndex,
            System::Details::StackArray<DstType, ND> &dstArray, int64_t dstIndex, int64_t count)
        {
            Copy(static_cast<System::Details::ArrayView<SrcType>>(srcArray), srcIndex,
                static_cast<System::Details::ArrayView<DstType>>(dstArray), dstIndex, count);
        }
 
        template<typename SrcType, typename DstType, std::size_t ND>
        static void Copy(System::Details::ArrayView<SrcType> &srcArray, int64_t srcIndex,
            System::Details::StackArray<DstType, ND> &dstArray, int64_t dstIndex, int64_t count)
        {
            Copy(srcArray, srcIndex,
                static_cast<System::Details::ArrayView<DstType>>(dstArray), dstIndex, count);
        }
 
        template<typename Type>
        static void Sort(const ArrayPtr<Type> &arr)
        {
            Sort(arr, 0, arr->get_Length());
        }
 
        template<typename Type>
        static void Sort(const ArrayPtr<Type> &arr, int startIndex, int count)
        {
            using namespace Collections::Generic::Details;
            if (!arr) {
                throw ArgumentNullException(u"arr");
            }
            if (startIndex < 0 || count < 0 || IsOutOfSize(startIndex + count, arr->data())) {
                throw ArgumentOutOfRangeException(u"startIndex or count");
            }
 
            auto begin = arr->data().begin() + startIndex;
            auto end = begin + count;
 
            std::sort(begin, end, Collections::Generic::Details::ComparerType<Type>());
        }
 
        template<typename Type>
        static void Sort(const ArrayPtr<Type> &arr, const SharedPtr<System::Collections::Generic::IComparer<T>>& comparator)
        {
            Collections::Generic::ComparerAdapter<T> adapter(comparator);
            std::sort(arr->data().begin(), arr->data().end(), adapter);
        }
 
        template<typename Type, typename Y>
        static void Sort(const ArrayPtr<Type>& arr, const SharedPtr<System::Collections::Generic::IComparer<Y>>& comparator)
        {
            throw NotImplementedException();
        }
 
        template<typename Type>
        static void Sort(const ArrayPtr<Type>& arr, const System::Comparison<T>& comparison)
        {
            std::sort(arr->data().begin(), arr->data().end(), comparison);
        }
 
        template<typename TKey, typename TValue>
        static void Sort(const ArrayPtr<TKey>& keys, const ArrayPtr<TValue>& items)
        {
            if (keys == nullptr)
                throw ArgumentNullException(u"keys");
 
            Sort(keys, items, 0, keys->get_Length());
        }
 
        template<typename TKey, typename TValue>
        static void Sort(const ArrayPtr<TKey>& keys, const ArrayPtr<TValue>& items, int index, int length)
        {
            if (keys == nullptr)
                throw ArgumentNullException(u"keys");
            if (index < 0 || length < 0)
                throw ArgumentOutOfRangeException(length < 0 ? u"length" : u"index");
            if (index + length > keys->Count() || (items != nullptr && index + length > items->Count()))
                throw ArgumentException();
 
            if (items == nullptr)
            {
                typename std::vector<TKey>::iterator keys_begin = keys->data().begin() + index;
                typename std::vector<TKey>::iterator keys_end = keys_begin + length;
 
                std::sort(keys_begin, keys_end, Collections::Generic::Details::ComparerType<TKey>());
            }
            else
            {
                // Sorting keys and items via multimap
                std::multimap<TKey, TValue, Collections::Generic::Details::ComparerType<TKey>> map;
                for (int i = index; i < index + length; ++i)
                    map.insert(std::make_pair(keys[i], items[i]));
 
                auto map_iter = map.begin();
                for (int i = index; (i < index + length) && (map_iter != map.end()); ++i, ++map_iter)
                {
                    keys[i] = map_iter->first;
                    items[i] = map_iter->second;
                }
            }
        }
 
        template<typename Type>
        static void Reverse(const ArrayPtr<Type> &arr)
        {
            std::reverse(arr->m_data.begin(), arr->m_data.end());
        }
 
        template<typename Type>
        static void Reverse(const ArrayPtr<Type> &arr, int startIndex, int count)
        {
            using namespace Collections::Generic::Details;
            if (!arr) {
                throw ArgumentNullException(u"arr");
            }
            if (startIndex < 0 || count < 0 || IsOutOfSize(startIndex + count, arr->data())) {
                throw ArgumentOutOfRangeException(u"startIndex or count");
            }
 
            std::reverse(arr->m_data.begin() + startIndex, arr->m_data.begin() + startIndex + count);
        }
 
        template<typename Type>
        static void Resize(ArrayPtr<Type> &arr, int new_size)
        {
            if (new_size < 0)
                throw ArgumentOutOfRangeException(u"new_size");
 
            if (arr)
            {
                // Array is present, so we need to resize it
                if (arr.get_shared_count() != 1)
                {
                    // Array is shared between some variables, so we need to create new one of needed size
                    auto new_array = MakeObject<Array<T>>(new_size);
                    std::copy(arr->data_ptr(), arr->data_ptr() + (std::ptrdiff_t)std::min(new_size, arr->get_Length()), new_array->data_ptr());
                    arr = new_array;
                }
                else
                {
                    // Array is owned only by this variable, so we probably can just resize its data
                    arr->m_data.resize((typename vector_t::size_type)new_size);
                }
            }
            else
            {
                // No array present, we just need to create new one
                arr = MakeObject<Array<T>>(new_size);
            }
        }
 
        void SetValue(const T &value, int index)
        {
            using namespace Collections::Generic::Details;
            if (IsOutOfBounds(index, m_data)) {
                throw ArgumentOutOfRangeException(u"index");
            }
            m_data[index] = value;
        }
 
        vector_t& data() { return m_data; }
 
        const vector_t& data() const { return m_data; }
 
        typename vector_t::pointer data_ptr() // VS2013 std::vector has no data() member
        {
            if(m_data.empty())
                return nullptr;
 
            return &m_data[0];
        }
 
        const UnderlyingType * data_ptr() const { return data_ptr(); }
 
        void* raw_data_ptr() override { return data_ptr(); }
 
        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;
 
        iterator begin() noexcept
        {
            return m_data.begin();
        }
 
        const_iterator begin() const noexcept 
        {
            return m_data.begin();
        }
 
        const_iterator cbegin() const noexcept 
        {
            return m_data.cbegin();
        }
 
        iterator end() noexcept
        {
            return m_data.end();
        }
 
        const_iterator end() const noexcept 
        {
            return m_data.end();
        }
 
        const_iterator cend() const noexcept 
        {
            return m_data.cend();
        }
 
        reverse_iterator rbegin() noexcept
        {
            return m_data.rbegin();
        }
 
        const_reverse_iterator rbegin() const noexcept
        {
            return m_data.rbegin();
        }
 
        const_reverse_iterator crbegin() const noexcept
        {
            return m_data.crbegin();
        }
 
        reverse_iterator rend() noexcept
        {
            return m_data.rend();
        }
 
        const_reverse_iterator rend() const noexcept
        {
            return m_data.rend();
        }
 
        const_reverse_iterator crend() const noexcept
        {
            return m_data.crend();
        }
 
        // int get_Count() const; - see ICollection<T> interface
        // void Add(const T& item); - see ICollection<T> interface
        // void Clear(); - see ICollection<T> interface
        // bool Contains(const T& item) const; - see ICollection<T> interface
        // bool Remove(const T& item); - see ICollection<T> interface
 
        // IList interface
 
        // int IndexOf(const T& item) const; - see IList<T> interface
        // void Insert(int index, const T& item); - see IList<T> interface
        // void RemoveAt(int index); - see IList<T> interface
 
        // IEnumerable interface
        UnderlyingType Min() const
        {
            return *std::min_element(m_data.cbegin(), m_data.cend());
        }
 
        UnderlyingType Max() const
        {
            return *std::max_element(m_data.cbegin(), m_data.cend());
        }
 
        static bool Exists(ArrayPtr<T> arr, std::function<bool(T)> match)
        {
            for (int i = 0; i < arr->get_Length(); i++)
            {
                if (match(arr[i]))
                    return true;
            }
            return false;
        }
 
        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 ErrType>
        static int upper_bound(ErrType arr, int dim)
        {
            ASPOSE_UNUSED(arr);
            ASPOSE_UNUSED(dim);
            throw System::IndexOutOfRangeException();
        }
        template <typename VType, typename Alloc>
        static int upper_bound(const std::vector<VType, Alloc> &arr, int dim)
        {
            if (!dim)
                return (int)arr.size() - 1;
 
            if (!arr.size())
                return -1;
 
            return upper_bound(arr[0], dim - 1);
        }
 
        template <typename U, typename Alloc>
        static size_t recursive_size(const std::vector<U, Alloc>& v)
        {
            return v.size();
        }
        
        template <typename U, typename Alloc1, typename Alloc2>
        static size_t recursive_size(const std::vector<std::vector<U, Alloc1>, Alloc2>& v)
        {
            size_t rv = 0;
            for (const auto &i : v)
                rv += recursive_size(i);
 
            return rv;
        }
 
protected:
    ~Array() 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 "Array<T>"; }
#endif
    };
    template <typename TTo>
    struct CastResult<Array<TTo>>
    {
        typedef ArrayPtr<TTo> type;
    };
 
 
    namespace Details {
        template <typename T>
        inline Array<T>* CreateArray(Array<T>*)
        {
            return new Array<T>(0);
        }
 
    } // namespace Details
 
} // namespace System
 
#endif // _aspose_system_array_h_