/*****************************************************************************
|
*
|
* Copyright (c) 2008-2010, CoreCodec, Inc.
|
* All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
* * Redistributions of source code must retain the above copyright
|
* notice, this list of conditions and the following disclaimer.
|
* * Redistributions in binary form must reproduce the above copyright
|
* notice, this list of conditions and the following disclaimer in the
|
* documentation and/or other materials provided with the distribution.
|
* * Neither the name of CoreCodec, Inc. nor the
|
* names of its contributors may be used to endorse or promote products
|
* derived from this software without specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY CoreCodec, Inc. ``AS IS'' AND ANY
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
* DISCLAIMED. IN NO EVENT SHALL CoreCodec, Inc. BE LIABLE FOR ANY
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*
|
****************************************************************************/
|
|
#ifndef __ARRAY_H
|
#define __ARRAY_H
|
|
#include "corec/corec.h"
|
#include "corec/memheap.h"
|
|
#ifdef __cplusplus
|
extern "C" {
|
#endif
|
|
#if defined(ARRAY_EXPORTS)
|
#define ARRAY_DLL DLLEXPORT
|
#elif defined(ARRAY_IMPORTS)
|
#define ARRAY_DLL DLLIMPORT
|
#else
|
#define ARRAY_DLL
|
#endif
|
|
#define Data_Var(type,name,len) struct { size_t n; type p[len]; } __##name; type* name = (__##name.n = sizeof(__##name.p),__##name.p)
|
ARRAY_DLL bool_t Data_ReAlloc(uint8_t** a,size_t n);
|
ARRAY_DLL size_t Data_Size(const uint8_t* a);
|
ARRAY_DLL void Data_Release(uint8_t** a);
|
ARRAY_DLL void Data_Clear(uint8_t** a); // release memory, but keep heap reference
|
ARRAY_DLL bool_t Data_Set(uint8_t** a,const uint8_t* b,size_t pos,size_t len);
|
|
typedef struct array
|
{
|
// these are private members, use ARRAY macros to access them
|
uint8_t* _Begin;
|
uint8_t* _End;
|
|
} array;
|
|
typedef int (*arraycmp)(const void* Param, const void* a,const void* b);
|
|
#define ARRAY_AUTO_COUNT ((size_t)-1)
|
|
static INLINE void ArrayInit(array* p) { p->_Begin = NULL; p->_End = NULL; }
|
ARRAY_DLL void ArrayInitEx(array*,const cc_memheap*);
|
ARRAY_DLL void ArrayClear(array*);
|
ARRAY_DLL void ArrayDrop(array*);
|
ARRAY_DLL size_t ArraySize(const array*);
|
ARRAY_DLL bool_t ArrayEq(const array* a, const array* b);
|
ARRAY_DLL bool_t ArrayCopy(array*,const array* In);
|
ARRAY_DLL bool_t ArrayResize(array*,size_t Size,size_t Align);
|
ARRAY_DLL void ArrayZero(array*);
|
ARRAY_DLL intptr_t ArrayFindEx(const array* p, size_t Count, size_t Width, const void* Data, arraycmp Cmp, const void* CmpParam, bool_t* Found);
|
ARRAY_DLL bool_t ArrayAlloc(array* p,size_t Total,size_t Align);
|
ARRAY_DLL bool_t ArrayAppend(array* p, const void* Ptr, size_t Length, size_t Align);
|
ARRAY_DLL bool_t ArrayAppendStr(array* p, const tchar_t* Ptr, bool_t Merge, size_t Align);
|
ARRAY_DLL void ArrayShrink(array* p, size_t Length);
|
ARRAY_DLL intptr_t ArrayAddEx(array* p, size_t Count, size_t Width, const void* Data, arraycmp Cmp, const void* CmpParam, size_t Align);
|
ARRAY_DLL bool_t ArrayRemoveEx(array* p, size_t Count, size_t Width, const void* Data, arraycmp Cmp, const void* CmpParam);
|
ARRAY_DLL void ArraySortEx(array* p, size_t Count, size_t Width, arraycmp Cmp, const void* CmpParam, bool_t Unique);
|
ARRAY_DLL bool_t ArrayInsert(array* p, size_t Ofs, const void* Ptr, size_t Length, size_t Align);
|
ARRAY_DLL void ArrayDelete(array* p, size_t Ofs, size_t Length);
|
ARRAY_DLL void ArrayRandomize(array* Array,size_t Width,uint32_t RndSeed);
|
|
#define ArrayAdd(p,type,Data,Cmp,CmpParam,Align) ArrayAddEx(p,ARRAYCOUNT(*p,type),sizeof(type),Data,Cmp,CmpParam,Align)
|
#define ArrayRemove(p,type,Data,Cmp,CmpParam) ArrayRemoveEx(p,ARRAYCOUNT(*p,type),sizeof(type),Data,Cmp,CmpParam)
|
#define ArrayFind(p,type,Data,Cmp,CmpParam,Found) ArrayFindEx(p,ARRAYCOUNT(*p,type),sizeof(type),Data,Cmp,CmpParam,Found)
|
#define ArraySort(p,type,Cmp,CmpParam,Unique) ArraySortEx(p,ARRAYCOUNT(*p,type),sizeof(type),Cmp,CmpParam,Unique)
|
|
#ifdef CONFIG_DEBUGCHECKS
|
#define ARRAYBEGIN(Array,Type) (assert(&(Array)!=NULL),(Type*)((Array)._Begin))
|
#define ARRAYEND(Array,Type) (assert(&(Array)!=NULL),(Type*)((Array)._End))
|
#define ARRAYEMPTY(Array) (assert(&(Array)!=NULL),(Array)._Begin==(Array)._End)
|
#else
|
#define ARRAYBEGIN(Array,Type) ((Type*)((Array)._Begin))
|
#define ARRAYEND(Array,Type) ((Type*)((Array)._End))
|
#define ARRAYEMPTY(Array) ((Array)._Begin==(Array)._End)
|
#endif
|
#define ARRAYCOUNT(Array,Type) ((size_t)(ARRAYEND(Array,Type)-ARRAYBEGIN(Array,Type)))
|
|
// TODO: move this to base/mem and depend on "mem" platform dependently(?)
|
typedef struct block
|
{
|
const uint8_t* Ptr;
|
uintptr_t Id;
|
|
} block;
|
//end TODO
|
|
#ifdef TARGET_PALMOS
|
|
typedef struct arrayblock
|
{
|
array Array;
|
block Block;
|
|
} arrayblock;
|
|
ARRAY_DLL void ArrayBlockClear(arrayblock*);
|
ARRAY_DLL void ArrayBlockLock(arrayblock*);
|
|
#else
|
|
typedef struct arrayblock
|
{
|
array Array;
|
|
} arrayblock;
|
|
#define ArrayBlockClear(a) ArrayClear(&(a)->Array)
|
#define ArrayBlockLock(a) {}
|
|
#endif
|
|
#define SAFETAIL 256
|
|
typedef struct cc_fifo
|
{
|
// private members
|
array _Base;
|
uint8_t* _Read;
|
|
} cc_fifo;
|
|
static INLINE void Fifo_Init(cc_fifo* p) { ArrayInit(&p->_Base); p->_Read = NULL; }
|
ARRAY_DLL void Fifo_Clear(cc_fifo*);
|
ARRAY_DLL void Fifo_Drop(cc_fifo*);
|
ARRAY_DLL bool_t Fifo_Alloc(cc_fifo* p, size_t Size, size_t Align);
|
ARRAY_DLL uint8_t* Fifo_Write(cc_fifo*, const void* Ptr, size_t Length, size_t Align);
|
|
static INLINE void Fifo_Readed(cc_fifo* p, size_t Length)
|
{
|
p->_Read += Length;
|
}
|
|
#define FIFO_SIZE(p) (ARRAYEND((p)._Base,uint8_t)-(p)._Read)
|
#define FIFO_BEGIN(p) ((p)._Read)
|
#define FIFO_END(p) ARRAYEND((p)._Base,uint8_t)
|
|
#ifdef __cplusplus
|
}
|
#endif
|
|
#endif
|
