// Course:            CS 141

// Lecture Section:   Enter your lecture section number here (1, 2)
// Lab Section:       Enter your lab section number here (21, 22, 23)
// Assignment #:      1

// First Name:        Enter your FIRST name here (eg, John)
// Last Name:         Enter your LAST name here (eg, Doe)
// ID Number:         Enter your ID number here (eg, 12-345-678)
// Email address:     Enter your UCR email address here (eg, jdoe@cs.ucr.edu)

// =======================================================================

#ifndef _ARRAY_CC
#define _ARRAY_CC

#include <iostream>
#include <strings.h>

#include "Array.h"

// destructor

template <class VALUE>  
Array<VALUE>::~Array() { 
  if (table) 
    delete[] table; 
}

// constructor without default

template <class VALUE>  
Array<VALUE>::Array() {
  use_default = 0;
  table_size = 0;
  max_referenced = -1;
  table = NULL;
}

// constructor with default

template <class VALUE>  
Array<VALUE>::Array(const VALUE& def) {
  use_default = 1;
  default_init = def;
  table_size = 0;
  max_referenced = -1;
  table = NULL;
}


// copy constructor -- defined in Array.h

// clear

template <class VALUE>
void
Array<VALUE>::clear() {
  if (table) {
    delete[] table;
    table_size = 0;
    max_referenced = -1;
    table = NULL;
  }
}

// copy function

template <class VALUE>  
void
Array<VALUE>::copy(const Array<VALUE> & a) {

  if (&a == this) return;

  clear();

  use_default = a.use_default;
  default_init = a.default_init;
  max_referenced = a.max_referenced;
  table_size = a.table_size;

  if (a.table) {
    table = new VALUE[table_size];
    if (!table) { std::cerr << "Out of memory" << std::endl; exit(-1); }
    for (int i = 0;  i < table_size;  ++i) table[i] = a.table[i];
  } 
}


// grow

template <class VALUE>
void
Array<VALUE>::grow() {
  int new_size = 2 * table_size;

  if (table == NULL) new_size = 3;

  VALUE *new_table = new VALUE[new_size];

  if (! new_table) {  std::cerr << "Out of memory" << std::endl;  exit(1); }

  int i;
  for (i = 0;  i < table_size;  ++i)  
    new_table[i] = table[i];

  if (use_default) 
    for (  ;  i < new_size;  ++i)  
      new_table[i] = default_init;

  if (table) delete[] table;
  table = new_table;
  table_size = new_size;
}

// operator[]

template <class VALUE>  
VALUE & 
Array<VALUE>::operator[](int index) {
  if (index < 0) { 
    std::cerr << "Negative index" << std::endl;  
    exit(-1);  
  }

  while (index >= table_size)  grow();
  if (index > max_referenced)  max_referenced = index;

  return table[index];
}

// operator[] const

template <class VALUE>  
VALUE 
Array<VALUE>::operator[](int index) const {
  if (index > max_referenced) { 
    std::cerr << "Array index out of bounds (index = " << index 
	 << ", max_referenced = " << max_referenced << ")" << std::endl;
    exit(-1);
  }
  if (index < 0) { 
    std::cerr << "Negative index" << std::endl;  
    exit(-1);  
  }

  return table[index];
}

// size

template <class VALUE>  
int
Array<VALUE>::size() const { 
  return max_referenced+1;
}


// print

template <class KEY>
std::ostream &
operator<<(std::ostream & out, 
	   const Array<KEY> & a) 
{
  out << "[";
  for (int i = 0;  i < a.size();  ++i) {
    if (i != 0) out << ", ";
    out << a[i];
  }
  out << "]";
  return out;
}

#endif