List.h

Go to the documentation of this file.

 
#pragma once
 
#include "Common.h"
#include "System/Object.h"
#include "System/Array.h"
#include <new>
#include <utility>
#include <initializer_list>
 
namespace DotNetDupe {
    namespace System {
        namespace Collections {
            namespace Generic {

                template <typename T>
                class List : public Object {
                public:
                    List() { }

                    List(int iCapacity) { SetCapacity(iCapacity); }

                    List(const std::initializer_list<T>& vCollection) {
                        SetCapacity((int)vCollection.size());
                        for (const auto& item : vCollection) {
                            Add(item);
                        }
                    }

                    List(const List& lstOther) {
                        SetCapacity(lstOther.m_iCapacity);
                        for (int i = 0; i < lstOther.m_iCount; ++i) {
                            Add(lstOther.m_pData[i]);
                        }
                    }

                    List& operator=(const List& lstOther) {
                        if (this != &lstOther) {
                            Clear();
                            SetCapacity(lstOther.m_iCapacity);
                            for (int i = 0; i < lstOther.m_iCount; ++i) {
                                Add(lstOther.m_pData[i]);
                            }
                        }
                        return *this;
                    }

                    List(List&& lstOther) noexcept : m_pData(lstOther.m_pData), m_iCount(lstOther.m_iCount), m_iCapacity(lstOther.m_iCapacity) {
                        lstOther.m_pData = nullptr;
                        lstOther.m_iCount = 0;
                        lstOther.m_iCapacity = 0;
                    }

                    List& operator=(List&& lstOther) noexcept {
                        if (this != &lstOther) {
                            FreeBuffer();
                            m_pData = lstOther.m_pData;
                            m_iCount = lstOther.m_iCount;
                            m_iCapacity = lstOther.m_iCapacity;
                            lstOther.m_pData = nullptr;
                            lstOther.m_iCount = 0;
                            lstOther.m_iCapacity = 0;
                        }
                        return *this;
                    }

                    ~List() override {
                        FreeBuffer();
                    }

                    int GetCount() const { return m_iCount; }

                    int GetCapacity() const { return m_iCapacity; }
                    
                    void SetCapacity(int iValue) {
                        if (iValue > m_iCapacity) {
                            T* pNewData = static_cast<T*>(AllocateCollectionBuffer(sizeof(T) * iValue));
                            for (int i = 0; i < m_iCount; ++i) {
                                ::new ((void*)&pNewData[i]) T(std::move(m_pData[i]));
                            }
                            FreeBuffer();
                            m_pData = pNewData;
                            m_iCapacity = iValue;
                        }
                    }

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

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

                    void Add(const T& item) {
                        if (m_iCount == m_iCapacity) {
                            SetCapacity(m_iCapacity == 0 ? 4 : m_iCapacity * 2);
                        }
                        ::new ((void*)&m_pData[m_iCount]) T(item);
                        m_iCount++;
                    }

                    void AddRange(const Array<T>& arrCollection) {
                        int iNewCount = m_iCount + arrCollection.GetLength();
                        if (iNewCount > m_iCapacity) {
                            SetCapacity(iNewCount);
                        }
                        for (int iIdx = 0; iIdx < arrCollection.GetLength(); iIdx++) {
                            ::new ((void*)&m_pData[m_iCount]) T(arrCollection[iIdx]);
                            m_iCount++;
                        }
                    }

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

                    bool Contains(const T& item) const {
                        return IndexOf(item) != -1;
                    }

                    int IndexOf(const T& item) const {
                        for (int i = 0; i < m_iCount; ++i) {
                            if (m_pData[i] == item) return i;
                        }
                        return -1;
                    }

                    int BinarySearch(const T& item) const {
                        int low = 0;
                        int high = m_iCount - 1;
                        while (low <= high) {
                            int mid = low + (high - low) / 2;
                            if (m_pData[mid] == item) return mid;
                            if (m_pData[mid] < item) {
                                low = mid + 1;
                            } else {
                                high = mid - 1;
                            }
                        }
                        return ~low;
                    }

                    void Insert(int iIndex, const T& item) {
                        if (m_iCount == m_iCapacity) {
                            SetCapacity(m_iCapacity == 0 ? 4 : m_iCapacity * 2);
                        }
                        if (iIndex < m_iCount) {
                            ::new ((void*)&m_pData[m_iCount]) T(std::move(m_pData[m_iCount - 1]));
                            for (int i = m_iCount - 1; i > iIndex; --i) {
                                m_pData[i] = std::move(m_pData[i - 1]);
                            }
                            m_pData[iIndex] = item;
                        } else {
                            ::new ((void*)&m_pData[m_iCount]) T(item);
                        }
                        m_iCount++;
                    }

                    bool Remove(const T& item) {
                        int idx = IndexOf(item);
                        if (idx != -1) {
                            RemoveAt(idx);
                            return true;
                        }
                        return false;
                    }

                    void RemoveAt(int iIndex) {
                        if (iIndex >= 0 && iIndex < m_iCount) {
                            for (int i = iIndex; i < m_iCount - 1; ++i) {
                                m_pData[i] = std::move(m_pData[i + 1]);
                            }
                            m_pData[m_iCount - 1].~T();
                            m_iCount--;
                        }
                    }
 
                    void SwapElements(T& a, T& b) {
                        T temp = std::move(a);
                        a = std::move(b);
                        b = std::move(temp);
                    }

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

                    template <typename Predicate>
                    bool Exists(Predicate fnMatch) const {
                        for (int i = 0; i < m_iCount; ++i) {
                            if (fnMatch(m_pData[i])) return true;
                        }
                        return false;
                    }

                    template <typename Predicate>
                    T Find(Predicate fnMatch) const {
                        for (int i = 0; i < m_iCount; ++i) {
                            if (fnMatch(m_pData[i])) return m_pData[i];
                        }
                        return T();
                    }

                    template <typename Predicate>
                    List<T> FindAll(Predicate fnMatch) const {
                        List<T> lstResult;
                        for (int i = 0; i < m_iCount; ++i) {
                            if (fnMatch(m_pData[i])) lstResult.Add(m_pData[i]);
                        }
                        return lstResult;
                    }

                    template <typename Predicate>
                    bool TrueForAll(Predicate fnMatch) const {
                        for (int i = 0; i < m_iCount; ++i) {
                            if (!fnMatch(m_pData[i])) return false;
                        }
                        return true;
                    }

                    Array<T> ToArray() const {
                        Array<T> arrResult(m_iCount);
                        for (int iIdx = 0; iIdx < m_iCount; iIdx++) {
                            arrResult[iIdx] = m_pData[iIdx];
                        }
                        return arrResult;
                    }

                    T* begin() { return m_pData; }

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

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

                    const T* end() const { return m_pData + m_iCount; }
 
                private:
                    T* m_pData = nullptr;
                    int m_iCount = 0;
                    int m_iCapacity = 0;
 
                    void FreeBuffer() {
                        if (m_pData) {
                            for (int i = 0; i < m_iCount; ++i) {
                                m_pData[i].~T();
                            }
                            FreeCollectionBuffer(m_pData);
                            m_pData = nullptr;
                        }
                    }
                };
            }
        }
    }
}