list.h

Go to the documentation of this file.

 
#pragma once
#include <cstddef>
#include <vector>
#include <initializer_list>
#include <functional>
#include <algorithm>
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T>
class List {
        PROMEKI_SHARED_FINAL(List)
        public:
                using Ptr = SharedPtr<List>;
 
                using Data = typename std::vector<T>;
 
                using Iterator = typename std::vector<T>::iterator;
 
                using ConstIterator = typename std::vector<T>::const_iterator;
 
                using RevIterator = typename std::vector<T>::reverse_iterator;
 
                using ConstRevIterator = typename std::vector<T>::const_reverse_iterator;
 
                using TestFunc = std::function<bool(const T &)>;
 
                List() = default;
 
                explicit List(size_t size) : d(size) {}
 
                List(size_t size, const T &defaultValue) : d(size, defaultValue) {}
 
                List(const List &other) : d(other.d) {}
 
                List(List &&other) noexcept : d(std::move(other.d)) {}
 
                List(std::initializer_list<T> initList) : d(initList) {}
 
                ~List() = default;
 
                List &operator=(const List &other) {
                        d = other.d;
                        return *this;
                }
 
                List &operator=(List &&other) noexcept {
                        d = std::move(other.d);
                        return *this;
                }
 
                List &operator=(std::initializer_list<T> initList) {
                        d = initList;
                        return *this;
                }
 
                List &operator+=(const T &item) {
                        pushToBack(item);
                        return *this;
                }
 
                List &operator+=(T &&item) {
                        pushToBack(std::move(item));
                        return *this;
                }
 
                List &operator+=(const List &list) {
                        pushToBack(list);
                        return *this;
                }
 
                List &operator+=(List &&list) {
                        pushToBack(std::move(list));
                        return *this;
                }
 
                Iterator begin() noexcept {
                        return d.begin();
                }
 
                ConstIterator begin() const noexcept {
                        return d.cbegin();
                }
 
                ConstIterator cbegin() const noexcept {
                        return d.cbegin();
                }
 
                ConstIterator constBegin() const noexcept {
                        return d.cbegin();
                }
 
                RevIterator rbegin() noexcept {
                        return d.rbegin();
                }
 
                RevIterator revBegin() noexcept {
                        return d.rbegin();
                }
 
                ConstRevIterator crbegin() const noexcept {
                        return d.crbegin();
                }
 
                ConstRevIterator constRevBegin() const noexcept {
                        return d.crbegin();
                }
 
                Iterator end() noexcept {
                        return d.end();
                }
 
                ConstIterator end() const noexcept {
                        return d.cend();
                }
 
                ConstIterator cend() const noexcept {
                        return d.cend();
                }
 
                ConstIterator constEnd() const noexcept {
                        return d.cend();
                }
 
                RevIterator rend() noexcept {
                        return d.rend();
                }
 
                RevIterator revEnd() noexcept {
                        return d.rend();
                }
 
                ConstRevIterator crend() const noexcept {
                        return d.crend();
                }
 
                ConstRevIterator constRevEnd() const noexcept {
                        return d.crend();
                }
 
                T &at(size_t index) {
                        return d.at(index);
                }
 
                const T &at(size_t index) const {
                        return d.at(index);
                }
 
                T &operator[](size_t index) {
                        return d[index];
                }
 
                const T &operator[](size_t index) const {
                        return d[index];
                }
 
                T &front() {
                        return d.front();
                }
 
                const T &front() const {
                        return d.front();
                }
 
                T &back() {
                        return d.back();
                }
 
                const T &back() const {
                        return d.back();
                }
 
                T *data() noexcept {
                        return d.data();
                }
 
                const T *data() const noexcept {
                        return d.data();
                }
 
                bool isEmpty() const noexcept {
                        return d.empty();
                }
 
                size_t size() const noexcept {
                        return d.size();
                }
 
                size_t maxSize() const noexcept {
                        return d.max_size();
                }
 
                void reserve(size_t newCapacity) {
                        d.reserve(newCapacity);
                }
 
                size_t capacity() const noexcept {
                        return d.capacity();
                }
 
                void shrink() {
                        d.shrink_to_fit();
                        return;
                }
 
                void clear() noexcept {
                        d.clear();
                        return;
                }
 
                Iterator insert(ConstIterator pos, const T &value) {
                        return d.insert(pos, value);
                }
 
                Iterator insert(ConstIterator pos, T &&value) {
                        return d.insert(pos, std::move(value));
                }
 
                Iterator insert(size_t pos, const T &value) {
                        return d.insert(constBegin() + pos, value);
                }
 
                Iterator insert(size_t pos, T &&value) {
                        return d.insert(constBegin() + pos, std::move(value));
                }
 
                template <typename... Args> Iterator emplace(ConstIterator pos, Args &&...args) {
                        return d.emplace(pos, std::forward<Args>(args)...);
                }
 
                template <typename... Args> Iterator emplace(size_t pos, Args &&...args) {
                        return d.emplace(constBegin() + pos, std::forward<Args>(args)...);
                }
 
                Iterator remove(ConstIterator pos) {
                        return d.erase(pos);
                }
 
                Iterator erase(ConstIterator first, ConstIterator last) {
                        return d.erase(first, last);
                }
 
                Iterator remove(size_t index) {
                        return d.erase(d.begin() + index);
                }
 
                void removeIf(TestFunc func) {
                        d.erase(std::remove_if(d.begin(), d.end(), func), d.end());
                        return;
                }
 
                bool removeFirst(const T &value) {
                        bool ret = false;
                        for(auto item = begin(); item != end(); ++item) {
                                if(*item == value) {
                                        remove(item);
                                        ret = true;
                                        break;
                                }
                        }
                        return ret;
                }
 
                void pushToBack(const T &value) {
                        d.push_back(value);
                        return;
                }
 
                void pushToBack(const List<T> &list) {
                        d.insert(d.end(), list.d.begin(), list.d.end());
                        return;
                }
 
                void pushToBack(T &&value) {
                        d.push_back(std::move(value));
                        return;
                }
 
                void pushToBack(List<T> &&list) {
                        d.insert(d.end(), std::make_move_iterator(list.d.begin()), std::make_move_iterator(list.d.end()));
                        return;
                }
 
                template <typename... Args> T &emplaceToBack(Args &&...args) {
                        return d.emplace_back(std::forward<Args>(args)...);
                }
 
                void popFromBack() {
                        d.pop_back();
                        return;
                }
 
                void resize(size_t newSize) {
                        d.resize(newSize);
                        return;
                }
 
                void resize(size_t newSize, const T &value) {
                        d.resize(newSize, value);
                        return;
                }
 
                void swap(List<T> &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                bool set(size_t index, const T &val) {
                        if(index >= size()) return false;
                        d[index] = val;
                        return true;
                }
 
                List<T> sort() const {
                        auto ret = *this;
                        std::sort(ret.begin(), ret.end());
                        return ret;
                }
 
                List<T> reverse() const {
                        auto ret = *this;
                        std::reverse(ret.begin(), ret.end());
                        return ret;
                }
 
                List<T> unique() {
                        auto ret = sort();
                        ret.d.erase(std::unique(ret.begin(), ret.end()), ret.end());
                        return ret;
                }
 
                template <typename Func>
                void forEach(Func &&func) const {
                        for(const auto &item : d) func(item);
                        return;
                }
 
                bool contains(const T &val) const {
                        for(const auto &item : d) {
                                if(item == val) return true;
                        }
                        return false;
                }
 
                ssize_t indexOf(const T &value) const {
                        for(size_t i = 0; i < d.size(); ++i) {
                                if(d[i] == value) return static_cast<ssize_t>(i);
                        }
                        return -1;
                }
 
                ssize_t lastIndexOf(const T &value) const {
                        for(ssize_t i = static_cast<ssize_t>(d.size()) - 1; i >= 0; --i) {
                                if(d[static_cast<size_t>(i)] == value) return i;
                        }
                        return -1;
                }
 
                size_t count(const T &value) const {
                        size_t n = 0;
                        for(const auto &item : d) {
                                if(item == value) ++n;
                        }
                        return n;
                }
 
                List<T> mid(size_t pos, size_t length) const {
                        List<T> ret;
                        size_t end = pos + length;
                        if(end > d.size()) end = d.size();
                        if(pos >= d.size()) return ret;
                        ret.reserve(end - pos);
                        for(size_t i = pos; i < end; ++i) ret.pushToBack(d[i]);
                        return ret;
                }
 
                friend bool operator==(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d == rhs.d;
                }
 
                friend bool operator!=(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d != rhs.d;
                }
 
                friend bool operator<(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d < rhs.d;
                }
 
                friend bool operator>(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d > rhs.d;
                }
 
                friend bool operator<=(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d <= rhs.d;
                }
 
                friend bool operator>=(const List<T> &lhs, const List<T> &rhs) {
                        return lhs.d >= rhs.d;
                }
 
        private:
                Data  d;
};
 
PROMEKI_NAMESPACE_END