array.hpp

#pragma once
 
#include <functional>
#include <initializer_list>
#include <random>
#include <stdexcept>
#include <vector>
 
#include "arrayLike.hpp"
#include "compare.hpp"
#include "sizable.hpp"
#include "typeChecks.hpp"
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
#include <cereal/archives/json.hpp>
#include <cereal/archives/xml.hpp>
#endif
#endif
 
// Define custom implementation for std::sort and std::shuffle if not available in this C++ version.
#if __cplusplus < 201703L
namespace std {
 
template <typename T>
class vec_iter : public std::vector<T>::iterator {};
 
template <typename T>
void sort(vec_iter<T> _begin, vec_iter<T> _end, std::function<bool(const T &, const T &)> _lambda) noexcept {
    bool swapped = true;
    while (swapped) {
        swapped = false;
        for (auto i = _begin; i != _end - 1; ++i) {
            if (_lambda(*i, *(i + 1))) {
                std::swap(*i, *(i + 1));
                swapped = true;
            }
        }
    }
}
 
template <class _RAIter, class _UGenerator>
void shuffle(_RAIter _begin, _RAIter _end, _UGenerator &&g) {
    for (_RAIter i = _end - 1; i > _begin; --i) {
        std::uniform_int_distribution<std::size_t> d(0, i - _begin);
        std::iter_swap(i, _begin + d(g));
    }
}
 
} // namespace std
#else
// Use std::sort and std::shuffle if available
#include <algorithm>
#endif
 
namespace z {
namespace core {
template <typename T>
class array : public sizable, public arrayLike<const T &, T *> {
protected:
    std::vector<T> array_data;
 
    inline void init(const T &arg1) {
        add(arg1);
    }
 
    template <typename... Args>
    inline void init(const T &arg1, const Args &...args) {
        add(arg1);
        init(args...);
    }
 
    virtual bool eq(const T &arg1, const T &arg2) const {
        return equals(arg1, arg2);
    }
 
    virtual bool gt(const T &arg1, const T &arg2) const {
        return greater(arg1, arg2);
    }
 
    virtual bool lt(const T &arg1, const T &arg2) const {
        return lesser(arg1, arg2);
    }
 
public:
    array() {}
 
    array(const array &other);
 
    array(const std::vector<T> &other);
 
    template <typename... Args>
    array(const T &arg1, const Args &...args);
 
    array(const std::initializer_list<T> &other) : array_data(other) {}
 
    virtual ~array() {}
 
    inline void clear();
 
    void increase(int newSize) noexcept {
        array_data.reserve(newSize);
    }
 
    virtual int add(const T &object) {
        array_data.push_back(object);
 
        return (array_data.size() - 1);
    }
 
    void add(const array &other) noexcept {
        for (int i = 0; i < other.size(); i++) {
            add(other.array_data[i]);
        }
    }
 
    inline int push(const T &object) noexcept {
        return add(object);
    }
 
    inline void push(const array &other) noexcept {
        add(other);
    }
 
    T pop() {
        if (!length()) {
            throw std::out_of_range("No more elements in array.");
        }
 
        T element = at(length() - 1);
        array_data.pop_back();
        return element;
    }
 
    array &insert(const T &, int);
 
    void append(const T &);
 
    array &remove(int);
    array &remove(int, int);
 
    array &replace(int, int, const T &);
    array &replace(int, int, const array<T> &);
 
    array subset(int index, int count) const;
 
    size_t size() const noexcept override;
 
    int length() const noexcept override;
 
    T &at(int);
    const T &at(int) const override;
 
    const T &operator[](int index) const override {
        return at(index);
    }
 
    T &operator[](int index) {
        return at(index);
    }
 
    virtual int find(const T &object) const {
        for (int i = 0; i < (int)array_data.size(); i++) {
            if (eq(array_data.at(i), object)) {
                return i;
            }
        }
 
        return -1;
    }
 
    bool contains(const T &object) const noexcept {
        return find(object) > -1;
    }
 
    void sort() noexcept {
        sort(*this);
    }
 
    void sort(std::function<bool(const T &, const T &)> lambda) noexcept {
        std::sort(array_data.begin(), array_data.end(), lambda);
    }
 
    array sorted() const noexcept {
        auto new_array = *this;
        new_array.sort();
        return new_array;
    }
 
    array sorted(std::function<bool(const T &, const T &)> lambda) const noexcept {
        auto new_array = *this;
        new_array.sort(lambda);
        return new_array;
    }
 
    virtual void shuffle() noexcept {
        // Use std::shuffle if C++17
        std::random_device device;
        std::mt19937 generator(device());
        std::shuffle(array_data.begin(), array_data.end(), generator);
    }
 
    array shuffled() const noexcept {
        auto new_array = *this;
        new_array.shuffle();
        return new_array;
    }
 
    virtual void reverse() noexcept {
        const auto len = length();
        for (int i = 0; i < (len / 2); ++i) {
            std::swap(array_data[i], array_data[len - 1 - i]);
        }
    }
 
    array reversed() const noexcept {
        auto new_array = *this;
        new_array.reverse();
        return new_array;
    }
 
    array &operator=(const array &other);
    array &operator=(const std::initializer_list<T> &other);
 
    bool operator==(const array &other) const;
    bool operator>(const array &other) const;
    bool operator<(const array &other) const;
    inline bool operator!=(const array &other) const;
    inline bool operator>=(const array &other) const;
    inline bool operator<=(const array &other) const;
 
    virtual bool operator()(const T &arg1, const T &arg2) const;
 
    bool isValid(int index) const;
 
    array &swap(int index1, int index2);
 
    template <typename U>
    array<U> map(std::function<U(const T &)> lambda) const;
 
    array filter(std::function<bool(const T &)> lambda) const;
 
    T reduce(const T &defaultValue, std::function<T(const T &, const T &)> lambda) const;
 
    T randomElement() const {
        if (array_data.empty()) {
            throw std::out_of_range("Array is empty");
        }
 
        std::random_device device;
        std::mt19937 generator(device());
        std::uniform_int_distribution<int> distribution(0, array_data.size() - 1);
        return array_data[distribution(generator)];
    }
 
    array randomElements(int count) const noexcept {
        if (array_data.empty()) {
            return array();
        }
 
        std::random_device device;
        std::mt19937 generator(device());
        std::uniform_int_distribution<int> distribution(0, array_data.size() - 1);
 
        const int numElements = std::min(count, length());
 
        array randomArray;
        randomArray.increase(numElements);
        for (int i = 0; i < numElements; ++i) {
            randomArray.push(array_data[distribution(generator)]);
        }
 
        return randomArray;
    }
 
    T *begin() const noexcept override {
        return array_data.empty() ? NULL : (T *)&array_data.front();
    }
 
    T *end() const noexcept override {
        return begin() + array_data.size();
    }
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
    void save(cereal::JSONOutputArchive &ar) const {
        ar.makeArray();
        for (int i = 0; i < (int)array_data.size(); i++) {
            ar(array_data[i]);
        }
    }
 
    void save(cereal::XMLOutputArchive &ar) const {
        for (int i = 0; i < (int)array_data.size(); i++) {
            ar(cereal::make_nvp(std::to_string(i), array_data[i]));
        }
    }
 
    template <typename archive>
    void save(archive &ar) const {
        ar((size_t)array_data.size());
        for (int i = 0; i < (int)array_data.size(); i++) {
            ar(array_data[i]);
        }
    }
 
    void load(cereal::JSONInputArchive &ar) {
        CEREAL_SIZE_TYPE sz;
        ar.loadSize(sz);
        array_data.reserve(sz);
 
        T data;
        for (int i = 0; i < sz; i++) {
            ar(data);
            array_data.push_back(data);
        }
    }
 
    void load(cereal::XMLInputArchive &ar) {
        CEREAL_SIZE_TYPE sz;
        ar.loadSize(sz);
        array_data.reserve(sz);
 
        T data;
        for (CEREAL_SIZE_TYPE i = 0; i < sz; i++) {
            ar(data);
            array_data.push_back(data);
        }
    }
 
    template <class archive>
    void load(archive &ar) {
        clear();
        CEREAL_SIZE_TYPE sz;
        ar(sz);
        array_data.reserve(sz);
 
        T data;
        for (CEREAL_SIZE_TYPE i = 0; i < sz; i++) {
            ar(data);
            array_data.push_back(data);
        }
    }
 
#endif
#endif
};
 
template <typename T>
array<T>::array(const array<T> &other) {
    array_data = other.array_data;
}
 
template <typename T>
array<T>::array(const std::vector<T> &other) {
    array_data = other;
}
 
template <typename T>
template <typename... Args>
array<T>::array(const T &arg1, const Args &...args) {
    init(arg1, args...);
}
 
template <typename T>
array<T> &array<T>::operator=(const array<T> &other) {
    array_data = other.array_data;
 
    return *this;
}
 
template <typename T>
array<T> &array<T>::operator=(const std::initializer_list<T> &other) {
    array_data.clear();
    array_data.reserve(other.size());
    for (auto &item : other) {
        array_data.push_back(item);
    }
 
    return *this;
}
 
template <typename T>
bool array<T>::operator==(const array<T> &other) const {
    if (array_data.size() != other.array_data.size()) {
        return false;
    }
 
    for (int i = 0; i < (int)array_data.size(); i++) {
        if (!eq(array_data.at(i), other.array_data.at(i))) {
            return false;
        }
    }
 
    return true;
}
 
template <typename T>
bool array<T>::operator>(const array<T> &other) const {
    if (array_data.size() != other.array_data.size()) {
        return (array_data.size() > other.array_data.size());
    }
 
    int gt_count = 0;
 
    for (int i = 0; i < (int)array_data.size(); i++) {
        if (gt(array_data.at(i), other.array_data.at(i))) {
            gt_count++;
        } else if (lt(array_data.at(i), other.array_data.at(i))) {
            gt_count--;
        }
    }
 
    return gt_count > 0;
}
 
template <typename T>
bool array<T>::operator<(const array &other) const {
    if (array_data.size() != other.array_data.size()) {
        return (array_data.size() < other.array_data.size());
    }
 
    int gt_count = 0;
 
    for (int i = 0; i < (int)array_data.size(); i++) {
        if (gt(array_data.at(i), other.array_data.at(i))) {
            gt_count++;
        } else if (lt(array_data.at(i), other.array_data.at(i))) {
            gt_count--;
        }
    }
 
    return gt_count < 0;
}
 
template <typename T>
inline bool array<T>::operator!=(const array &other) const {
    return !operator==(other);
}
 
template <typename T>
inline bool array<T>::operator>=(const array &other) const {
    return !operator<(other);
}
 
template <typename T>
inline bool array<T>::operator<=(const array<T> &other) const {
    return !operator>(other);
}
 
template <typename T>
inline void array<T>::clear() {
    array_data.clear();
}
 
template <typename T>
array<T> &array<T>::insert(const T &object, int index) {
    // if index is negative, insert from end of the array.
    if (index < 0) {
        index += array_data.size() + 1;
    }
 
    // keep within bounds of array.
    if (index > (int)array_data.size()) {
        index = array_data.size();
    }
    if (index < 0) {
        index = 0;
    }
 
    array_data.insert(array_data.begin() + index, object);
 
    return *this;
}
 
template <typename T>
void array<T>::append(const T &object) {
    array_data.push_back(object);
}
 
template <typename T>
array<T> &array<T>::remove(int index) {
    if (index < 0) {
        index += array_data.size() + 1;
    }
    if ((index >= array_data.size()) || (index < 0)) {
        return *this;
    }
 
    array_data.erase(array_data.begin() + index);
 
    return *this;
}
 
template <typename T>
array<T> &array<T>::remove(int index, int count) {
    if (!count) {
        return *this;
    }
 
    if (index < 0) {
        index += array_data.size() + 1;
    }
 
    int start, end;
 
    if (count > 0) {
        start = index;
        end = index + count;
    } else {
        start = index + count + 1;
        end = index + 1;
    }
 
    if ((end <= 0) || (start >= (int)array_data.size())) {
        return *this;
    }
    if (start < 0) {
        start = 0;
    }
    if (end > (int)array_data.size()) {
        end = array_data.size();
    }
 
    array_data.erase(array_data.begin() + start, array_data.begin() + end);
 
    return *this;
}
 
template <typename T>
size_t array<T>::size() const noexcept {
    size_t bytes = 0;
    for (auto &item : array_data) {
        size_t objBytes;
        z::core::size(item, objBytes);
        bytes += objBytes;
    }
    return bytes;
}
 
template <typename T>
int array<T>::length() const noexcept {
    return array_data.size();
}
 
template <typename T>
T &array<T>::at(int index) {
    return array_data.at(index);
}
 
template <typename T>
const T &array<T>::at(int index) const {
    return array_data.at(index);
}
 
template <typename T>
array<T> &array<T>::replace(int index, int count, const T &object) {
    if (!count) {
        return *this;
    }
 
    if (index < 0) {
        index += array_data.size() + 1;
    }
 
    int start, end;
 
    if (count > 0) {
        start = index;
        end = index + count;
    } else {
        start = index + count + 1;
        end = index + 1;
    }
 
    if ((end <= 0) || (start >= (int)array_data.size())) {
        return *this;
    }
    if (start < 0) {
        start = 0;
    }
    if (end > (int)array_data.size()) {
        end = array_data.size();
    }
 
    array_data.erase(array_data.begin() + start, array_data.begin() + end);
    array_data.insert(array_data.begin() + start, object);
 
    return *this;
}
 
template <typename T>
array<T> &array<T>::replace(int index, int count, const array<T> &other) {
    if (index < 0) {
        index += array_data.size();
    }
 
    int start, end;
 
    if (count >= 0) {
        start = index;
        end = index + count;
    } else {
        start = index + count + 1;
        end = index + 1;
    }
 
    if ((end <= 0) || (start >= (int)array_data.size())) {
        return *this;
    }
    if (start < 0) {
        start = 0;
    }
    if (end > (int)array_data.size()) {
        end = array_data.size();
    }
 
    if (count) {
        array_data.erase(array_data.begin() + start, array_data.begin() + end);
    }
    array_data.insert(array_data.begin() + start, other.array_data.begin(), other.array_data.end());
 
    return *this;
}
 
template <typename T>
array<T> array<T>::subset(int index, int count) const {
    array<T> output;
 
    if (!count) {
        return *this;
    }
 
    if (index < 0) {
        index += array_data.size() + 1;
    }
 
    int start, end;
 
    if (count > 0) {
        start = index;
        end = index + count;
    } else {
        start = index + count + 1;
        end = index + 1;
    }
 
    if ((end <= 0) || (start >= (int)array_data.size())) {
        return *this;
    }
    if (start < 0) {
        start = 0;
    }
    if (end > (int)array_data.size()) {
        end = array_data.size();
    }
 
    if (end - start > 0) {
        output.array_data.reserve(end - start);
    }
    for (int i = start; i < end; i++) {
        output.array_data.push_back(array_data[i]);
    }
 
    return output;
}
 
template <typename T>
bool array<T>::operator()(const T &arg1, const T &arg2) const {
    return greater(arg1, arg2);
}
 
template <typename T>
bool array<T>::isValid(int index) const {
    if (index < 0) {
        index += array_data.size();
    }
    return (index < (int)array_data.size()) && (index >= 0);
}
 
template <typename T>
array<T> &array<T>::swap(int index1, int index2) {
    auto temp = at(index1);
    array_data[index1] = at(index2);
    array_data[index2] = temp;
    return *this;
}
 
template <typename T>
template <typename U>
array<U> array<T>::map(std::function<U(const T &)> lambda) const {
    array<U> result;
    result.increase(array_data.size());
 
    for (const auto &i : array_data) {
        result.add(lambda(i));
    }
 
    return result;
}
 
template <typename T>
array<T> array<T>::filter(std::function<bool(const T &)> lambda) const {
    array result;
    result.increase(array_data.size()); // Increase it to the max size for performance, but it will likely be smaller than this.
 
    for (const auto &i : array_data) {
        if (lambda(i)) {
            result.add(i);
        }
    }
 
    return result;
}
 
template <typename T>
T array<T>::reduce(const T &defaultValue, std::function<T(const T &, const T &)> lambda) const {
    const auto len = array_data.size();
    if (len == 0) {
        return defaultValue;
    }
 
    auto result = array_data[0];
    for (int i = 1; i < len; ++i) {
        result = lambda(result, array_data[i]);
    }
 
    return result;
}
 
} // namespace core
} // namespace z
 
#define zarray z::core::array