ValidateVec

Table of Contents

ValidateVec

Description

Validate whether a given Vec object is valid. Not foolproof but will work most of the time. Aborts if provided Vec is not valid.

Parameters

NameDirectionDescription
iinPointer to Vec object to validate.

Success

Continue execution, meaning given Vec object is most probably a valid Vec.

Failure

abort

Usage example (Cross-references)

    /// FAILURE : `abort`
    ///
    #define ValidateStrIters(siv) ValidateVec(siv);
    
    ///
    #define VecForeachIdx(v, var, idx, body)                                                                               \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx            = 0;                                                                                       \
    VEC_DATATYPE(v) var = {0};                                                                                     \
    #define VecForeachReverseIdx(v, var, idx, body)                                                                        \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx            = 0;                                                                                       \
    VEC_DATATYPE(v) var = {0};                                                                                     \
    #define VecForeachPtrIdx(v, var, idx, body)                                                                            \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx             = 0;                                                                                      \
    VEC_DATATYPE(v) *var = NULL;                                                                                   \
    #define VecForeachPtrReverseIdx(v, var, idx, body)                                                                     \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx             = 0;                                                                                      \
    VEC_DATATYPE(v) *var = {0};                                                                                    \
    #define VecForeachInRangeIdx(v, var, idx, start, end, body)                                                            \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx            = 0;                                                                                       \
    VEC_DATATYPE(v) var = {0};                                                                                     \
    #define VecForeachPtrInRangeIdx(v, var, idx, start, end, body)                                                         \
    do {                                                                                                               \
    ValidateVec(v);                                                                                                \
    size idx             = 0;                                                                                      \
    VEC_DATATYPE(v) *var = NULL;                                                                                   \
    
    static inline size vec_aligned_size(GenericVec *v, size item_size) {
    ValidateVec(v);
    
    if (!v->alignment) {
    
    static inline size vec_aligned_offset_at(GenericVec *v, size idx, size item_size) {
    ValidateVec(v);
    
    return idx * vec_aligned_size(v, item_size);
    
    static inline char *vec_ptr_at(GenericVec *v, size idx, size item_size) {
    ValidateVec(v);
    
    return v->data + vec_aligned_offset_at(v, idx, item_size);
    
    void deinit_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);
    
    if (vec->data) {
    
    void clear_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);
    
    if (vec->data) {
    // Reserve new space if n > capacity
    void reserve_vec(GenericVec *vec, size item_size, size n) {
    ValidateVec(vec);
    
    if (n > vec->capacity) {
    
    void reserve_pow2_vec(GenericVec *vec, size item_size, size n) {
    ValidateVec(vec);
    
    size n2 = 1;
    
    void reduce_space_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);
    
    if (vec->length == 0) {
    
    void insert_range_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count) {
    ValidateVec(vec);
    
    if (idx > vec->length) {
    
    void insert_range_fast_into_vec(GenericVec *vec, char *item_data, size item_size, size idx, size count) {
    ValidateVec(vec);
    
    if (idx > vec->length) {
    
    void remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count) {
    ValidateVec(vec);
    
    if (start + count > vec->length) {
    
    void fast_remove_range_vec(GenericVec *vec, void *removed_data, size item_size, size start, size count) {
    ValidateVec(vec);
    
    if (start + count > vec->length) {
    
    void qsort_vec(GenericVec *vec, size item_size, GenericCompare comp) {
    ValidateVec(vec);
    
    if (vec_aligned_size(vec, item_size) != item_size) {
    
    void swap_vec(GenericVec *vec, size item_size, size idx1, size idx2) {
    ValidateVec(vec);
    
    if (idx1 >= vec->length || idx2 >= vec->length) {
    
    void reverse_vec(GenericVec *vec, size item_size) {
    ValidateVec(vec);
    
    size i = vec->length / 2;
    
    void resize_vec(GenericVec *vec, size item_size, size new_size) {
    ValidateVec(vec);
    
    if (new_size <= vec->capacity) {
    
    void ValidateStr(const Str* s) {
    return ValidateVec(s);
    }
    // Test ValidateVec macro
    bool test_vec_validate(void) {
    printf("Testing ValidateVec macro\n");
    
    // Create a valid vector
    
    // This should not abort
    ValidateVec(&vec);
    
    // Clean up
    
    // Validate both vectors
    ValidateVec(&s1);
    ValidateVec(&s2);
    // Validate both vectors
    ValidateVec(&s1);
    ValidateVec(&s2);
    
    // Check that the strings were merged correctly

Share :