188 lines
9.5 KiB
C
188 lines
9.5 KiB
C
/*
|
|
* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
|
|
*
|
|
* This program is free software: you can use, redistribute, and/or modify
|
|
* it under the terms of the GNU Affero General Public License, version 3
|
|
* or later ("AGPL"), as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "talgo.h"
|
|
|
|
#ifndef _TD_UTIL_TARRAY2_H_
|
|
#define _TD_UTIL_TARRAY2_H_
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// a: a
|
|
// e: element
|
|
// ep: element pointer
|
|
// cmp: compare function
|
|
// idx: index
|
|
// cb: callback function
|
|
|
|
#define TARRAY2(TYPE) \
|
|
struct { \
|
|
int32_t size; \
|
|
int32_t capacity; \
|
|
TYPE *data; \
|
|
}
|
|
|
|
typedef void (*TArray2Cb)(void *);
|
|
|
|
#define TARRAY2_SIZE(a) ((a)->size)
|
|
#define TARRAY2_CAPACITY(a) ((a)->capacity)
|
|
#define TARRAY2_DATA(a) ((a)->data)
|
|
#define TARRAY2_GET(a, i) ((a)->data[i])
|
|
#define TARRAY2_GET_PTR(a, i) ((a)->data + i)
|
|
#define TARRAY2_FIRST(a) ((a)->data[0])
|
|
#define TARRAY2_LAST(a) ((a)->data[(a)->size - 1])
|
|
#define TARRAY2_DATA_LEN(a) ((a)->size * sizeof(typeof((a)->data[0])))
|
|
|
|
static FORCE_INLINE int32_t tarray2_make_room( //
|
|
void *arg, // array
|
|
int32_t es, // expected size
|
|
int32_t sz // size of element
|
|
) {
|
|
TARRAY2(void) *a = arg;
|
|
int32_t capacity = (a->capacity > 0) ? (a->capacity << 1) : 32;
|
|
while (capacity < es) {
|
|
capacity <<= 1;
|
|
}
|
|
void *p = taosMemoryRealloc(a->data, capacity * sz);
|
|
if (p == NULL) return TSDB_CODE_OUT_OF_MEMORY;
|
|
a->capacity = capacity;
|
|
a->data = p;
|
|
return 0;
|
|
}
|
|
|
|
#define TARRAY2_INIT_EX(a, size_, capacity_, data_) \
|
|
do { \
|
|
(a)->size = (size_); \
|
|
(a)->capacity = (capacity_); \
|
|
(a)->data = (data_); \
|
|
} while (0)
|
|
|
|
#define TARRAY2_INIT(a) TARRAY2_INIT_EX(a, 0, 0, NULL)
|
|
|
|
#define TARRAY2_CLEAR(a, cb) \
|
|
do { \
|
|
if ((cb) && (a)->size > 0) { \
|
|
TArray2Cb cb_ = (TArray2Cb)(cb); \
|
|
for (int32_t i = 0; i < (a)->size; ++i) { \
|
|
cb_((a)->data + i); \
|
|
} \
|
|
} \
|
|
(a)->size = 0; \
|
|
} while (0)
|
|
|
|
#define TARRAY2_DESTROY(a, cb) \
|
|
do { \
|
|
TARRAY2_CLEAR(a, cb); \
|
|
if ((a)->data) { \
|
|
taosMemoryFree((a)->data); \
|
|
(a)->data = NULL; \
|
|
} \
|
|
(a)->capacity = 0; \
|
|
} while (0)
|
|
|
|
#define TARRAY2_INSERT(a, idx, e) \
|
|
({ \
|
|
int32_t __ret = 0; \
|
|
if ((a)->size >= (a)->capacity) { \
|
|
__ret = tarray2_make_room((a), (a)->size + 1, sizeof(typeof((a)->data[0]))); \
|
|
} \
|
|
if (!__ret) { \
|
|
if ((a)->size > (idx)) { \
|
|
memmove((a)->data + (idx) + 1, (a)->data + (idx), sizeof(typeof((a)->data[0])) * ((a)->size - (idx))); \
|
|
} \
|
|
(a)->data[(idx)] = (e); \
|
|
(a)->size++; \
|
|
} \
|
|
__ret; \
|
|
})
|
|
|
|
#define TARRAY2_INSERT_PTR(a, idx, ep) TARRAY2_INSERT(a, idx, *(ep))
|
|
#define TARRAY2_APPEND(a, e) TARRAY2_INSERT(a, (a)->size, e)
|
|
#define TARRAY2_APPEND_PTR(a, ep) TARRAY2_APPEND(a, *(ep))
|
|
|
|
#define TARRAY2_APPEND_BATCH(a, ep, n) \
|
|
({ \
|
|
int32_t __ret = 0; \
|
|
if ((a)->size + (n) > (a)->capacity) { \
|
|
__ret = tarray2_make_room((a), (a)->size + (n), sizeof(typeof((a)->data[0]))); \
|
|
} \
|
|
if (!__ret) { \
|
|
memcpy((a)->data + (a)->size, (ep), sizeof(typeof((a)->data[0])) * (n)); \
|
|
(a)->size += (n); \
|
|
} \
|
|
__ret; \
|
|
})
|
|
|
|
// return (TYPE *)
|
|
#define TARRAY2_SEARCH(a, ep, cmp, flag) \
|
|
({ \
|
|
typeof((a)->data) __ep = (ep); \
|
|
typeof((a)->data) __p; \
|
|
if ((a)->size > 0) { \
|
|
__p = taosbsearch(__ep, (a)->data, (a)->size, sizeof(typeof((a)->data[0])), (__compar_fn_t)cmp, flag); \
|
|
} else { \
|
|
__p = NULL; \
|
|
} \
|
|
__p; \
|
|
})
|
|
|
|
// return (TYPE)
|
|
#define TARRAY2_SEARCH_EX(a, ep, cmp, flag) \
|
|
({ \
|
|
typeof((a)->data) __p = TARRAY2_SEARCH(a, ep, cmp, flag); \
|
|
__p ? __p[0] : NULL; \
|
|
})
|
|
|
|
#define TARRAY2_SEARCH_IDX(a, ep, cmp, flag) \
|
|
({ \
|
|
typeof((a)->data) __p = TARRAY2_SEARCH(a, ep, cmp, flag); \
|
|
__p ? __p - (a)->data : -1; \
|
|
})
|
|
|
|
#define TARRAY2_SORT_INSERT(a, e, cmp) \
|
|
({ \
|
|
int32_t __idx = TARRAY2_SEARCH_IDX(a, &(e), cmp, TD_GT); \
|
|
TARRAY2_INSERT(a, __idx < 0 ? (a)->size : __idx, e); \
|
|
})
|
|
|
|
#define TARRAY2_SORT_INSERT_P(a, ep, cmp) TARRAY2_SORT_INSERT(a, *(ep), cmp)
|
|
|
|
#define TARRAY2_REMOVE(a, idx, cb) \
|
|
do { \
|
|
if ((idx) < (a)->size) { \
|
|
if (cb) { \
|
|
TArray2Cb cb_ = (TArray2Cb)(cb); \
|
|
cb_((a)->data + (idx)); \
|
|
} \
|
|
if ((idx) < (a)->size - 1) { \
|
|
memmove((a)->data + (idx), (a)->data + (idx) + 1, sizeof(typeof(*(a)->data)) * ((a)->size - (idx)-1)); \
|
|
} \
|
|
(a)->size--; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define TARRAY2_FOREACH(a, e) for (int32_t __i = 0; __i < (a)->size && ((e) = (a)->data[__i], 1); __i++)
|
|
#define TARRAY2_FOREACH_REVERSE(a, e) for (int32_t __i = (a)->size - 1; __i >= 0 && ((e) = (a)->data[__i], 1); __i--)
|
|
#define TARRAY2_FOREACH_PTR(a, ep) for (int32_t __i = 0; __i < (a)->size && ((ep) = &(a)->data[__i], 1); __i++)
|
|
#define TARRAY2_FOREACH_PTR_REVERSE(a, ep) \
|
|
for (int32_t __i = (a)->size - 1; __i >= 0 && ((ep) = &(a)->data[__i], 1); __i--)
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /*_TD_UTIL_TARRAY2_H_*/ |