list.h

/*
 * Copyright regify
 *
 * 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 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 REGIFY_UTIL_LIST_H
#define REGIFY_UTIL_LIST_H
/* Only need to export C interface if used by C++ source code */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
/*****************************************************************************
*                                                                            *
*  ------------------------ Public List Interface -------------------------  *
*                                                                            *
*****************************************************************************/
typedef void* ruList;
 
typedef void* ruListElmt;
 
typedef void* ruIterator;
 
RUAPI ruList ruListNew(ruType valueType);
 
RUAPI ruList ruListNewBound(ruType valueType, uint32_t maxSize, bool ordered);
 
RUAPI int32_t ruListBind(ruList rl, bool bound);
 
RUAPI ruList ruListFree(ruList rl);
 
RUAPI int32_t ruListClear(ruList rl);
 
RUAPI int32_t ruListAppendPtr(ruList rl, perm_ptr data);
 
#define ruListAppend(rl, data) ruListAppendPtr(rl, (perm_ptr)(data))
 
#define ruListPush(rl, data) ruListAppendPtr(rl, (perm_ptr)(data))
 
RUAPI int32_t ruListInsertIdx(ruList rl, int32_t index, perm_ptr data);
 
RUAPI int32_t ruListInsertBefore(ruList rl, ruListElmt rle, perm_ptr data);
 
RUAPI int32_t ruListInsertAfter(ruList rl, ruListElmt rle, perm_ptr data);
 
RUAPI uint32_t ruListSize(ruList rl, int32_t* code);
 
RUAPI alloc_chars ruListJoin(ruList rl, trans_chars delim, int32_t* code);
 
RUAPI int32_t ruListSort(ruList rl);
 
RUAPI ptr ruListRemove(ruList rl, ruListElmt* rle, int32_t* code);
 
RUAPI ptr ruListRemoveIdx(ruList rl, int32_t index, int32_t* code);
 
RUAPI ptr ruListPop(ruList rl, int32_t *code);
 
RUAPI ptr ruListTryPop(ruList rl, msec_t timeoutMs, int32_t *code);
 
RUAPI ruListElmt ruListHead(ruList rl, int32_t* code);
 
#define ruListIter(rl) ruListHead(rl, NULL)
 
RUAPI ruListElmt ruListTail(ruList rl, int32_t* code);
 
RUAPI bool ruListElmtIsHead(ruListElmt re, int32_t* code);
 
RUAPI bool ruListElmtIsTail(ruListElmt re, int32_t* code);
 
RUAPI ruListElmt ruListNextElmt(ruListElmt re, int32_t* code);
 
RUAPI ptr ruListNextData(ruListElmt *re, int32_t* code);
 
#define ruIterNext(re, type) (type) ruListNextData(&(re), NULL)
 
RUAPI ptr ruListIdxData(ruList rl, int32_t index, int32_t* code);
 
#define ruListIdx(rl, index, type, code) (type)ruListIdxData(rl, index, code)
 
RUAPI int32_t ruListRemoveDataTo(ruList rl, ruListElmt* rle, ptr* dest);
 
#define ruListRemoveTo(rl, rle, dest) ruListRemoveDataTo(rl, &(rle), (ptr*)&(dest))
 
RUAPI int32_t ruListRemoveIdxDataTo(ruList rl, int32_t index, ptr* dest);
 
#define ruListRemoveIdxTo(rl, index, dest) ruListRemoveIdxDataTo(rl, index, (ptr*)&(dest))
 
RUAPI int32_t ruListPopDataTo(ruList rl, ptr* dest);
 
#define ruListPopTo(rl, dest) ruListPopDataTo(rl, (ptr*)&(dest))
 
RUAPI int32_t ruListTryPopDataTo(ruList rl, msec_t timeoutMs, ptr* dest);
 
#define ruListTryPopTo(rl, timeoutMs, dest) ruListTryPopDataTo(rl, timeoutMs, (ptr*)&(dest))
 
RUAPI int32_t ruListNextDataTo(ruListElmt *re, ptr* dest);
 
#define ruIterTo(re, dest) ruListNextDataTo(&(re), (ptr*)&(dest))
 
RUAPI int32_t ruListIdxDataTo(ruList rl, int32_t index, ptr* dest);
 
#define ruListIdxTo(rl, index, dest) ruListIdxDataTo(rl, index, (ptr*)&(dest))
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif //REGIFY_UTIL_LIST_H