// file: InitializerOfArray.hpp

#ifndef INITIALIZER_OF_ARRAY_HPP_
#define INITIALIZER_OF_ARRAY_HPP_

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <vector>

	template <typename T>
	class InitializerOfArray
		// Instantiation condition: T is a comparable type.
	{
		protected:
			virtual T random_item ();

			T	min,
				max;
				
		public: 
			T get_min () {return min;}
			T get_max () {return max;}
			
			virtual void init_random (std::vector<T> & array);
			
			virtual void print (const std::vector<T> & array);
			
			InitializerOfArray (T new_min, T new_max);
	}; // InitializerOfArray
	
	template <typename T>
	T InitializerOfArray<T>::random_item ()
    {
		T result = 
			T((double(std::rand() - 1) / (RAND_MAX - 2)) * (max - min) + min);
		assert(get_min() <= result);							// postcondition
		assert(result <= get_max());							// postcondition
		return result;
	}
	
	template <typename T>
	void InitializerOfArray<T>::init_random (std::vector<T> & array)
	{
		for (int index = 0; index < array.size(); ++index) {
			array[index] = random_item();
		}
	}
	
	template <typename T>
	void InitializerOfArray<T>::print (const std::vector<T> & array)
    {
		std::cout << "[";
		for (int index = 0; index < array.size(); ++index) {
			std::cout << array[index] << " ";
		}
		std::cout << "]" << std::endl;
	}
	
	template <typename T>
	InitializerOfArray<T>::InitializerOfArray (T new_min, T new_max)
    {
		assert(new_min <= new_max);								// precondition
		min = new_min;
		max = new_max;
	}

#endif // INITIALIZER_OF_ARRAY_HPP_