toolbox.c

CVI教程,用于信号采集系统的多任务开发软件.学习简单,功能实用.

                (*list)->itemSize * numItemsToInsert);
        else
            memset (ITEMPTR(list, numItems), 0,
                (*list)->itemSize * numItemsToInsert);

        (*list)->numItems += numItemsToInsert;
        }
    else 
        {                                  /* move part of list up to make room for new item */
        memmove (ITEMPTR(list,firstItemPosition-1+numItemsToInsert),
            ITEMPTR(list,firstItemPosition-1),
            (numItems + 1 - firstItemPosition) * (*list)->itemSize);

        if (ptrToItems)
            memmove (ITEMPTR(list,firstItemPosition-1), ptrToItems,
                (*list)->itemSize * numItemsToInsert);
        else
            memset (ITEMPTR(list,firstItemPosition-1), 0,
                (*list)->itemSize * numItemsToInsert);

        (*list)->numItems += numItemsToInsert;
        }

    return TRUE;
}

/*******************************/

int CVIFUNC ListEqual (ListType list1, ListType list2)
{
    if (list1 == list2)
        return TRUE;

    if (list1 == NULL || list2 == NULL)
        return FALSE;

    if ((*list1)->itemSize == (*list1)->itemSize)
        if ((*list1)->numItems == (*list2)->numItems)
            return (memcmp (ITEMPTR(list1,0), ITEMPTR(list2,0),
                (*list1)->itemSize * (*list1)->numItems) == 0);

    return FALSE;
}

/*******************************/

     /* The item pointed to by ptrToItem is copied over the current item at itemPosition */
void CVIFUNC ListReplaceItem (ListType list, void *ptrToItem, int itemPosition)
{
    ListReplaceItems (list, ptrToItem, itemPosition, 1);
}

/*******************************/

     /* The item pointed to by ptrToItems is copied over the current item at itemPosition */
void CVIFUNC ListReplaceItems (ListType list, void *ptrToItems, int firstItemPosition, int numItemsToReplace)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list || !ptrToItems || numItemsToReplace <= 0)
        return;
    if ((*list)->numItems == 0)
        return;
#endif
    
    if (firstItemPosition == END_OF_LIST)
        firstItemPosition = (*list)->numItems;
    else
    if (firstItemPosition == FRONT_OF_LIST)
        firstItemPosition = 1;

#ifndef TB_NO_SAFETY_CHECKS
    if (firstItemPosition <= 0  ||
        firstItemPosition + numItemsToReplace - 1 > (*list)->numItems)
        return;
#endif

    memmove (ITEMPTR(list,firstItemPosition-1), ptrToItems,
        (*list)->itemSize * numItemsToReplace);
}

/*******************************/

void CVIFUNC ListRemoveItem (ListType list, void *itemDestination, int itemPosition)
{
    ListRemoveItems (list, itemDestination, itemPosition, 1);
}

/*******************************/

void CVIFUNC ListRemoveItems (ListType list, void *itemsDestination, int firstItemPosition, int numItemsToRemove)
{
    int firstItemAfterChunk, numToMove;

#ifndef TB_NO_SAFETY_CHECKS
    if (!list || numItemsToRemove <= 0 || numItemsToRemove > (*list)->numItems)
        return;
#endif

    if (firstItemPosition == FRONT_OF_LIST)
        firstItemPosition = 1;
    else
    if (firstItemPosition == END_OF_LIST)
        firstItemPosition = (*list)->numItems;

#ifndef TB_NO_SAFETY_CHECKS
    if (firstItemPosition <= 0 ||
        firstItemPosition + numItemsToRemove - 1 > (*list)->numItems)   /* can't remove more than are there */
        return;
#endif

    if (itemsDestination != NULL)
         memcpy (itemsDestination, ITEMPTR(list,firstItemPosition-1),
            (*list)->itemSize * numItemsToRemove);

    firstItemAfterChunk = firstItemPosition + numItemsToRemove;
    numToMove = (*list)->numItems - (firstItemAfterChunk - 1);

    if (numToMove > 0)  /* move part of list down to cover hole left by removed item */
        memmove (ITEMPTR(list,firstItemPosition-1),
                 ITEMPTR(list,firstItemAfterChunk-1),
                 (*list)->itemSize * numToMove);

    (*list)->numItems -= numItemsToRemove;
}

/*******************************/

void CVIFUNC ListGetItem (ListType list, void *itemDestination, int itemPosition)
{
    ListGetItems (list, itemDestination, itemPosition, 1);
}

/*******************************/

void CVIFUNC ListGetItems(ListType list, void *itemsDestination, int firstItemPosition, int numItemsToGet)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list || !itemsDestination || numItemsToGet <= 0)
        return;
    if ((*list)->numItems == 0)
        return;
#endif

    if (firstItemPosition == FRONT_OF_LIST)
        firstItemPosition = 1;
    else    
    if (firstItemPosition == END_OF_LIST)
        firstItemPosition = (*list)->numItems;

#ifndef TB_NO_SAFETY_CHECKS
    if (firstItemPosition <= 0  ||
        firstItemPosition + numItemsToGet - 1 > (*list)->numItems)
        return;
#endif

    memcpy (itemsDestination, ITEMPTR(list,firstItemPosition-1),
        (*list)->itemSize * numItemsToGet);
}

/*******************************/

    /*  Returns a pointer to the item at itemPosition. returns null if an errors occurred.
    */
void * CVIFUNC ListGetPtrToItem (ListType list, int itemPosition)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list)
        return NULL;
    if ((*list)->numItems == 0)
        return NULL;
#endif

    if (itemPosition == FRONT_OF_LIST)
        itemPosition = 1;
    else
    if (itemPosition == END_OF_LIST)
        itemPosition = (*list)->numItems;

#ifndef TB_NO_SAFETY_CHECKS
    if (itemPosition <= 0 || itemPosition > (*list)->numItems)
        return NULL;
#endif 

    return ITEMPTR(list,itemPosition-1);
}

/*******************************/

     /* returns a pointer the lists data (abstraction violation for optimization) */
void * CVIFUNC ListGetDataPtr (ListType list)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list)
        return NULL;
#endif

    return &((*list)->itemList[0]);
}

/********************************/

int CVIFUNC ListApplyToEach (ListType list, int ascending, ListApplicationFunc funcToApply, void *callbackData)
{
    int result = 0, index;

    if (!list || !funcToApply)
        goto Error;

    if (ascending) 
        {
        for (index = 1; index <= ListNumItems (list); index++) 
            {
            result  = funcToApply (index, ListGetPtrToItem (list, index),
                callbackData);
            if (result < 0)
                goto Error;
            }
        }
    else 
        {
        for (index = ListNumItems (list); index > 0 &&
            index <= ListNumItems (list); index--) 
            {
            result  = funcToApply (index, ListGetPtrToItem (list, index),
                callbackData);
            if (result < 0)
                goto Error;
            }
        }

Error:
    return result;
}

/********************************/

int CVIFUNC ListGetItemSize (ListType list)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list)
        return 0;
#endif

    return (*list)->itemSize;
}

/********************************/

int CVIFUNC ListNumItems (ListType list)
{
#ifndef TB_NO_SAFETY_CHECKS
    if (!list)
        return 0;
#endif

    return (*list)->numItems;
}

/*******************************/

void CVIFUNC ListRemoveDuplicates (ListType list, CompareFunction compareFunction)
{
    int numItems, index, startIndexForFind, duplicatesIndex;

    numItems = ListNumItems (list);

    for (index = 1; index < numItems; index++) 
        {
        startIndexForFind = index + 1;
        while (startIndexForFind <= numItems) 
            {
            duplicatesIndex = ListFindItem (list, ListGetPtrToItem (list, index),
                startIndexForFind, compareFunction);
            if (duplicatesIndex > 0) 
                {
                ListRemoveItem (list, NULL, duplicatesIndex);
                numItems--;
                startIndexForFind = duplicatesIndex;
                }
             else
                break;
            }
        }
}

/*******************************/

int CVIFUNC ListFindItem (ListType list, void *ptrToItem, int startingPosition, CompareFunction compareFunction)
{
    int numItems, size, index, cmp;
    void *listItemPtr;

#ifndef TB_NO_SAFETY_CHECKS
    if (!list || !ptrToItem)
        return 0;
#endif

    if ((numItems = (*list)->numItems) == 0)
        return 0;

    size = (*list)->itemSize;

    if (startingPosition == FRONT_OF_LIST)
        startingPosition = 1;
    else
    if (startingPosition == END_OF_LIST)
        startingPosition = numItems;

#ifndef TB_NO_SAFETY_CHECKS
    if (startingPosition <= 0 || startingPosition > (*list)->numItems)
        return 0;
#endif

    for (index = startingPosition; index <= numItems; index++)
        {
        listItemPtr = ITEMPTR(list,index-1);
        cmp = compareFunction ? compareFunction(ptrToItem, listItemPtr)
                              : ListMemBlockCmp(ptrToItem, listItemPtr, size);
        if (cmp == 0)
            return index;
        }

    return 0;
}

/*******************************/

int CVICALLBACK ShortCompare(void *a, void *b)
{
    if (*(short *)a < *(short *)b) return -1;
    if (*(short *)a > *(short *)b) return  1;
    return 0;
}

/*******************************/

int CVICALLBACK IntCompare(void *a, void *b)
{
   if (*(int *)a < *(int *)b) return -1;
   if (*(int *)a > *(int *)b) return  1;
   return 0;
}

/*******************************/

int CVICALLBACK FloatCompare(void *a, void *b)
{
   if (*(float *)a < *(float *)b) return -1;
   if (*(float *)a > *(float *)b) return  1;
   return 0;
}

/*******************************/

int CVICALLBACK DoubleCompare(void *a, void *b)
{
   if (*(double *)a < *(double *)b) return -1;
   if (*(double *)a > *(double *)b) return  1;
   return 0;
}

/*******************************/

int CVICALLBACK CStringCompare(void *a, void *b)
{
    return strcmp(*(char **)a, *(char **)b);
}

/*******************************/

    /*  Used to compare list elements by their raw data contents */
static int CVICALLBACK ListMemBlockCmp(void *a, void *b, int size)
{
    return memcmp(a, b, size);
}

/*******************************/

int CVIFUNC ListBinSearch (ListType list, void *ptrToItem, CompareFunction compareFunction)
{
    int index;

#ifndef TB_NO_SAFETY_CHECKS
    if (!list || !ptrToItem)
        return 0;
#endif

    index = BinSearch (ITEMPTR(list,0), (int)(*list)->numItems,
        (int)(*list)->itemSize, ptrToItem, compareFunction);

    if (index >= 0)
        index++;        /* lists start from 1 */
    else
        index = 0;      /* item not found */

    return index;
}

/*******************************/

int CVIFUNC ListIsSorted (ListType list, CompareFunction compareFunction)
{
    int numItems, index;
    int cmp, size;
    void *item1Ptr, *item2Ptr;

#ifndef TB_NO_SAFETY_CHECKS
    if (!list)
        return FALSE;
#endif 

    if ((numItems = (*list)->numItems) < 2)
        return TRUE;

    size = (*list)->itemSize;

    item2Ptr = ITEMPTR(list,0);   /* prime it */
    for (index = 1; index <= numItems-1; index++)
        {
        item1Ptr = item2Ptr;   /* ITEMPTR(list,index-1) */
        item2Ptr = ITEMPTR(list,index);
        cmp = compareFunction ? compareFunction(item1Ptr, item2Ptr)
                              : ListMemBloc