From 770212bc8e09a867cf5e712f7d81d8d226057aff Mon Sep 17 00:00:00 2001
From: cdez <cde@cdezselfhosted.pw>
Date: Wed, 4 Oct 2023 17:25:56 -0700
Subject: [PATCH] "Completed" PA05 (aka don't want to spend anymore time on it)
 +- ArrayDataEngine.c +- IteratorUtility.c +- QueueUtility.c +- StackUtility.c

---
 PA05-1004/ArrayDataEngine.c |  59 ++++++++++++++++++++----------------
 PA05-1004/IteratorUtility.c |  35 ++++++++++++++++-----
 PA05-1004/PA05_Main         | Bin 37624 -> 37624 bytes
 PA05-1004/QueueUtility.c    |  14 +++++----
 PA05-1004/StackUtility.c    |  12 ++++----
 5 files changed, 75 insertions(+), 45 deletions(-)

diff --git a/PA05-1004/ArrayDataEngine.c b/PA05-1004/ArrayDataEngine.c
index 9e6eefd..bf5f7bb 100644
--- a/PA05-1004/ArrayDataEngine.c
+++ b/PA05-1004/ArrayDataEngine.c
@@ -62,16 +62,17 @@ Dependencies: privateCheckForResize, deepCopyData
 void copyDataList( StateArrayType *dest, const StateArrayType src )
 {
     int copyIterator;
-    privateCheckForResize(dest);
+    dest->size = 0;
     // check for resize if the destination capacity is less than source
     if(dest->capacity == src.capacity)
     {
-        dest->size = src.size;
+        privateCheckForResize(dest);
         // if it is, then size the dest to what source was
         // copy the data from source to dest using deepCopy
         for(copyIterator = 0; copyIterator < src.size; copyIterator++)
         {
             deepCopyData(&dest->array[copyIterator], src.array[copyIterator]);
+            dest->size = dest->size + 1;
         }
     }
     // no return, void
@@ -148,7 +149,8 @@ void displayData( const StateArrayType stateData, const char *subTitle )
             // print subtitle (and new line)
         printf("%s\n", subTitle);
             // for loop (iterates through the array data)
-        for(displayIterator = 0; displayIterator < stateData.size; displayIterator++)
+        for(displayIterator = 0; displayIterator < stateData.size; 
+                                                              displayIterator++)
         {
             // print Name,
             printf("%s, ", stateData.array[displayIterator].name);
@@ -239,25 +241,29 @@ bool insertItemAtIndex( StateArrayType *stateData,
                                   StateDataType toBeInserted, int insertIndex )
 {
     int insertIterator;
-    // check for resize
-    privateCheckForResize(stateData);
     // check to see if index is within size
-    if(insertIndex < getListSize(*stateData) && insertIndex >= 0)
+    if(insertIndex <= getListSize(*stateData) && insertIndex >= 0)
     {
+        // check for resize
+        privateCheckForResize(stateData);
         // shift elements right of index to right
-        for(insertIterator = insertIndex; insertIterator < getListSize(*stateData); insertIterator++)
+        for(insertIterator = insertIndex; insertIterator < 
+                                      getListSize(*stateData); insertIterator++)
         {
             // put the element into element + 1
-            stateData->array[insertIterator + 1] = stateData->array[insertIterator];
+            stateData->array[insertIterator + 1] = 
+                                               stateData->array[insertIterator];
         }
         // insert element at index
         stateData->array[insertIndex] = toBeInserted;
+        // increment the size by one
+        stateData->size = stateData->size + 1;
         // return true
         return true;
     }
     // return false
     return false;
-}
+} // Needs to iterate from top to bottom, whatever this means.
 
 /*
 Name: listIsEmpty
@@ -271,14 +277,8 @@ Dependencies: none
 */
 bool listIsEmpty( const StateArrayType array )
 {
-    // check to see if size is equal to 0
-    if(array.size == 0)
-    {
-        // return true since array empty
-        return true;
-    }
-    // return false if not empty
-    return false;
+    // return the check to see if the size is equal to 0
+    return (array.size == 0);
 }
 
 /*
@@ -305,12 +305,15 @@ void privateCheckForResize( StateArrayType *stateData )
         // 'create' bigger array
         stateData->capacity = stateData->capacity * 2;
         // allocate the bigger array
-        biggerStateArray = (StateDataType *)malloc(sizeof(StateDataType) * stateData->capacity);
+        biggerStateArray = (StateDataType *)malloc(sizeof(StateDataType) * 
+                                                           stateData->capacity);
         // copy the new array stuff into the old space, use loop
-        for(resizeIterator = 0; resizeIterator < stateData->size; resizeIterator++)
+        for(resizeIterator = 0; resizeIterator < stateData->size; 
+                                                               resizeIterator++)
         {
             // use deep copy to copy the pieces of smaller array
-            deepCopyData(&biggerStateArray[resizeIterator], stateData->array[resizeIterator]);
+            deepCopyData(&biggerStateArray[resizeIterator], 
+                                              stateData->array[resizeIterator]);
         }
         // free the old array
         free(stateData->array);
@@ -341,8 +344,8 @@ void privateCopyString( char *dest, const char *src )
         // iterate the number of characters
         characterCount = characterCount + 1;
     }
-    // add a NULL_CHAR once done. (destStringIterator + 1)
-    dest[characterCount + 1] = NULL_CHAR;
+    // add a NULL_CHAR once done, characterCount is in the right place for \0
+    dest[characterCount] = NULL_CHAR;
     // no return, void
 }
 
@@ -365,21 +368,25 @@ bool removeItemAtIndex( StateArrayType *stateData,
 {
     int removalIterator;
     // check to see if index is within size
-    if(removeIndex < getListSize(*stateData) && removeIndex >= 0)
+    if(removeIndex <= getListSize(*stateData) && removeIndex >= 0)
     {
         // for loop (iterate through list starting at the index)
-        for(removalIterator = removeIndex; removalIterator < getListSize(*stateData); removalIterator++)
+        for(removalIterator = removeIndex; removalIterator < 
+                                 getListSize(*stateData) - 1; removalIterator++)
         {
             // shift the next element to current element.
-            stateData->array[removalIterator] = stateData->array[removalIterator + 1];
+            stateData->array[removalIterator] = 
+                                          stateData->array[removalIterator + 1];
         }
+        // decrement the size of the array
+        stateData->size = stateData->size - 1;
         // return true once done
         return true;
     }
         
     // return false if item not removable?
     return false;
-}
+} // this for loop has potential out of bounds issue.
 
 /*
 Name: setItemToEmpty
diff --git a/PA05-1004/IteratorUtility.c b/PA05-1004/IteratorUtility.c
index 7f88975..beeddf5 100644
--- a/PA05-1004/IteratorUtility.c
+++ b/PA05-1004/IteratorUtility.c
@@ -68,8 +68,10 @@ Dependencies: getItemAtIndex
 */
 bool getFirst( IteratorType *iterator, StateDataType *returned )
 {
+    // set currentIndex to 0
+    iterator->currentIndex = 0;
     // return function true/false if value possible
-    return getItemAtIndex(returned, *iterator->iterData, 0);
+    return getItemAtIndex(returned, *iterator->iterData, iterator->currentIndex);
 }
 
 /*
@@ -85,8 +87,10 @@ Dependencies: getItemAtIndex, getListSize
 */
 bool getLast( IteratorType *iterator, StateDataType *returned )
 {
+    // set currentIndex to getListSize
+    iterator->currentIndex = getListSize(*iterator->iterData);
     // return function to see if possible
-    return getItemAtIndex(returned, *iterator->iterData, getListSize(*iterator->iterData));
+    return getItemAtIndex(returned, *iterator->iterData, iterator->currentIndex);
 }
 
 /*
@@ -106,7 +110,8 @@ bool getNext( IteratorType *iterator, StateDataType *returned )
     if(iterator->currentIndex != getListSize(*iterator->iterData))
     {
         iterator->currentIndex = iterator->currentIndex + 1;
-        return getItemAtIndex(returned, *iterator->iterData, iterator->currentIndex);
+        return getItemAtIndex(returned, *iterator->iterData, 
+                                                        iterator->currentIndex);
     }
     // return false
     return false;
@@ -129,7 +134,8 @@ bool getPrevious( IteratorType *iterator, StateDataType *returned )
     if(iterator->currentIndex != 0)
     {
         iterator->currentIndex = iterator->currentIndex - 1;
-        return getItemAtIndex(returned, *iterator->iterData, iterator->currentIndex);
+        return getItemAtIndex(returned, *iterator->iterData, 
+                                                        iterator->currentIndex);
     }
     // return false
     return false;
@@ -151,7 +157,8 @@ bool insertAfterCurrentIndex( IteratorType *iterator,
                                              const StateDataType toBeInserted )
 {
     // return function true/false based on possibility
-    return insertItemAtIndex(iterator->iterData, toBeInserted, iterator->currentIndex + 1);
+    return insertItemAtIndex(iterator->iterData, toBeInserted, 
+                                                    iterator->currentIndex + 1);
 }
 
 /*
@@ -170,7 +177,8 @@ bool insertAtCurrentIndex( IteratorType *iterator,
                                              const StateDataType toBeInserted )
 {
     // return true/false based on if the function deems worthy
-    return insertItemAtIndex(iterator->iterData, toBeInserted, iterator->currentIndex);
+    return insertItemAtIndex(iterator->iterData, toBeInserted, 
+                                                        iterator->currentIndex);
 }
 
 /*
@@ -188,5 +196,18 @@ Dependencies: removeItemAtIndex, getListSize
 */
 bool removeAtCurrentIndex( IteratorType *iterator, StateDataType *removedItem )
 {
-    return removeItemAtIndex(iterator->iterData, removedItem, iterator->currentIndex);
+    // need to check if the last element is being removed
+    if(iterator->currentIndex == getListSize(*iterator->iterData))
+    {
+        // move the currentIndex back one, 
+        // return removeItemAtIndex with currentIndex + 1
+        iterator->currentIndex = iterator->currentIndex - 1;
+        return removeItemAtIndex(iterator->iterData, removedItem, 
+                                                    iterator->currentIndex + 1);
+        // gives the effect like it removed, 
+            // but doesn't screw up the rest of the program.
+    }
+    // otherwise, remove the item
+    return removeItemAtIndex(iterator->iterData, removedItem, 
+                                                        iterator->currentIndex);
 }
\ No newline at end of file
diff --git a/PA05-1004/PA05_Main b/PA05-1004/PA05_Main
index 13fb3242134fc5e5b783ea7c156b81962f183c63..8670ef56c05883f9abe94d182378900f59f20c27 100755
GIT binary patch
delta 5523
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
TRi?MIU#Mh&!|-6)Ggkix#9?(E

delta 5315
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
F{0C%l#P$FH

diff --git a/PA05-1004/QueueUtility.c b/PA05-1004/QueueUtility.c
index 800195d..b0dd100 100644
--- a/PA05-1004/QueueUtility.c
+++ b/PA05-1004/QueueUtility.c
@@ -64,8 +64,9 @@ Dependencies: getItemAtIndex, getListSize
 */
 bool peekFront( StateDataType *returnVal, const QueueType queue )
 {
-    // return false (TEMP)
-    return false;
+    // use getListSize to get the 'front' value
+    // use getItemAtIndex to 'see' the value at the front.
+    return getItemAtIndex(returnVal, queue, getListSize(queue));
 }
 
 /*
@@ -82,8 +83,9 @@ Dependencies: removeItemAtIndex, getListSize
 */
 bool dequeue( StateDataType *returnVal, QueueType *queue )
 {
-    // return false (TEMP)
-    return false;
+    // get the "front" of the queue
+    // remove the value in the queue and return success/failure
+    return removeItemAtIndex(queue, returnVal, getListSize(*queue));
 }
 
 /*
@@ -99,6 +101,6 @@ Dependencies: insertItemAtIndex
 */
 bool enqueue( QueueType *queue, const StateDataType toBePushed )
 {
-    // return false (TEMP)
-    return false;
+    // return function success/failure based on inputs
+    return insertItemAtIndex(queue, toBePushed, 0);
 }
\ No newline at end of file
diff --git a/PA05-1004/StackUtility.c b/PA05-1004/StackUtility.c
index 359558b..ae97a1a 100644
--- a/PA05-1004/StackUtility.c
+++ b/PA05-1004/StackUtility.c
@@ -63,8 +63,8 @@ Dependencies: getItemAtIndex, getListSize
 */
 bool peekTop( StateDataType *returnVal, const StackType stackData )
 {
-    // return false (TEMP)
-    return false;
+    // return the getItemAtIndex success/failure
+    return getItemAtIndex(returnVal, stackData, getListSize(stackData));
 }
 
 /*
@@ -81,8 +81,8 @@ Dependencies: removeItemAtIndex, getListSize
 */
 bool popStack( StateDataType *returnVal, StackType *stackData )
 {
-    // return false (TEMP)
-    return false;
+    // return function success/failure based on inputs
+    return removeItemAtIndex(stackData, returnVal, getListSize(*stackData));
 }
 
 /*
@@ -98,6 +98,6 @@ Dependencies: insertItemAtIndex, getListSize
 */
 bool pushStack( StackType *stackData, const StateDataType toBePushed )
 {
-    // return false (TEMP)
-    return false;
+    // return function success/failure based on operation
+    return insertItemAtIndex(stackData, toBePushed, getListSize(*stackData));
 }
\ No newline at end of file