Changeset 03daabd in mainline for uspace/lib/c/include/adt/array.h


Ignore:
Timestamp:
2019-10-06T19:47:36Z (5 years ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
5be6361
Parents:
9559cf8
git-author:
Matthieu Riolo <matthieu.riolo@…> (2019-09-17 07:50:03)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2019-10-06 19:47:36)
Message:

Renaming dyn_array to array

The term dyn_array is redunant and has therefore been replaced
with the shorter term array

File:
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/include/adt/array.h

    r9559cf8 r03daabd  
    3333 */
    3434
    35 #ifndef LIBC_DYN_ARRAY_H_
    36 #define LIBC_DYN_ARRAY_H_
     35#ifndef LIBC_ARRAY_H_
     36#define LIBC_ARRAY_H_
    3737
    3838#include <errno.h>
    … …  
    5050        /** No. of items in the array */
    5151        size_t size;
    52 } dyn_array_t;
     52} array_t;
    5353
    5454/** Initialize dynamic array
    … …  
    5858 * @return void
    5959 */
    60 #define dyn_array_initialize(dyn_array, type)                                  \
    61         _dyn_array_initialize((dyn_array), sizeof(type))
     60#define array_initialize(array, type)                                  \
     61        _array_initialize((array), sizeof(type))
    6262
    6363/** Dynamic array accessor
    … …  
    6565 * @return lvalue for the given item
    6666 */
    67 #define dyn_array_at(dyn_array, type, index)                                   \
    68         (*((type *) (dyn_array)->_data + index))
     67#define array_at(array, type, index)                                   \
     68        (*((type *) (array)->_data + index))
    6969
    7070/** Access last element
    … …  
    7272 * @return lvalue for the last item
    7373 */
    74 #define dyn_array_last(dyn_array, type)                                        \
    75         (*((type *) (dyn_array)->_data + ((dyn_array)->size - 1)))
     74#define array_last(array, type)                                        \
     75        (*((type *) (array)->_data + ((array)->size - 1)))
    7676
    7777/** Insert item at given position, shift rest of array
    … …  
    8080 * @return ENOMEM on failure
    8181 */
    82 #define dyn_array_insert(dyn_array, type, index, value)                        \
    83 ({                                                                             \
    84         size_t _index = (index);                                               \
    85         dyn_array_t *_da = (dyn_array);                                        \
    86         errno_t rc = dyn_array_reserve(_da, _da->size + 1);                        \
    87         if (!rc) {                                                             \
    88                 _dyn_array_shift(_da, _index, 1);                              \
    89                 dyn_array_at(_da, type, _index) = (value);                     \
    90         }                                                                      \
    91         rc;                                                                    \
     82#define array_insert(array, type, index, value)                        \
     83({                                                                     \
     84        size_t _index = (index);                                           \
     85        array_t *_da = (array);                                            \
     86        errno_t rc = array_reserve(_da, _da->size + 1);                    \
     87        if (!rc) {                                                         \
     88                _array_shift(_da, _index, 1);                                  \
     89                array_at(_da, type, _index) = (value);                     \
     90        }                                                                  \
     91        rc;                                                                \
    9292})
    9393
    … …  
    9797 * @return ENOMEM on failure
    9898 */
    99 #define dyn_array_append(dyn_array, type, value)                               \
    100         dyn_array_insert(dyn_array, type, (dyn_array)->size, (value))
     99#define array_append(array, type, value)                               \
     100        array_insert(array, type, (array)->size, (value))
    101101
    102102/** Dynamic array iteration
    103103 *
    104  * @param[in]  dyn_array   dyn_array_t (not pointer)
    105  * @param[in]  it          name of variable used as iterator, it's pointer
    106  *                         to @p type
     104 * @param[in]  array   array_t (not pointer)
     105 * @param[in]  it      name of variable used as iterator, it's pointer
     106 *                     to @p type
    107107 */
    108 #define dyn_array_foreach(dyn_array, type, it)                                 \
    109         for (type *it = NULL; it == NULL; it = (type *)1)                      \
    110             for (type *_it = (type *)(dyn_array)._data;                        \
    111             it = _it, _it != ((type *)(dyn_array)._data + (dyn_array).size);   \
     108#define array_foreach(array, type, it)                                 \
     109        for (type *it = NULL; it == NULL; it = (type *)1)                  \
     110            for (type *_it = (type *)(array)._data;                        \
     111            it = _it, _it != ((type *)(array)._data + (array).size);       \
    112112            ++_it)
    113113
    114114/** Find first occurence of value
    115115 *
    116  * @param[in]  dyn_array   dyn_array_t *
     116 * @param[in]  array   array_t *
    117117 * @param[in]  value       value to search for
    118118 *
    119119 * @return  index of found value or size of array when no found
    120120 */
    121 #define dyn_array_find(dyn_array, type, value)                                 \
    122 ({                                                                             \
    123         size_t _result = (dyn_array)->size;                                    \
    124         dyn_array_foreach(*(dyn_array), type, _it) {                           \
     121#define array_find(array, type, value)                                 \
     122({                                                                     \
     123        size_t _result = (array)->size;                                    \
     124        array_foreach(*(array), type, _it) {                               \
    125125                if (*_it == value) {                                           \
    126                         _result = _it - (type *)(dyn_array)->_data;            \
    127                         break;                                                 \
     126                        _result = _it - (type *)(array)->_data;                    \
     127                        break;                                                     \
    128128                }                                                              \
    129         }                                                                      \
    130         _result;                                                               \
     129        }                                                                  \
     130        _result;                                                           \
    131131})
    132132
    133 extern void dyn_array_destroy(dyn_array_t *);
    134 extern void dyn_array_remove(dyn_array_t *, size_t);
    135 void dyn_array_clear(dyn_array_t *);
    136 void dyn_array_clear_range(dyn_array_t *, size_t, size_t);
    137 extern errno_t dyn_array_concat(dyn_array_t *, dyn_array_t *);
    138 extern errno_t dyn_array_reserve(dyn_array_t *, size_t);
     133extern void array_destroy(array_t *);
     134extern void array_remove(array_t *, size_t);
     135void array_clear(array_t *);
     136void array_clear_range(array_t *, size_t, size_t);
     137extern errno_t array_concat(array_t *, array_t *);
     138extern errno_t array_reserve(array_t *, size_t);
    139139
    140 extern void _dyn_array_initialize(dyn_array_t *, size_t);
    141 extern void _dyn_array_shift(dyn_array_t *, size_t, size_t);
    142 extern void _dyn_array_unshift(dyn_array_t *, size_t, size_t);
     140extern void _array_initialize(array_t *, size_t);
     141extern void _array_shift(array_t *, size_t, size_t);
     142extern void _array_unshift(array_t *, size_t, size_t);
    143143
    144144#endif
Note: See TracChangeset for help on using the changeset viewer.