//
// Created by Peter Stanko on 8/15/16.
//
#ifndef CUSTOMARRAY_CUSTOMARRAY_H
#define CUSTOMARRAY_CUSTOMARRAY_H
#include <iostream>
#include <array>
namespace pb161 {
	template <typename T, size_t S>
	class CustomArray {
	private:
		std::array<T, S> array{};
	public:
		using size_type = size_t;
		using value_type = T;
		using reference = T&;
		using const_reference = const T&;
		using iterator = typename std::array<T, S>::iterator;
		using const_iterator = typename std::array<T, S>::const_iterator;
		using reverse_iterator = typename std::array<T, S>::reverse_iterator;
		using const_reverse_iterator = typename std::array<T, S>::const_reverse_iterator;
		iterator begin() {
			return array.begin();
		}
		const_iterator begin() const {
			return array.begin();
		}
		iterator end(){
			return array.end();
		}
		const_iterator end() const {
			return array.end();
		}
		reverse_iterator rbegin() {
			return array.rbegin();
		}
		const_reverse_iterator rbegin() const {
			return array.rbegin();
		}
		reverse_iterator rend() {
			return array.rend();
		}
		const_reverse_iterator rend() const {
			return array.rend();
		}
		constexpr bool empty() {
			return array.empty();
		}
		constexpr size_type size() {
			return array.size();
		}
		constexpr size_type size() const {
			return array.size();
		}
		reference front() {
			return array[0];
		}
		const_reference front() const {
			return array[0];
		}
		reference back() {
			return array[S-1];
		}
		const_reference back() const {
			return array[S-1];
		}
		void swap(CustomArray& array) {
			std::swap_ranges(begin(), end(), array.begin());
		}
		reference at(size_type i) {
			return array.at(i);
		}
		const_reference at(size_type i) const {
			return array.at(i);
		}
		reference operator[](size_type i){
			return array[i];
		}
		const_reference operator[](size_type i) const {
			return array[i];
		}
		void fill(const value_type& val) {
			array.fill(val);
		}
		template<class Generator>
		void generate(Generator generator) {
			iterator beginIterator = begin();
			iterator lastIterator = end();
			while (beginIterator != lastIterator) {
				*beginIterator = generator();
				beginIterator = beginIterator+1;
			}
		}
		template<typename X, std::size_t Y>
		friend bool operator==(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
		template<typename X, std::size_t Y>
		friend bool operator!=(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
		template<typename X, std::size_t Y>
		friend bool operator<(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
		template<typename X, std::size_t Y>
		friend bool operator>(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
		template<typename X, std::size_t Y>
		friend bool operator<=(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
		template<typename X, std::size_t Y>
		friend bool operator>=(const CustomArray<X, Y> &first, const CustomArray<X, Y> &second);
	};
	template<class T, std::size_t S>
	void swap(CustomArray<T, S>& first, CustomArray<T, S>& second) {
		std::swap(first, second);
	}
	template<typename T, std::size_t S>
	bool operator==(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return first.array == second.array;
	}
	template<typename T, std::size_t S>
	bool operator<(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return first.array < second.array;
	}
	template<typename T, std::size_t S>
	bool operator>(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return first > second;
	}
	template<typename T, std::size_t S>
	bool operator<=(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return !(first > second);
	}
	template<typename T, std::size_t S>
	bool operator>=(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return !(first < second);
	}
	template<typename T, std::size_t S>
	bool operator!=(const CustomArray<T, S> &first, const CustomArray<T, S> &second) {
		return !(first == second);
	}
}
#endif //CUSTOMARRAY_CUSTOMARRAY_H