Skip to content

VecDeinit

VecDeinit

Description

Deinit vec by freeing all allocations.

Parameters

Name Direction Description
v in,out Pointer to Vec to be deinited

Usage example (from documentation)

  Vec(Model)* models = GetAllModels(...);
  ... // use vector
  DeinitVec(models)

Usage example (Cross-references)

Usage examples (Cross-references)
    void deinit_char_ptr_vec(CharPtrVec *vec) {
        // VecDeinit will automatically call char_ptr_deinit on each element
        VecDeinit(vec);
    }
    
                    VecMerge(vec, &temp);
                    VecDeinit(&temp);
                }
                break;
    
                    VecInitClone(vec, &temp);
                    VecDeinit(&temp);
                }
                break;
    void deinit_str_vec(StrVec *vec) {
        // VecDeinit will automatically call StrDeinit on each element
        VecDeinit(vec);
    }
    
                    VecInsertRange(vec, temp_strings, index, count);
                    VecDeinit(vec);
                }
                break;
    
                    VecPushBackArr(vec, temp_strings, count);
                    VecDeinit(vec);
                }
                break;
    
                    VecPushFrontArr(vec, temp_strings, count);
                    VecDeinit(vec);
                }
                break;
    
                    VecPushFrontArrFast(vec, temp_strings, count);
                    VecDeinit(vec);
                }
                break;
    
                    VecMerge(vec, &temp);
                    VecDeinit(&temp);
                }
                break;
    
                    VecInsertRangeFast(vec, temp_strings, index, count);
                    VecDeinit(vec);
                }
                break;
    
                    VecInitClone(vec, &temp);
                    VecDeinit(&temp);
                }
                break;
    
    void deinit_int_vec(IntVec *vec) {
        VecDeinit(vec);
    }
    
                VecMerge(vec, &temp);
                VecDeinit(&temp); // Clean up temp to prevent memory leak
                break;
            }
    
                VecInitClone(vec, &temp);
                VecDeinit(&temp); // Clean up temp to prevent memory leak
                break;
            }
    
        StrDeinit(&p->build_dir);
        VecDeinit(&p->source_directories);
        VecDeinit(&p->test_directories);
    }
        StrDeinit(&p->build_dir);
        VecDeinit(&p->source_directories);
        VecDeinit(&p->test_directories);
    }
            // recursively explore directories and get files that need documentation
            Strs file_paths = VecInit();
            Scope(&file_paths, VecDeinit, {
                // temporary vector to store all directory paths to explore files in
                Strs dir_paths = VecInitWithDeepCopy(NULL, StrDeinit);
                // temporary vector to store all directory paths to explore files in
                Strs dir_paths = VecInitWithDeepCopy(NULL, StrDeinit);
                Scope(&dir_paths, VecDeinit, {
                    VecMerge(&dir_paths, &project.source_directories);
                    VecMerge(&dir_paths, &project.test_directories);
    
                        SysDirContents dir_contents = SysGetDirContents(dir_name.data);
                        Scope(&dir_contents, VecDeinit, {
                            VecForeach(&dir_contents, dir_entry) {
                                // if it's a directory then store it for exploration later on
            StrDeinit(&e.str);
        };
        VecDeinit(&entries);
    
        LogDeinit();
            }
    
            VecDeinit(&lines);
            VecDeinit(&file);
        } else {
    
            VecDeinit(&lines);
            VecDeinit(&file);
        } else {
            LOG_ERROR("Failed to read file");
        StrDeinit(&result->binary_name);
        StrDeinit(&result->sha256);
        VecDeinit(&result->tags);
        StrDeinit(&result->created_at);
        StrDeinit(&result->model_name);
        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&functions);
        return success;
    }
    
    StrDeinit(&json);
    VecDeinit(&symbols);
    return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);
        StrDeinit(&json);
        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);
        return success;
        VecDeinit(&numbers);
        VecDeinit(&strings);
        VecDeinit(&booleans);
        return success;
    }
    void SimpleProductDeinit(SimpleProduct *product) {
        StrDeinit(&product->name);
        VecDeinit(&product->tags);
    }
    
        StrDeinit(&json);
        VecDeinit(&languages);
        return success;
    }
            StrDeinit(&tag);
        }
        VecDeinit(&result->tags);
        StrDeinit(&result->created_at);
        StrDeinit(&result->model_name);
    
        StrDeinit(&json);
        VecDeinit(&symbols);
        return success;
    }
        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        return success;
    }
        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        return success;
    }
        StrDeinit(&json);
        StrDeinit(&response.message);
        VecDeinit(&response.data);
        return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        return success;
        StrDeinit(&json);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&empty_list);
        return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&empty_arr);
        VecDeinit(&filled_arr);
        return success;
        StrDeinit(&json);
        VecDeinit(&empty_arr);
        VecDeinit(&filled_arr);
        return success;
    }
    void SimpleProductDeinit(SimpleProduct *product) {
        StrDeinit(&product->name);
        VecDeinit(&product->tags);
    }
    
        StrDeinit(&json);
        VecDeinit(&languages);
        return success;
    }
    void TestConfigDeinit(TestConfig *config) {
        StrDeinit(&config->log_level);
        VecDeinit(&config->features);
    }
        TestPersonDeinit(&data->user);
        TestConfigDeinit(&data->config);
        VecDeinit(&data->numbers);
        VecDeinit(&data->flags);
    }
        TestConfigDeinit(&data->config);
        VecDeinit(&data->numbers);
        VecDeinit(&data->flags);
    }
        // Cleanup
        StrDeinit(&json);
        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        StrDeinit(&json);
        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        VecDeinit(&original_numbers);
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        return success;
        VecDeinit(&original_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        return success;
    }
        StrDeinit(&empty_str);
        StrDeinit(&parsed_str);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        StrDeinit(&parsed_str);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        VecDeinit(&empty_numbers);
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        return success;
        VecDeinit(&empty_strings);
        VecDeinit(&parsed_numbers);
        VecDeinit(&parsed_strings);
        return success;
    }
    void EdgeCaseDataDeinit(EdgeCaseData *data) {
        StrDeinit(&data->empty_string);
        VecDeinit(&data->empty_array);
        VecDeinit(&data->numbers);
    }
        StrDeinit(&data->empty_string);
        VecDeinit(&data->empty_array);
        VecDeinit(&data->numbers);
    }
        StrDeinit(&json1);
        StrDeinit(&json2);
        VecDeinit(&items);
        VecDeinit(&data);
        return success;
        StrDeinit(&json2);
        VecDeinit(&items);
        VecDeinit(&data);
        return success;
    }
    
        StrDeinit(&json);
        VecDeinit(&obj.filled_items);
        return success;
    }
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecPrefixMatch(NULL, &vp);
        VecDeinit(&vp);
        return true;
    }
        BitVecPush(VecPtrAt(&vp, 0), true);
        BitVecSuffixMatch(NULL, &vp);
        VecDeinit(&vp);
        return true;
    }
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Test with a vector with alignment > 1
    
        // Clean up
        VecDeinit(&aligned_vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Create a vector with 8-byte alignment
    
        // Clean up
        VecDeinit(&aligned_vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
        }
    
        VecDeinit(&sv); // This should call StrDeinit on each element
        return result;
    }
        bool result = true; // If we got here, the validation didn't crash
    
        VecDeinit(&sv);
        return result;
    }
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Test with struct type
    
        // Clean up
        VecDeinit(&test_vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Test with struct type and 16-byte alignment
    
        // Clean up
        VecDeinit(&test_vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&src);
        VecDeinit(&clone);
        // Clean up
        VecDeinit(&src);
        VecDeinit(&clone);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Test with a struct type
    
        // Clean up
        VecDeinit(&test_vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Note: We can't easily test the negative case (invalid vector)
        }
    
        VecDeinit(&split);
    
        // Test StrSplitToIters
        }
    
        VecDeinit(&iters);
        StrDeinit(&s);
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
            if (iteration_count > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx < 4) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx > 3) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx < 5) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx > vec.length) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
            if (idx > 2) {
                LOG_ERROR("Should've terminated");
                VecDeinit(&vec);
                return false;
            }
    
        // Should never reach here if bounds checking triggers
        VecDeinit(&vec);
        return true;
    }
        // Clean up
        ComplexItemDeinit(&item);
        VecDeinit(&vec);
    
        return result;
        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec);
    
        return result;
        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec);
    
        return result;
        ComplexItemDeinit(&item2);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        ComplexItemDeinit(&item3);
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);
        VecDeinit(&vec2);
        VecDeinit(&vec3);
        VecDeinit(&vec4);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        // Now test VecInsertRangeFastR in isolation
    
        // Clean up
        VecDeinit(&vec2);
    
        return result;
    
        // Clean up this vector
        VecDeinit(&vec);
    
        // Create a new vector for testing fast delete operations
    
        // Clean up
        VecDeinit(&vec);
    
        // Test with an L-value index
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Test with large number of elements
        VecDeinit(&vec);
        vec = VecInitT(vec);
    
        // Test with zero-capacity vector
        VecDeinit(&vec);
        vec = VecInitT(vec);
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up the temporary vector
        VecDeinit(&temp_vec);
    
        return result;
    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;
    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;
    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
    
        return result;
    
        // Clean up the vector
        VecDeinit(&vec);
    
        return result;
        result        = result && (match_idx == 1);
    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        return result;
        result        = result && (match_idx == 1);
    
        VecDeinit(&patterns);
        BitVecDeinit(&source);
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&src);
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&src);
    
        return result;
    
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
        // Clean up
        VecDeinit(&vec1);
        VecDeinit(&vec2);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
    
        return result;
    
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&vec2);
        // Clean up
        VecDeinit(&vec);
        VecDeinit(&vec2);
    
        return result;
    #define VecInitClone(vd, vs)                                                                                           \
        do {                                                                                                               \
            VecDeinit(vd);                                                                                                 \
            VecMerge(vd, vs);                                                                                              \
        } while (0)
Last updated on