macros.h

Go to the documentation of this file.

 
#ifndef SEEN_MACROS
#define SEEN_MACROS
 
#include "types.h"
#include <string.h>
 
#define cmpVal(a, b) _Generic((a, b), char *       \
                              : charCmp, int *     \
                              : intCmp, float *    \
                              : floatCmp, double * \
                              : doubleCmp, void ** \
                              : ptrCmp)(a, b)
 
#define bubbleSortArr(arr, size) _Generic(arr, char *                 \
                                          : charBubbleSortArr, int *     \
                                          : intBubbleSortArr, float *    \
                                          : floatBubbleSortArr, double * \
                                          : doubleBubbleSortArr, void ** \
                                          : ptrBubbleSortArr)(arr, size)
 
#define quickSortArr(arr, size, ...) _Generic(arr, char *                \
                                         : charQuickSortArr, int *     \
                                         : intQuickSortArr, float *    \
                                         : floatQuickSortArr, double * \
                                         : doubleQuickSortArr, void ** \
                                         : ptrQuickSortArr)(arr, size, ...)
 
#define newALFromArray(arr, size) _Generic(arr, char *                     \
                                           : newALFromCharArray, int *     \
                                           : newALFromIntArray, float *    \
                                           : newALFromFloatArray, double * \
                                           : newALFromDoubleArray, void ** \
                                           : newALFromPtrArray)(arr, size)
 
#define newLLFromArray(arr, size) _Generic(arr, char *                     \
                                           : newLLFromCharArray, int *     \
                                           : newLLFromIntArray, float *    \
                                           : newLLFromFloatArray, double * \
                                           : newLLFromDoubleArray, void ** \
                                           : newLLFromPtrArray)(arr, size)
 
#define newStackFromArray(arr, size) _Generic(arr, char *                        \
                                              : newStackFromCharArray, int *     \
                                              : newStackFromIntArray, float *    \
                                              : newStackFromFloatArray, double * \
                                              : newStackFromDoubleArray, void ** \
                                              : newStackFromPtrArray)(arr, size)
 
#define newQueueFromArray(arr, size) _Generic(arr, char *                        \
                                              : newQueueFromCharArray, int *     \
                                              : newQueueFromIntArray, float *    \
                                              : newQueueFromFloatArray, double * \
                                              : newQueueFromDoubleArray, void ** \
                                              : newQueueFromPtrArray)(arr, size)
 
#define newStackFromArray(arr, size) _Generic(arr, char *                        \
                                              : newStackFromCharArray, int *     \
                                              : newStackFromIntArray, float *    \
                                              : newStackFromFloatArray, double * \
                                              : newStackFromDoubleArray, void ** \
                                              : newStackFromPtrArray)(arr, size)
 
#define print(spec, collection) _Generic(collection, ArrayList       \
                                   : printAL, LinkedList \
                                   : printLL, Stack      \
                                   : printStack, Queue   \
                                   : printQueue)(spec, collection)
 
#define areEqual(collection1, collection2) _Generic(collection1, ArrayList         \
                                        : areALEqual, LinkedList \
                                        : areLLEqual, Stack      \
                                        : areStacksEqual, Queue  \
                                        : areQueuesEqual)(collection1, collection2)
 
#define append(list, item) _Generic(list, ArrayList          \
                                    : appendToAL, LinkedList \
                                    : appendToLL)(list, item)
 
#define insert(list, index, item) _Generic(list, ArrayList          \
                                           : insertToAL, LinkedList \
                                           : insertToLL)(list, index, item)
 
#define set(list, index, newItem) _Generic(list, ArrayList         \
                                           : setALItem, LinkedList \
                                           : setLLItem)(list, index, newItem)
 
#define merge(list1, list2) _Generic(list1, ArrayList      \
                                     : mergeAL, LinkedList \
                                     : mergeLL)(list1, list2)
 
#define slice(list, begin, end) _Generic(list, ArrayList       \
                                         : sliceAL, LinkedList \
                                         : sliceLL)(list, begin, end)
 
#define removeItem(list, index) _Generic(list, ArrayList            \
                                         : removeFromAL, LinkedList \
                                         : removeFromLL)(list, index)
 
#define getItem(list, index, dest) _Generic(list, ArrayList         \
                                            : getFromAL, LinkedList \
                                            : getFromLL)(list, index, dest)
 
#define delete(collection) _Generic(collection, ArrayList         \
                               : deleteAL, LinkedList \
                               : deleteLL, Stack      \
                               : deleteStack, Queue   \
                               : deleteQueue)(collection)
 
#define isIn(collection, item) _Generic(collection, ArrayList      \
                                  : isInAL, LinkedList \
                                  : isInLL, Stack      \
                                  : isInStack, Queue   \
                                  : isInQueue)(collection, item)
 
#define getLength(collection) _Generic(collection, ArrayList           \
                                 : getALLength, LinkedList \
                                 : getLLLength, Stack      \
                                 : getStackLength, Queue   \
                                 : getQueueLength, string  \
                                 : strlen)(collection)
 
#define linearSearch(list, key) _Generic(list, ArrayList              \
                                         : linearSearchAL, LinkedList \
                                         : linearSearchLL)(list, key)
 
#define deleteHead(collection) _Generic(list, Stack                  \
                                  : deleteHeadFromStack, Queue \
                                  : deleteHeadFromQueue)(collection)
 
#define isEmpty(collection) _Generic(collection, ArrayList         \
                               : isALEmpty, LinkedList \
                               : isLLEmpty, Stack      \
                               : isStackEmpty, Queue   \
                               : isQueueEmpty)(collection, item)
 
#define peek(collection, dest) _Generic(list, Stack                   \
                                         : peekStack, Queue \
                                         : peekQueue)(collection)
#endif