1. // EXAMPLES : https://pastebin.com/VLCGGW7c
  2. #if defined __C_VECTOR_INCLUDED__
  3.     #endinput
  4. #endif
  5. #define __C_VECTOR_INCLUDED__
  6. #define __C_VECTOR_VERSION__ 0x100
  7.  
  8. #include <YSI_Coding\y_malloc>
  9. #tryinclude <YSI_Data\y_iterate>
  10.  
  11. #define VECTOR_NULL                     (Vector:NO_ALLOC)
  12. #define INVALID_VECTOR_INDEX            (cellmin)
  13.  
  14. enum _:E_VECTOR {
  15.     Alloc:E_VECTOR_DATA,
  16.     E_VECTOR_SIZE
  17. }
  18.  
  19. #if defined _INC_y_iterate
  20.  
  21. iterfunc stock vector(&iterstate, cur, Vector:vector, array[] = cellmin, size = sizeof(array)) {
  22.     #pragma unused cur
  23.     if(array[0] == cellmin) {
  24.         return vector_get_value(vector, iterstate++);
  25.     } else {
  26.         return vector_get_array(vector, iterstate++, array, size);
  27.     }
  28. }
  29. #define iterstart@vector iterstate(INVALID_VECTOR_INDEX, 0)
  30.  
  31. iterfunc stock array(&iterstate, cur, const array[], size, size2 = sizeof(array)) {
  32.     #pragma unused cur
  33.     if(iterstate < size && iterstate < size2) {
  34.         return array[iterstate++];
  35.     }
  36.     return INVALID_VECTOR_INDEX;
  37. }
  38. #define iterstart@array iterstate(INVALID_VECTOR_INDEX, 0)
  39.  
  40. #endif
  41.  
  42. static stock vector_push_back_ptr(&Vector:vector, &Alloc:ptr, size = 0) {
  43.     new
  44.         v[E_VECTOR];
  45.  
  46.     if(vector == VECTOR_NULL) {
  47.         v[E_VECTOR_DATA] = malloc(E_VECTOR, true);
  48.         v[E_VECTOR_SIZE] = E_VECTOR;
  49.         vector = Vector:malloc(E_VECTOR);
  50.     } else {
  51.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  52.         v[E_VECTOR_SIZE] += E_VECTOR;
  53.         new
  54.             Alloc:a = malloc(v[E_VECTOR_SIZE], true);
  55.  
  56.         memcpy(YSI_gMallocMemory[_:a], YSI_gMallocMemory[_:v[E_VECTOR_DATA]], 0, v[E_VECTOR_SIZE]*4, v[E_VECTOR_SIZE]);
  57.         free(v[E_VECTOR_DATA]);
  58.         v[E_VECTOR_DATA] = a;
  59.     }
  60.  
  61.     new
  62.         value_ptr[E_VECTOR];
  63.  
  64.     ptr = value_ptr[E_VECTOR_DATA] = malloc(size, true);
  65.     value_ptr[E_VECTOR_SIZE] = size;
  66.  
  67.     mseta(Alloc:vector, 0, v, E_VECTOR);
  68.     mseta(v[E_VECTOR_DATA], v[E_VECTOR_SIZE] - E_VECTOR, value_ptr, E_VECTOR);
  69. }
  70.  
  71. stock vector_push_back_value(&Vector:vector, value) {
  72.     new
  73.         Alloc:ptr;
  74.  
  75.     vector_push_back_ptr(vector, ptr);
  76.     mset(ptr, 0, value);
  77. }
  78.  
  79. stock vector_push_back_array(&Vector:vector, const array[], size = sizeof(array)) {
  80.     new
  81.         Alloc:ptr;
  82.  
  83.     vector_push_back_ptr(vector, ptr, size);
  84.     mseta(ptr, 0, array, size);
  85. }
  86.  
  87. stock vector_remove(&Vector:vector, index) {
  88.     if(vector != VECTOR_NULL) {
  89.         new
  90.             v[E_VECTOR];
  91.  
  92.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  93.         index *= E_VECTOR;
  94.  
  95.         if(0 <= index < v[E_VECTOR_SIZE]) {
  96.             if(index == 0 && (v[E_VECTOR_SIZE] - E_VECTOR) == 0) {
  97.                 vector_free(vector);
  98.             } else {
  99.                 free(Alloc:mget(v[E_VECTOR_DATA] + Alloc:index, E_VECTOR_DATA));
  100.  
  101.                 for(new i = index, j = index + E_VECTOR, value_ptr[E_VECTOR]; j < v[E_VECTOR_SIZE]; i += E_VECTOR) {
  102.                     mgeta(value_ptr, E_VECTOR, v[E_VECTOR_DATA], j);
  103.                     mseta(v[E_VECTOR_DATA], i, value_ptr, E_VECTOR);
  104.                     j += E_VECTOR;
  105.                 }
  106.  
  107.                 v[E_VECTOR_SIZE] -= E_VECTOR;
  108.  
  109.                 new
  110.                     Alloc:a = malloc(v[E_VECTOR_SIZE], true);
  111.  
  112.                 memcpy(YSI_gMallocMemory[_:a], YSI_gMallocMemory[_:v[E_VECTOR_DATA]], 0, (v[E_VECTOR_SIZE])*4, v[E_VECTOR_SIZE]);
  113.                 free(v[E_VECTOR_DATA]);
  114.                 v[E_VECTOR_DATA] = a;
  115.  
  116.                 mseta(Alloc:vector, 0, v, E_VECTOR);
  117.             }
  118.  
  119.             return true;
  120.         }
  121.     }
  122.  
  123.     return false;
  124. }
  125.  
  126. stock vector_get_value(Vector:vector, index) {
  127.     if(vector != VECTOR_NULL) {
  128.         new
  129.             v[E_VECTOR];
  130.  
  131.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  132.         index *= 2;
  133.  
  134.         if(0 <= index < v[E_VECTOR_SIZE]) {
  135.             return mget(Alloc:mget(v[E_VECTOR_DATA], index), 0);
  136.         }
  137.     }
  138.  
  139.     return INVALID_VECTOR_INDEX;
  140. }
  141.  
  142. stock vector_get_array(Vector:vector, index, array[], size = sizeof(array)) {
  143.     if(vector != VECTOR_NULL) {
  144.         new
  145.             v[E_VECTOR];
  146.  
  147.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  148.         index *= 2;
  149.  
  150.         if(0 <= index < v[E_VECTOR_SIZE]) {
  151.             new
  152.                 ptr[E_VECTOR];
  153.  
  154.             mgeta(ptr, E_VECTOR, v[E_VECTOR_DATA], index);
  155.  
  156.             new
  157.                 n_sz = ((size > ptr[E_VECTOR_SIZE]) ? ptr[E_VECTOR_SIZE] : size);
  158.  
  159.             mgeta(array, n_sz, ptr[E_VECTOR_DATA], 0);
  160.  
  161.             return n_sz;
  162.         }
  163.     }
  164.  
  165.     return INVALID_VECTOR_INDEX;
  166. }
  167.  
  168. stock vector_set_value(Vector:vector, index, value) {
  169.     if(vector != VECTOR_NULL) {
  170.         new
  171.             v[E_VECTOR];
  172.  
  173.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  174.         index *= 2;
  175.  
  176.         if(0 <= index < v[E_VECTOR_SIZE]) {
  177.             mset(Alloc:mget(v[E_VECTOR_DATA], index), 0, value);
  178.         }
  179.     }
  180. }
  181.  
  182. stock vector_set_array(Vector:vector, index, array[], size = sizeof(array)) {
  183.     if(vector != VECTOR_NULL) {
  184.         new
  185.             v[E_VECTOR];
  186.  
  187.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  188.         index *= 2;
  189.  
  190.         if(0 <= index < v[E_VECTOR_SIZE]) {
  191.             new
  192.                 ptr[E_VECTOR];
  193.  
  194.             mgeta(ptr, E_VECTOR, v[E_VECTOR_DATA], index);
  195.             if(size != ptr[E_VECTOR_SIZE]) {
  196.                 free(ptr[E_VECTOR_DATA]);
  197.                 ptr[E_VECTOR_DATA] = malloc(size, true);
  198.                 ptr[E_VECTOR_SIZE] = size;
  199.             }
  200.  
  201.             mseta(ptr[E_VECTOR_DATA], 0, array, size);
  202.             mseta(v[E_VECTOR_DATA], index, ptr, E_VECTOR);
  203.         }
  204.     }
  205. }
  206.  
  207. stock bool:vector_is_storing_array(Vector:vector) {
  208.     if(vector != VECTOR_NULL) {
  209.         return mget(Alloc:mget(Alloc:vector, E_VECTOR_DATA), E_VECTOR_SIZE) != 0;
  210.     }
  211.  
  212.     return false;
  213. }
  214.  
  215. stock vector_free(&Vector:vector) {
  216.     if(vector != VECTOR_NULL) {
  217.         new
  218.             v[E_VECTOR];
  219.    
  220.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  221.  
  222.         for(new i = 0; i < v[E_VECTOR_SIZE]; i += 2) {
  223.             free(Alloc:mget(v[E_VECTOR_DATA], i));
  224.         }
  225.  
  226.         free(v[E_VECTOR_DATA]);
  227.         free(Alloc:vector);
  228.         vector = VECTOR_NULL;
  229.     }
  230. }
  231.  
  232. stock vector_get_array_size(Vector:vector, index) {
  233.     if(vector != VECTOR_NULL) {
  234.         new
  235.             v[E_VECTOR];
  236.  
  237.         mgeta(v, E_VECTOR, Alloc:vector, 0);
  238.         index *= 2;
  239.  
  240.         if(0 <= index < v[E_VECTOR_SIZE]) {
  241.             return mget(Alloc:v[E_VECTOR_DATA], E_VECTOR_SIZE);
  242.         }
  243.     }
  244.  
  245.     return 0;
  246. }
  247.  
  248. stock vector_get_size(Vector:vector) {
  249.     if(vector != VECTOR_NULL) {
  250.         return (mget(Alloc:vector, E_VECTOR_SIZE) / E_VECTOR);
  251.     }
  252.  
  253.     return 0;
  254. }