include/lib/Array.h - main - thomas-king/Literals

include/lib/Array.h
205 строк3 KB
AceRodstin
Update libraries.
30 дек 2022, 16:14
30 дек 2022, 16:144e4ae27
//
//  Array.h
//  Libraries
//
//  Created by Ace Rodstin on 24 Nov 2022.
//

#ifndef ARRAY_HEADER_FILE
#define ARRAY_HEADER_FILE


#include <initializer_list>
#include <vector>
#include <algorithm>
#include <optional>

using namespace std;

template<class T>
class Array {
public:
	using Element = T;
	using Container = vector<Element>;
	using SizeType = size_t;
	using Iterator = typename Container::iterator;
	using ReverseIterator = typename Container::reverse_iterator;

	Array() {
		storage = make_unique<Container>();
	};

	Array(initializer_list<Element> elements) {
		storage = make_unique<Container>(elements);
	}

	Array(Container container) {
		storage = make_unique<Container>(container);
	}

	Array(const Array &other) {
		storage = make_unique<Container>();

		for (auto element : other) {
			storage->push_back(element);
		}
	}

	Array& operator=(const Array& other) {
		if (*this == other) {
			return *this;
		} else {
			storage->clear();

			for (auto element : other) {
				storage->push_back(element);
			}

			return *this;
		}
	}

	Element operator[](SizeType index) const {
		return (*storage)[index];
	}

	Array operator[](Range<Iterator> range) const {
		Container container { range.start, range.end };
		return { container };
	}

	bool operator!=(const Array& other) const {
		return !(*this == other);
	}

	bool operator==(const Array& other) const {
		if (count() != other.count()) {
			return false;
		}

		bool isEqual = true;

		for (int i = 0; i < count(); ++i) {
			if ((*this)[i] != other[i]) {
				isEqual = false;
				break;
			}
		}

		return isEqual;
	}

	Iterator begin() const {
		return storage->begin();
	}

	Iterator end() const {
		return storage->end();
	}

	ReverseIterator rbegin() const {
		return storage->rbegin();
	}
	
	ReverseIterator rend() const {
		return storage->rend();
	}

	bool isEmpty() {
		return storage->empty();
	}

	SizeType count() const {
		return storage->size();
	}

	optional<T> first() {
		if (isEmpty()) {
			return {};
		} else {
			return *begin();
		}
	}

	optional<T> last() {
		if (isEmpty()) {
			return {};
		} else {
			return *rbegin();
		}
	}

	void drop_first(SizeType count = 1) {
		auto leading = begin();

		for (SizeType i = 0; i < count; ++i) {	
			++leading;
		}

		Range<Iterator> range { begin(), leading };
		remove(range);
	}

	void drop_last(SizeType count = 1) {
		auto trailing = end();

		for (SizeType i = 0; i < count; ++i) {
			--trailing;
		}

		Range<Iterator> range { trailing, end() };
		remove(range);
	}

	void append(T value) {
		storage->push_back(value);
	}

	T remove(Iterator it) {
		T element = *it;
		storage->erase(it);
		return element;
	}

	void remove(Range<Iterator> range) {
		storage->erase(range.start, range.end);
	}

	bool contains(T value) {
		auto iterator = find(storage->begin(), storage->end(), value);
		return iterator != storage->end();
	}

	template<class V>
	Array<V> map(function<V(T)> transform) {
		Array<V> temp {};

		for (auto element : *storage) {
			V transformed = transform(element);
			temp.append(transformed);
		}

		return temp;
	}

	template<typename V>
	Array<V> compact_map(function<optional<V>(T)> transform) {
		Array<V> temp {};

		for (auto element : *storage) {
			optional<V> transformed = transform(element);

			if (transformed.has_value()) {
				temp.append(transformed.value());
			}
		}

		return temp;
	}

private:
	unique_ptr<Container> storage;
};


#endif