klips/cpp/datastructs/templates/vector/vector.h

/*#############################################################################
## Author: Shaun Reed                                                        ##
## Legal: All Content (c) 2020 Shaun Reed, all rights reserved               ##
## About: An example of a vector implementation using templates              ##
##                                                                           ##
## Contact: shaunrd0@gmail.com  | URL: www.shaunreed.com | GitHub: shaunrd0  ##
##############################################################################
## vector.h
*/

#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>
#include <string>


#define TYPE std::string

template <typename T>
class Vector {
  public:
    Vector() : maxSize(0), curIndex(-1), data(NULL) {};
    Vector(const Vector& rhs);
    Vector<T> operator=(Vector<T> rhs);
    ~Vector();
    bool push(T val);
    T pop();
    void makeEmpty();
    T peek() const;
    bool isEmpty() const;
    bool isFull() const;
    void print() const;
    int getMax() const;
    int getSize() const;
    int getIndex() const;
    T getValue(int index) const;

  private:
    int maxSize;
    int curIndex;
    T *data;
    bool push(T val, T *&data);
    T pop(T *&data);
    void makeEmpty(T *&data);
    T peek(T *data) const;
    void print(T *data) const;
};


/******************************************************************************
 * Constructors, Destructors, Operators
 *****************************************************************************/

/** copy constructor
 * @brief Construct a new Vector::Vector object from an existing one
 *        Creates a new deep copy of a given Vector
 *
 * @param rhs Vector<T> object
 */
template<typename T>
Vector<T>::Vector(const Vector<T>& rhs)
{
  if (rhs.getIndex() >= 0) {
    curIndex = rhs.getIndex();
    // Avoid copying over unused indices from parent Vector
    maxSize = rhs.getSize();
    data = new T[curIndex+1];
    for (int i = 0; i <= rhs.getIndex(); i++) {
      data[i] = rhs.getValue(i);
    }
  }
  else {
    curIndex = -1;
    maxSize = 0;
    data = NULL;
  }
}

/** operator=
 * @brief Assign two Vector objects equal using copy constr and class destr
 *        Pass the rhs by value to create local copy, swap its contents
 *        Destructor called on previous Vector data at the end of this scope
 *
 * @param rhs Vector object passed by value, creating a local variable
 * @return Vector<T> A deep copy of the rhs Vector object
 */
template<typename T>
Vector<T> Vector<T>::operator=(Vector<T> rhs)
{
  if (this == &rhs) return *this;
  // Swap the pointers, moving the previous head data to the local variable rhs
  std::swap(data, rhs.data);
  curIndex = rhs.getIndex();
  // Use the current size of the vector we are equal to
  // Avoids copying over unused indices
  maxSize = rhs.getSize();
  return *this;
}

/** destructor
 * @brief Destroy the Vector::Vector object
 */
template<typename T>
Vector<T>::~Vector()
{
  if (!isEmpty()) makeEmpty();
}


/******************************************************************************
 * Public Member Functions
 *****************************************************************************/

/** push
 * @brief Push a value to the end of our Vector
 *
 * @param val The value to be inserted
 */
template<typename T>
bool Vector<T>::push(T val)
{
  bool inserted = push(val, data);
  if (inserted)
    std::cout << "[" << val << "] was inserted into the vector\n";
  else std::cout << "[" << val << "] could not be inserted into the vector\n";
  return inserted;
}

/** pop
 * @brief returns the value at the Vector::data[curIndex] if it exists
 *        Once returned, the curIndex is decremented via data[curIndex--]
 *        If the vector is empty, returns INT32_MIN
 *
 * @return T The value held at the Node pointed to by Vector::data[index]
 */
template<typename T>
T Vector<T>::pop()
{
  T val;
  if (!isEmpty()) {
    val = pop(data);
    std::cout << "[" << val << "] has been popped from our Vector\n";
  }
  else std::cout << "Nothing to pop, our Vector is empty...\n";
  return val;
}

/** makeEmpty
 * @brief Empty this Vector object, deleting all associated data
 */
template<typename T>
void Vector<T>::makeEmpty()
{
  if (isEmpty()) {
    std::cout << "Cannot makeEmpty, our Vector is already empty...\n";
    return;
  }
  else makeEmpty(data);
}

/** peek
 * @brief returns the value at the end of the vector
 *  If the vector is empty, returns INT32_MIN
 *
 * @return T The value held at the current data[index] of the vector
 */
template<typename T>
T Vector<T>::peek() const
{
  T val;
  if (!isEmpty()) {
    val = peek(data);
    std::cout << "[" << peek(data) << "] is at the end of our vector\n";
  }
  else std::cout << "Nothing to peek, our vector is empty...\n";
  return val;
}

/** isEmpty
 * @brief Determine if the Vector is empty
 *
 * @return true If the Vector::data is NULL
 * @return false If the Vector::data contains any values
 */
template<typename T>
bool Vector<T>::isEmpty() const
{
  return data == NULL;
}

/** isFull
 * @brief Determine if the Vector is full
 *
 * @return true If the Vector::size is equal to the current index
 * @return false If the Vector::size is greater than the current index
 */
template<typename T>
bool Vector<T>::isFull() const
{
  return getSize() == getMax() || data == NULL;
}

/** print
 * @brief Output the data held by the Vector object
 *        Calls to the private print()
 */
template<typename T>
void Vector<T>::print() const
{
  if(!isEmpty()) print(data);
  else std::cout << "Nothing to print, our vector is empty...\n";
}

/** getMax
 * @brief Returns the literal maximum size of the vector
 *        Not offset to match any index - Vector with max size 3 has indices 0-2
 *
 * @return int at this->maxSize
 */
template<typename T>
int Vector<T>::getMax() const
{
  return maxSize;
}

/** getSize
 * @brief Returns the current size of the vector
 *        AKA the current number of indices being used, NOT the max indices
 *
 * @return int at this->curIndex + 1
 */
template<typename T>
int Vector<T>::getSize() const
{
  return curIndex + 1;
}

/** getIndex
 * @brief Returns the current index of the vector
 *        AKA the last index the vector wrote to
 *
 * @return int at this->curIndex
 */
template<typename T>
int Vector<T>::getIndex() const
{
  return curIndex;
}

// TODO: use operator[](){...} instead

/** getValue
 * @brief Get the value stored at a given index within the vector
 *
 * @param index The index containing the value to be returned
 * @return T The value held at the index given
 */
template<typename T>
T Vector<T>::getValue(int index) const
{
  return data[index];
}


/******************************************************************************
 * Private Member Functions
 *****************************************************************************/

/** push
 * @brief Private member to handle inserting value into the vector
 *
 * @param val Value to be inserted
 * @param data The data of the vector to push the value into
 *
 * @return true If the value was inserted
 * @return false If the value could not be inserted
 */
template<typename T>
bool Vector<T>::push(T val, T *&data)
{
  T *temp;
  if (isFull()) {
    if (maxSize <= 0) maxSize = 1;
    else maxSize *= 2;
    temp = new T[maxSize];
    for (int i = 0; i <= curIndex; i++) {
      temp[i] = data[i];
    }
    std::swap(data, temp);
  }
  curIndex += 1;
  data[curIndex] = val;
  return data[curIndex] == val;
}

/** pop
 * @brief Returns the value held at the last index within the Vector
 *        Decrements the curIndex after storing the value to be returned
 *
 * @param data The Vector data to modify
 * @return T The value stored at the index removed from the end of the Vector
 */
template<typename T>
T Vector<T>::pop(T *&data)
{
  // We already know the vector is not empty from public pop()
  T val = data[curIndex--];
  if (curIndex < 0) makeEmpty(data);
  return val;
}

/** makeEmpty
 * @brief Private member to empty Vector object, deleting all associated data
 *
 * @param data The data of the Vector to be deleted
 */
template<typename T>
void Vector<T>::makeEmpty(T *&data)
{
  delete[] data;
  maxSize = 0;
  curIndex = -1;
  data = NULL;
}

/** peek
 * @brief Private member to display the value at the end of our Vector
 *
 * @param data The Vector data to peek
 * @return T The value stored at the end of the Vector
 */
template<typename T>
T Vector<T>::peek(T *data) const
{
  // We already know the vector is not empty from public peek()
  return data[curIndex];
}

/** print
 * @brief Output the contents of a Vector from the beginning to the end
 *
 * @param data The data within the Vector to output
 */
template<typename T>
void Vector<T>::print(T *data) const
{
  std::cout << "Vector Contents: ";
  for (int i = 0; i <= curIndex; i++) {
    std::cout << data[i] << " | ";
  }
  std::cout << std::endl;
}


#endif