vector.c

00001 // Copyright (c) Microsoft. All rights reserved.
00002 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
00003 
00004 #include <stdlib.h>
00005 #ifdef _CRTDBG_MAP_ALLOC
00006 #include <crtdbg.h>
00007 #endif
00008 
00009 #include "azure_c_shared_utility/gballoc.h"
00010 #include "azure_c_shared_utility/vector.h"
00011 
00012 
00013 typedef struct VECTOR_TAG
00014 {
00015     void* storage;
00016     size_t count;
00017     size_t elementSize;
00018 } VECTOR;
00019 
00020 VECTOR_HANDLE VECTOR_create(size_t elementSize)
00021 {
00022     VECTOR_HANDLE result;
00023 
00024     VECTOR* vec = (VECTOR*)malloc(sizeof(VECTOR));
00025     if (vec == NULL)
00026     {
00027         result = NULL;
00028     }
00029     else
00030     {
00031         vec->storage = NULL;
00032         vec->count = 0;
00033         vec->elementSize = elementSize;
00034         result = (VECTOR_HANDLE)vec;
00035     }
00036     return result;
00037 }
00038 
00039 static void internal_VECTOR_clear(VECTOR* vec)
00040 {
00041     if (vec->storage != NULL)
00042     {
00043         free(vec->storage);
00044         vec->storage = NULL;
00045     }
00046     vec->count = 0;
00047 }
00048 
00049 void VECTOR_destroy(VECTOR_HANDLE handle)
00050 {
00051     if (handle != NULL)
00052     {
00053         VECTOR* vec = (VECTOR*)handle;
00054         internal_VECTOR_clear(vec);
00055         free(vec);
00056     }
00057 }
00058 
00059 /* insertion */
00060 int VECTOR_push_back(VECTOR_HANDLE handle, const void* elements, size_t numElements)
00061 {
00062     int result;
00063     if (handle == NULL || elements == NULL || numElements == 0)
00064     {
00065         result = __LINE__;
00066     }
00067     else
00068     {
00069         VECTOR* vec = (VECTOR*)handle;
00070         const size_t curSize = vec->elementSize * vec->count;
00071         const size_t appendSize = vec->elementSize * numElements;
00072 
00073         void* temp = realloc(vec->storage, curSize + appendSize);
00074         if (temp == NULL)
00075         {
00076             result = __LINE__;
00077         }
00078         else
00079         {
00080             memcpy((unsigned char*)temp + curSize, elements, appendSize);
00081             vec->storage = temp;
00082             vec->count += numElements;
00083             result = 0;
00084         }
00085     }
00086     return result;
00087 }
00088 
00089 /* removal */
00090 void VECTOR_erase(VECTOR_HANDLE handle, void* elements, size_t numElements)
00091 {
00092     if (handle != NULL && elements != NULL && numElements > 0)
00093     {
00094         VECTOR* vec = (VECTOR*)handle;
00095         unsigned char* src = (unsigned char*)elements + (vec->elementSize * numElements);
00096         unsigned char* srcEnd = (unsigned char*)vec->storage + (vec->elementSize * vec->count);
00097         (void)memmove(elements, src, srcEnd - src);
00098         vec->count -= numElements;
00099         if (vec->count == 0)
00100         {
00101             free(vec->storage);
00102             vec->storage = NULL;
00103         }
00104         else
00105         {
00106             vec->storage = realloc(vec->storage, (vec->elementSize * vec->count));
00107         }
00108     }
00109 }
00110 
00111 void VECTOR_clear(VECTOR_HANDLE handle)
00112 {
00113     if (handle != NULL)
00114     {
00115         VECTOR* vec = (VECTOR*)handle;
00116         internal_VECTOR_clear(vec);
00117     }
00118 }
00119 
00120 /* access */
00121 
00122 void* VECTOR_element(const VECTOR_HANDLE handle, size_t index)
00123 {
00124     void* result = NULL;
00125     if (handle != NULL)
00126     {
00127         const VECTOR* vec = (const VECTOR*)handle;
00128         if (index < vec->count)
00129         {
00130             result = (unsigned char*)vec->storage + (vec->elementSize * index);
00131         }
00132     }
00133     return result;
00134 }
00135 
00136 void* VECTOR_front(const VECTOR_HANDLE handle)
00137 {
00138     void* result = NULL;
00139     if (handle != NULL)
00140     {
00141         const VECTOR* vec = (const VECTOR*)handle;
00142         result = vec->storage;
00143     }
00144     return result;
00145 }
00146 
00147 void* VECTOR_back(const VECTOR_HANDLE handle)
00148 {
00149     void* result = NULL;
00150     if (handle != NULL)
00151     {
00152         const VECTOR* vec = (const VECTOR*)handle;
00153         result = (unsigned char*)vec->storage + (vec->elementSize * (vec->count - 1));
00154     }
00155     return result;
00156 }
00157 
00158 void* VECTOR_find_if(const VECTOR_HANDLE handle, PREDICATE_FUNCTION pred, const void* value)
00159 {
00160     void* result = NULL;
00161     size_t i;
00162     VECTOR* handleData = (VECTOR*)handle;
00163     if (handle != NULL && pred != NULL && value != NULL)
00164     {
00165         for (i = 0; i < handleData->count; ++i)
00166         {
00167             void* elem = (unsigned char*)handleData->storage + (handleData->elementSize * i);
00168             if (!!pred(elem, value))
00169             {
00170                 result = elem;
00171                 break;
00172             }
00173         }
00174     }
00175     return result;
00176 }
00177 
00178 /* capacity */
00179 
00180 size_t VECTOR_size(const VECTOR_HANDLE handle)
00181 {
00182     size_t result = 0;
00183     if (handle != NULL)
00184     {
00185         const VECTOR* vec = (const VECTOR*)handle;
00186         result = vec->count;
00187     }
00188     return result;
00189 }