list.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <vector>
#include <initializer_list>
#include <functional>
#include <algorithm>
#include <stdexcept>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/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 = 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(const T *first, const T *last) : d(first, last) {}
 
                ~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;
                }
 
                template <typename InputIt> void assign(InputIt first, InputIt last) {
                        d.assign(first, last);
                        return;
                }
 
                void assign(size_t count, const T &value) {
                        d.assign(count, value);
                        return;
                }
 
                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) {
                        if (index >= d.size()) throw std::logic_error("List::at index out of range");
                        return d[index];
                }
 
                const T &at(size_t index) const {
                        if (index >= d.size()) throw std::logic_error("List::at index out of range");
                        return d[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(const T *first, const T *last) {
                        d.insert(d.end(), first, last);
                        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;
                }
 
                template <typename Compare> List<T> sort(Compare comp) const {
                        auto ret = *this;
                        std::sort(ret.begin(), ret.end(), comp);
                        return ret;
                }
 
                void sortInPlace() { std::sort(d.begin(), d.end()); }
 
                template <typename Compare> void sortInPlace(Compare comp) { std::sort(d.begin(), d.end(), comp); }
 
                List<T> reverse() const {
                        auto ret = *this;
                        std::reverse(ret.begin(), ret.end());
                        return ret;
                }
 
                List<T> unique() const {
                        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;
                }
 
                Result<size_t> indexOf(const T &value) const {
                        for (size_t i = 0; i < d.size(); ++i) {
                                if (d[i] == value) return makeResult<size_t>(i);
                        }
                        return makeError<size_t>(Error::NotFound);
                }
 
                Result<size_t> lastIndexOf(const T &value) const {
                        for (size_t i = d.size(); i > 0; --i) {
                                size_t idx = i - 1;
                                if (d[idx] == value) return makeResult<size_t>(idx);
                        }
                        return makeError<size_t>(Error::NotFound);
                }
 
                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
 
#endif // PROMEKI_ENABLE_CORE