Array.h

Go to the documentation of this file.

 
#pragma once
 
#include "Common.h"
#include "System/Object.h"
#include "System/ArgumentException.h"
#include "System/ArgumentOutOfRangeException.h"
#include "System/Predicate.h"
#include "System/Action.h"
#include "System/String.h"
#include <new>
#include <initializer_list>
#include <utility>
#include <cstddef>
 
namespace DotNetDupe {
    namespace System {

        template <class T>
        class Array : public Object {
        private:
            T* m_pData = nullptr;
            int m_iLength = 0;
 
            void Allocate(int iLength) {
                if (iLength > 0) {
                    m_pData = static_cast<T*>(AllocateCollectionBuffer(sizeof(T) * iLength));
                    m_iLength = iLength;
                }
            }
 
            void Free() {
                if (m_pData) {
                    for (int i = 0; i < m_iLength; ++i) {
                        m_pData[i].~T();
                    }
                    FreeCollectionBuffer(m_pData);
                    m_pData = nullptr;
                    m_iLength = 0;
                }
            }
 
            void SwapElements(T& a, T& b) {
                T temp = std::move(a);
                a = std::move(b);
                b = std::move(temp);
            }
 
        public:
            Array() = default;

            Array(int iLength) {
                Allocate(iLength);
                for (int i = 0; i < m_iLength; ++i) {
                    ::new ((void*)&m_pData[i]) T();
                }
            }

            Array(const T* pData, int iLength) {
                Allocate(iLength);
                if (pData) {
                    for (int i = 0; i < m_iLength; ++i) {
                        ::new ((void*)&m_pData[i]) T(pData[i]);
                    }
                } else {
                    for (int i = 0; i < m_iLength; ++i) {
                        ::new ((void*)&m_pData[i]) T();
                    }
                }
            }

            Array(const std::initializer_list<T>& vItems) {
                Allocate(static_cast<int>(vItems.size()));
                int iIdx = 0;
                for (const auto& item : vItems) {
                    ::new ((void*)&m_pData[iIdx++]) T(item);
                }
            }

            Array(const Array& other) {
                Allocate(other.m_iLength);
                for (int i = 0; i < m_iLength; ++i) {
                    ::new ((void*)&m_pData[i]) T(other.m_pData[i]);
                }
            }

            Array& operator=(const Array& other) {
                if (this != &other) {
                    Free();
                    Allocate(other.m_iLength);
                    for (int i = 0; i < m_iLength; ++i) {
                        ::new ((void*)&m_pData[i]) T(other.m_pData[i]);
                    }
                }
                return *this;
            }

            Array(Array&& other) noexcept : m_pData(other.m_pData), m_iLength(other.m_iLength) {
                other.m_pData = nullptr;
                other.m_iLength = 0;
            }

            Array& operator=(Array&& other) noexcept {
                if (this != &other) {
                    Free();
                    m_pData = other.m_pData;
                    m_iLength = other.m_iLength;
                    other.m_pData = nullptr;
                    other.m_iLength = 0;
                }
                return *this;
            }

            ~Array() override {
                Free();
            }

            int GetLength() const { return m_iLength; }

            T* GetData() { return m_pData; }

            const T* GetData() const { return m_pData; }

            T* begin() { return m_pData; }

            T* end() { return m_pData + m_iLength; }

            const T* begin() const { return m_pData; }

            const T* end() const { return m_pData + m_iLength; }

            bool IsNull() const { return m_iLength == 0; }

            T& operator[](int iIndex) { return m_pData[iIndex]; }

            const T& operator[](int iIndex) const { return m_pData[iIndex]; }

            int IndexOf(const T& value) const {
                for (int iIdx = 0; iIdx < m_iLength; ++iIdx) {
                    if (m_pData[iIdx] == value) return iIdx;
                }
                return -1;
            }

            int LastIndexOf(const T& value) const {
                for (int iIdx = m_iLength - 1; iIdx >= 0; --iIdx) {
                    if (m_pData[iIdx] == value) return iIdx;
                }
                return -1;
            }

            void Sort() {
                for (int i = 0; i < m_iLength - 1; ++i) {
                    for (int j = 0; j < m_iLength - i - 1; ++j) {
                        if (m_pData[j] > m_pData[j + 1]) {
                            SwapElements(m_pData[j], m_pData[j + 1]);
                        }
                    }
                }
            }

            void Reverse() {
                int left = 0;
                int right = m_iLength - 1;
                while (left < right) {
                    SwapElements(m_pData[left], m_pData[right]);
                    left++;
                    right--;
                }
            }

            void Clear() {
                for (int i = 0; i < m_iLength; ++i) {
                    m_pData[i] = T();
                }
            }

            void CopyTo(Array<T>& arrTarget, int iIndex);

            static void Copy(Array<T>& arrSource, Array<T>& arrDestination, int iLength);

            bool Exists(const Predicate<T>& fnPredicate) const {
                for (int i = 0; i < m_iLength; ++i) {
                    if (fnPredicate(m_pData[i])) return true;
                }
                return false;
            }

            T Find(const Predicate<T>& fnPredicate) const {
                for (int i = 0; i < m_iLength; ++i) {
                    if (fnPredicate(m_pData[i])) return m_pData[i];
                }
                return T();
            }

            Array<T> FindAll(const Predicate<T>& fnPredicate) const {
                int count = 0;
                for (int i = 0; i < m_iLength; ++i) {
                    if (fnPredicate(m_pData[i])) count++;
                }
                Array<T> arrNew(count);
                int idx = 0;
                for (int i = 0; i < m_iLength; ++i) {
                    if (fnPredicate(m_pData[i])) {
                        arrNew[idx++] = m_pData[i];
                    }
                }
                return arrNew;
            }

            int FindIndex(const Predicate<T>& fnPredicate) const {
                for (int i = 0; i < m_iLength; ++i) {
                    if (fnPredicate(m_pData[i])) return i;
                }
                return -1;
            }

            T FindLast(const Predicate<T>& fnPredicate) const {
                for (int i = m_iLength - 1; i >= 0; --i) {
                    if (fnPredicate(m_pData[i])) return m_pData[i];
                }
                return T();
            }

            int FindLastIndex(const Predicate<T>& fnPredicate) const {
                for (int i = m_iLength - 1; i >= 0; --i) {
                    if (fnPredicate(m_pData[i])) return i;
                }
                return -1;
            }

            void ForEach(const Action<T>& fnAction) {
                for (int i = 0; i < m_iLength; ++i) {
                    fnAction(m_pData[i]);
                }
            }

            bool TrueForAll(const Predicate<T>& fnPredicate) const {
                for (int i = 0; i < m_iLength; ++i) {
                    if (!fnPredicate(m_pData[i])) return false;
                }
                return true;
            }
        };
    }
}
 
#include "System/String.h"
 
namespace DotNetDupe {
    namespace System {
        template <class T>
        inline void Array<T>::CopyTo(Array<T>& arrTarget, int iIndex) {
            if (iIndex < 0) throw ArgumentOutOfRangeException("iIndex");
            if (iIndex + GetLength() > arrTarget.GetLength()) throw ArgumentException("Destination array was not long enough.");

            for (int iIdx = 0; iIdx < GetLength(); ++iIdx) {
                arrTarget[iIndex + iIdx] = m_pData[iIdx];
            }
        }
 
        template <class T>
        inline void Array<T>::Copy(Array<T>& arrSource, Array<T>& arrDestination, int iLength) {
            if (iLength < 0) throw ArgumentOutOfRangeException("iLength");
            if (arrSource.GetLength() < iLength) throw ArgumentException("Source array was not long enough.");
            if (arrDestination.GetLength() < iLength) throw ArgumentException("Destination array was not long enough.");

            for (int iIdx = 0; iIdx < iLength; ++iIdx) {
                arrDestination[iIdx] = arrSource[iIdx];
            }
        }
    }
}