Line data    Source code

       1             : /**
       2             :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3             :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4             :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5             :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6             :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7             :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8             :  * See LICENSE in the root of the software repository for the full text of the License.
       9             :  */
      10             : #include "securec.h"
      11             : #include "mmpa_api.h"
      12             : #include "vector.h"
      13             : #ifdef __cplusplus
      14             : extern "C" {
      15             : #endif
      16             : #define VECTOR_BASIC_SIZE 0
      17             : #define VECTOR_BASIC_STEP 8
      18             : #define VECTOR_MAX_AREA 0x80000000U
      19             : 
      20           1 : void InitVector(Vector *vector, size_t itemSize)
      21             : {
      22           1 :     vector->itemSize = itemSize;
      23           1 :     vector->size = 0;
      24           1 :     vector->capacity = 0;
      25           1 :     vector->data = NULL;
      26           1 :     vector->pfnDestroyItem = NULL;
      27           1 : }
      28             : 
      29           1 : void ClearVector(Vector *vector)
      30             : {
      31           1 :     if (vector->pfnDestroyItem != NULL) {
      32           2 :         for (size_t i = 0; i < vector->size; i++) {
      33           1 :             vector->pfnDestroyItem(VectorAt(vector, i));
      34             :         }
      35             :     }
      36           1 :     vector->size = 0;
      37           1 : }
      38             : 
      39           0 : void DeInitVector(Vector *vector)
      40             : {
      41           0 :     ClearVector(vector);
      42           0 :     if (vector->data != NULL) {
      43           0 :         mmFree(vector->data);
      44             :     }
      45           0 :     InitVector(vector, 0);
      46           0 : }
      47             : 
      48           0 : Vector *CreateVector(size_t itemSize)
      49             : {
      50           0 :     Vector *vector = (Vector *)mmMalloc(sizeof(Vector));
      51           0 :     if (vector == NULL) {
      52           0 :         return NULL;
      53             :     }
      54           0 :     InitVector(vector, itemSize);
      55           0 :     return vector;
      56             : }
      57             : 
      58           0 : void DestroyVector(Vector *vector)
      59             : {
      60           0 :     DeInitVector(vector);
      61           0 :     mmFree(vector);
      62           0 : }
      63             : 
      64           0 : void MoveVector(Vector *src, Vector *desc)
      65             : {
      66           0 :     desc->capacity = src->capacity;
      67           0 :     desc->data = src->data;
      68           0 :     desc->itemSize = src->itemSize;
      69           0 :     desc->pfnDestroyItem = src->pfnDestroyItem;
      70           0 :     desc->size = src->size;
      71           0 :     InitVector(src, 0);
      72           0 : }
      73             : 
      74           1 : size_t CapacityVector(Vector *vector, size_t capacity)
      75             : {
      76           1 :     if (vector->capacity >= capacity) {
      77           0 :         return vector->capacity;
      78             :     }
      79             : 
      80           1 :     size_t maxCapacity = VECTOR_MAX_AREA / vector->itemSize;
      81           1 :     if (vector->capacity >= maxCapacity) {
      82           0 :         return vector->capacity;
      83             :     }
      84             : 
      85           1 :     size_t validCapacity = (capacity >= maxCapacity) ? maxCapacity : capacity;
      86           1 :     size_t areaSize = validCapacity * vector->itemSize;
      87           1 :     uint8_t *data = (uint8_t *)mmMalloc(areaSize);
      88           1 :     if (data == NULL) {
      89           0 :         return vector->capacity;
      90             :     }
      91             : 
      92           1 :     if ((vector->data != NULL) && (vector->size != 0) && (vector->itemSize != 0)) {
      93           0 :         errno_t ret = memcpy_s(data, areaSize, vector->data, vector->itemSize * vector->size);
      94           0 :         if (ret != 0) {
      95           0 :             mmFree(data);
      96           0 :             return vector->capacity;
      97             :         }
      98           0 :         mmFree(vector->data);
      99             :     }
     100             : 
     101           1 :     vector->data = data;
     102           1 :     vector->capacity = validCapacity;
     103           1 :     return validCapacity;
     104             : }
     105             : 
     106           0 : size_t ReSizeVector(Vector *vector, size_t size)
     107             : {
     108           0 :     if (size > vector->capacity) {
     109           0 :         (void)CapacityVector(vector, size);
     110           0 :         if (size > vector->capacity) {
     111           0 :             return vector->size;
     112             :         }
     113             :     }
     114             : 
     115           0 :     if (size > vector->size) {
     116           0 :         vector->size = size;
     117             :     }
     118           0 :     return vector->size;
     119             : }
     120             : 
     121           1 : void *EmplaceVector(Vector *vector, size_t index, void *data)
     122             : {
     123           1 :     if (vector->size == vector->capacity) {
     124             :         size_t capacity =
     125           1 :             CapacityVector(vector, ((vector->capacity + VECTOR_BASIC_STEP) / VECTOR_BASIC_STEP) * VECTOR_BASIC_STEP);
     126           1 :         if (capacity <= vector->size) {
     127           0 :             return NULL;
     128             :         }
     129             :     }
     130             : 
     131           1 :     if (index > vector->size) {
     132           0 :         return NULL;
     133             :     }
     134             : 
     135           1 :     uint8_t *itemData = vector->data + (index * vector->itemSize);
     136             :     errno_t ret;
     137           1 :     if (index < vector->size) {
     138           0 :         size_t mvArea = (vector->size - index) * vector->itemSize;
     139           0 :         ret = memmove_s(itemData + vector->itemSize, mvArea, itemData, mvArea);
     140           0 :         if (ret != 0) {
     141           0 :             return NULL;
     142             :         }
     143             :     }
     144           1 :     ret = memcpy_s(itemData, vector->itemSize, data, vector->itemSize);
     145           1 :     if (ret != 0) {
     146           0 :         return NULL;
     147             :     }
     148           1 :     vector->size++;
     149           1 :     return itemData;
     150             : }
     151             : 
     152           1 : void *EmplaceBackVector(Vector *vector, void *data)
     153             : {
     154           1 :     return EmplaceVector(vector, vector->size, data);
     155             : }
     156             : 
     157           0 : void *EmplaceHeadVector(Vector *vector, void *data)
     158             : {
     159           0 :     return EmplaceVector(vector, 0, data);
     160             : }
     161             : 
     162           0 : void RemoveVector(Vector *vector, size_t index)
     163             : {
     164           0 :     if (index >= vector->size) {
     165           0 :         return;
     166             :     }
     167             : 
     168           0 :     uint8_t *itemData = vector->data + (index * vector->itemSize);
     169           0 :     if (vector->pfnDestroyItem != NULL) {
     170           0 :         vector->pfnDestroyItem(itemData);
     171             :     }
     172             : 
     173           0 :     if ((index + 1) < vector->size) {
     174           0 :         size_t mvArea = (vector->size - index - 1) * vector->itemSize;
     175           0 :         errno_t ret = memmove_s(itemData, mvArea, itemData + vector->itemSize, mvArea);
     176           0 :         if (ret != 0) {
     177           0 :             return;
     178             :         }
     179             :     }
     180             : 
     181           0 :     vector->size--;
     182             :     // free memory when no data
     183           0 :     if ((vector->size == 0) && (vector->capacity != 0)) {
     184           0 :          mmFree(vector->data);
     185           0 :          vector->data = NULL;
     186           0 :          vector->capacity = 0;
     187             :     }
     188           0 :     return;
     189             : }
     190             : 
     191           4 : void *VectorAt(Vector *vector, size_t index)
     192             : {
     193           4 :     if (index >= vector->size) {
     194           0 :         return NULL;
     195             :     }
     196           4 :     return vector->data + (index * vector->itemSize);
     197             : }
     198             : 
     199           0 : const void *ConstVectorAt(const Vector *vector, size_t index)
     200             : {
     201           0 :     if (index >= vector->size) {
     202           0 :         return NULL;
     203             :     }
     204           0 :     return vector->data + (index * vector->itemSize);
     205             : }
     206             : 
     207             : #ifdef __cplusplus
     208             : }
     209             : #endif