#ifndef _BOUNDARR_H_
#define _BOUNDARR_H_

/*
 * This class implements an array with user-specified bounds.  Subscripting
 * is done with a at() function, and subscripts are bounds-checked.
 */

#include <iostream>
#include <string>
#include <stdexcept>
#include <memory>
#include <algorithm>

template <typename T>
class BoundArr {
public:
	// Create a new array of the given dimensions
	BoundArr(int low, int high):
		m_space(new T[high-low+1]), m_low(low), m_high(high) { }
	// Note: I think m_space(std::make_shared<T[]>(high-low+1)) should
	// work also, but it blows up with a farily indecipherable memory
	// corruption error.  Seems to be a 2020 standard behavior, so
	// compiler may not have it right yet, or maybe 2020 just breaks
	// everything it touches.

	// Convenience for conventional creation.
	BoundArr(int size): m_space(new T[size]), m_low(0), m_high(size-1) { }

	// Create an array as a copy of another.
	BoundArr(const BoundArr &other) { 
		copyin(other);
	}

	// Perform an array assignment.  Delete our space, then make us a
	// copy of other.
	BoundArr & operator=(const BoundArr &other)
	{
		copyin(other);
		return *this;
	}

	// Find out how large this is.
	int low() const { return m_low; }
	int high() const { return m_high; }
	int size() const { return m_high - m_low + 1; }

	// Subscript the array.  The two versions are allowed, and will
	// be chosen based on the context of use.
	T &at(int subs) { return m_space[offset(subs)]; }
	T const &at(int subs) const { return m_space[offset(subs)]; }
	
	// Print the array to the stream.
	void print(std::ostream &out) const;

private:
	std::shared_ptr<T[]> m_space; // Actual storage space for the array.
	int m_low, m_high;	// Bounds

	// Make us a copy of the other array.  Allocates m_space of
	// the same size, then copies the contents of other.m_size into it,
	// and copies m_size.
	void copyin(const BoundArr<T> &other);

	// Check the bounds, throw if out, then 
	int offset(int sub) const;
};

// Make us a copy of the other array.  Allocates m_space of the same size, then
// copies the contents of other.m_size into it, and copies m_size.
template <typename T>
void BoundArr<T>::copyin(const BoundArr<T> &other)
{
	// The proper way to set m_space is the following, which is C++ 17
	// standard.  It won't compile, even with the relevant compiler option.
	// I believe this is some error in the compiler installation on
	// Fedora, but I don't really know.  The reset and new gets the
	// job done.
	// m_space = std::make_shared<T[]>(other.size());

	// Replace any existing space with a new block
	// having the same size and content as other.
	m_space.reset(new T[other.size()]);
	m_low = other.m_low;
	m_high = other.m_high;
	for(int i = 0; i < size(); ++i) m_space[i] = other.m_space[i];
}

// Check that the sub is in range, and throw if it is not.  Otherwise,
// return the sub adjusted to an offset for subscripting the base array.
template <typename T>
int BoundArr<T>::offset(int sub) const
{
	if(sub < m_low || m_high < sub)
		throw std::range_error("Bounds: sub " + std::to_string(sub) +
				       " outside " + std::to_string(m_low) +
				       ".." + std::to_string(m_high));
	return sub - m_low;
}

// Array printer
template <typename T>
void BoundArr<T>::print(std::ostream &out) const
{
	out << "<" << m_low << "|";
	for(int n = 0; n < size(); ++n) {
		out << " " << m_space[n];
	}
	out << " |" << m_high << ">";
}

// This exports the printing function to standard streams by defining
// the meaning of << on a stream and a BoundArr to be running the print
// method on the array to the stream.
template <typename T>
inline std::ostream & operator<<(std::ostream &strm, const BoundArr<T> &arr) 
{
	arr.print(strm);
	return strm;
}

#endif