array.h

Go to the documentation of this file.

/* PipeWire
 *
 * Copyright © 2018 Wim Taymans
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef PIPEWIRE_ARRAY_H
#define PIPEWIRE_ARRAY_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <errno.h>
 
#include <spa/utils/defs.h>
 
struct pw_array {
        void *data;             
        size_t size;            
        size_t alloc;           
        size_t extend;          
};
 
#define PW_ARRAY_INIT(extend) (struct pw_array) { NULL, 0, 0, extend }
 
#define pw_array_get_len_s(a,s)                 ((a)->size / (s))
#define pw_array_get_unchecked_s(a,idx,s,t)     SPA_PTROFF((a)->data,(idx)*(s),t)
#define pw_array_check_index_s(a,idx,s)         ((idx) < pw_array_get_len_s(a,s))
 
#define pw_array_get_len(a,t)                   pw_array_get_len_s(a,sizeof(t))
 
#define pw_array_get_unchecked(a,idx,t)         pw_array_get_unchecked_s(a,idx,sizeof(t),t)
 
#define pw_array_check_index(a,idx,t)           pw_array_check_index_s(a,idx,sizeof(t))
 
#define pw_array_first(a)       ((a)->data)
#define pw_array_end(a)         SPA_PTROFF((a)->data, (a)->size, void)
#define pw_array_check(a,p)     (SPA_PTROFF(p,sizeof(*p),void) <= pw_array_end(a))
 
#define pw_array_for_each(pos, array)                                   \
        for (pos = (__typeof__(pos)) pw_array_first(array);             \
             pw_array_check(array, pos);                                \
             (pos)++)
 
#define pw_array_consume(pos, array)                                    \
        for (pos = (__typeof__(pos)) pw_array_first(array);             \
             pw_array_check(array, pos);                                \
             pos = (__typeof__(pos)) pw_array_first(array))
 
#define pw_array_remove(a,p)                                            \
({                                                                      \
        (a)->size -= sizeof(*(p));                                      \
        memmove(p, SPA_PTROFF((p), sizeof(*(p)), void),                 \
                SPA_PTRDIFF(pw_array_end(a),(p)));                      \
})
 
static inline void pw_array_init(struct pw_array *arr, size_t extend)
{
        arr->data = NULL;
        arr->size = arr->alloc = 0;
        arr->extend = extend;
}
 
static inline void pw_array_clear(struct pw_array *arr)
{
        free(arr->data);
}
 
static inline void pw_array_reset(struct pw_array *arr)
{
        arr->size = 0;
}
 
static inline int pw_array_ensure_size(struct pw_array *arr, size_t size)
{
        size_t alloc, need;
 
        alloc = arr->alloc;
        need = arr->size + size;
 
        if (SPA_UNLIKELY(alloc < need)) {
                void *data;
                alloc = SPA_MAX(alloc, arr->extend);
                spa_assert(alloc != 0); /* forgot pw_array_init */
                while (alloc < need)
                        alloc *= 2;
                if (SPA_UNLIKELY((data = realloc(arr->data, alloc)) == NULL))
                        return -errno;
                arr->data = data;
                arr->alloc = alloc;
        }
        return 0;
}
 
static inline void *pw_array_add(struct pw_array *arr, size_t size)
{
        void *p;
 
        if (pw_array_ensure_size(arr, size) < 0)
                return NULL;
 
        p = SPA_PTROFF(arr->data, arr->size, void);
        arr->size += size;
 
        return p;
}
 
static inline void *pw_array_add_fixed(struct pw_array *arr, size_t size)
{
        void *p;
 
        if (SPA_UNLIKELY(arr->alloc < arr->size + size)) {
                errno = ENOSPC;
                return NULL;
        }
 
        p = SPA_PTROFF(arr->data, arr->size, void);
        arr->size += size;
 
        return p;
}
 
#define pw_array_add_ptr(a,p)                                   \
        *((void**) pw_array_add(a, sizeof(void*))) = (p)
 
#ifdef __cplusplus
}  /* extern "C" */
#endif
 
#endif /* PIPEWIRE_ARRAY_H */