#ifndef _SVECTOR_H_
#define _SVECTOR_H_

// Forward declarations
template <typename T> class svector_iter;
template <typename T> class const_svector_iter;

// *** svector ******************************
template <typename T>
class svector
{
  public:
      // Typedefs for STL compatibility
    typedef T value_type;              // type in the container
    typedef T& reference;              // ref type in container
    typedef const T& const_reference;  // const ref type in container
    typedef svector_iter<T> iterator;  // iterator type for this container
    typedef ptrdiff_t difference_type; // type of diff between iterators
    typedef unsigned int size_type;    // type of sizes in container
    typedef const_svector_iter<T> const_iterator;

    svector();                      
    ~svector();
    void push_back(const_reference value);
    iterator insert(iterator it, const_reference value);
    void clear(void);

    iterator begin(void);
    iterator end(void);
    const_iterator begin(void) const;
    const_iterator end(void) const;
    size_type size(void) const;
  private:
    size_type size_;      // The number of elements in the array
    T* array_;            // The dynamically allocated array
    size_type capacity_;  // The allocated size of the array
    void grow(void);
};

// *** svector_iter ******************************
template <typename T>
class svector_iter
{
  public:
    typedef ptrdiff_t difference_type;
    svector_iter();    // default constructor
    svector_iter(T*);  // conversion constructor
    difference_type operator-(const svector_iter& rhs);
    svector_iter operator+(difference_type rhs);
    T& operator[](difference_type index);
  private:
    T* elem_ptr_;  // A pointer to some element
};

// *** const_svector_iter ******************************
template <typename T>
class const_svector_iter
{
  public:
    typedef ptrdiff_t difference_type;
    const_svector_iter();          // default constructor
    const_svector_iter(const T*);  // conversion constructor
    const T& operator*(void) const;
    const_svector_iter& operator++(void);
    bool operator!=(const const_svector_iter &rhs) const;
  private:
    const T* elem_ptr_;  // A pointer to some element
};

#include "svector.cpp"

#endif