Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation
 

Doxygen Source Code Documentation

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

SUMA_Algorithms.h File Reference

Go to the source code of this file.


Data Structures

struct  CList_
struct  CListElmt_
struct  DList_
struct  DListElmt_
struct  List_
struct  ListElmt_

Defines

#define list_size(list)   ((list)->size)
#define list_head(list)   ((list)->head)
#define list_tail(list)   ((list)->tail)
#define list_is_head(list, element)   ((element) == (list)->head ? 1 : 0)
#define list_is_tail(element)   ((element)->next == NULL ? 1 : 0)
#define list_data(element)   ((element)->data)
#define list_next(element)   ((element)->next)
#define clist_size(list)   ((list)->size)
#define clist_head(list)   ((list)->head)
#define clist_data(element)   ((element)->data)
#define clist_next(element)   ((element)->next)
#define dlist_size(list)   ((list)->size)
#define dlist_head(list)   ((list)->head)
#define dlist_tail(list)   ((list)->tail)
#define dlist_is_head(element)   ((element)->prev == NULL ? 1 : 0)
#define dlist_is_tail(element)   ((element)->next == NULL ? 1 : 0)
#define dlist_data(element)   ((element)->data)
#define dlist_next(element)   ((element)->next)
#define dlist_prev(element)   ((element)->prev)

Typedefs

typedef ListElmt_ ListElmt
typedef List_ List
typedef CListElmt_ CListElmt
typedef CList_ CList
typedef DListElmt_ DListElmt
typedef DList_ DList

Functions

void list_init (List *list, void(*destroy)(void *data))
void list_destroy (List *list)
int list_ins_next (List *list, ListElmt *element, const void *data)
int list_rem_next (List *list, ListElmt *element, void **data)
void clist_init (CList *list, void(*destroy)(void *data))
void clist_destroy (CList *list)
int clist_ins_next (CList *list, CListElmt *element, const void *data)
int clist_rem_next (CList *list, CListElmt *element, void **data)
void dlist_init (DList *list, void(*destroy)(void *data))
void dlist_destroy (DList *list)
int dlist_ins_next (DList *list, DListElmt *element, const void *data)
int dlist_ins_prev (DList *list, DListElmt *element, const void *data)
int dlist_remove (DList *list, DListElmt *element, void **data)

Define Documentation

#define clist_data (  element    )     ((element)->data)
 

Definition at line 146 of file SUMA_Algorithms.h.

#define clist_head (  list    )     ((list)->head)
 

Definition at line 144 of file SUMA_Algorithms.h.

#define clist_next (  element    )     ((element)->next)
 

Definition at line 148 of file SUMA_Algorithms.h.

#define clist_size (  list    )     ((list)->size)
 

Definition at line 142 of file SUMA_Algorithms.h.

Referenced by clist_destroy(), clist_ins_next(), and clist_rem_next().

#define dlist_data (  element    )     ((element)->data)
 

Definition at line 220 of file SUMA_Algorithms.h.

#define dlist_head (  list    )     ((list)->head)
 

Definition at line 212 of file SUMA_Algorithms.h.

Referenced by SUMA_Addto_ROIplane_List(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_BrushStrokeToNodeStroke(), SUMA_Build_Cluster_From_Node(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_Build_Mask_DrawnROI(), SUMA_BuildMessageLog(), SUMA_Draw_SO_ROI(), SUMA_DrawAxis(), SUMA_DrawBrushStroke(), SUMA_DrawnROI_to_1DDrawROI(), SUMA_DrawnROI_to_NIMLDrawnROI(), SUMA_Engine(), SUMA_FillToVoxelMask(), SUMA_FindDset(), SUMA_GetCx(), SUMA_GetLargestBackroundOrder(), SUMA_GetListNextCommand(), SUMA_GetSmallestForegroundOrder(), SUMA_ListOrderToPlaneOrder(), SUMA_MaskDsetByClustList(), SUMA_MovePlaneDown(), SUMA_MovePlaneUp(), SUMA_NodesInROI(), SUMA_OverlaysToOrderedList(), SUMA_Paint_SO_ROIplanes(), SUMA_PlaneOrder_Info(), SUMA_RedoAction(), SUMA_RegisterEngineListCommand(), SUMA_RegisterMessage(), SUMA_Show_SurfClust_list_Info(), SUMA_ShowBrushStroke(), SUMA_ShowDrawnROI(), SUMA_ShowList(), SUMA_ShowOffset_ll_Info(), SUMA_Sort_ClustersList(), SUMA_SortedAxisSegmentList(), SUMA_SurfClust_list_2_DsetMask(), and SUMA_UndoAction().

#define dlist_is_head (  element    )     ((element)->prev == NULL ? 1 : 0)
 

Definition at line 216 of file SUMA_Algorithms.h.

#define dlist_is_tail (  element    )     ((element)->next == NULL ? 1 : 0)
 

Definition at line 218 of file SUMA_Algorithms.h.

Referenced by SUMA_GetLargestBackroundOrder(), SUMA_GetSmallestForegroundOrder(), SUMA_ListOrderToPlaneOrder(), and SUMA_ShowList().

#define dlist_next (  element    )     ((element)->next)
 

Definition at line 222 of file SUMA_Algorithms.h.

Referenced by SUMA_Addto_ROIplane_List(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_Build_Mask_DrawnROI(), SUMA_BuildMessageLog(), SUMA_Draw_SO_ROI(), SUMA_DrawAxis(), SUMA_FindDset(), SUMA_NodesInROI(), SUMA_OverlaysToOrderedList(), SUMA_RedoAction(), SUMA_ShowDrawnROI(), and SUMA_SortedAxisSegmentList().

#define dlist_prev (  element    )     ((element)->prev)
 

Definition at line 224 of file SUMA_Algorithms.h.

Referenced by SUMA_UndoAction().

#define dlist_size (  list    )     ((list)->size)
 

Definition at line 210 of file SUMA_Algorithms.h.

Referenced by dlist_destroy(), dlist_ins_next(), dlist_ins_prev(), dlist_remove(), SUMA_BrushStrokeToNodeStroke(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_Build_Mask_DrawnROI(), SUMA_cb_DrawROI_Undo(), SUMA_Draw_SO_ROI(), SUMA_DrawBrushStroke(), SUMA_DrawnROI_to_NIMLDrawnROI(), SUMA_FillToVoxelMask(), SUMA_GetCx(), SUMA_GetListNextCommand(), SUMA_NodesInROI(), SUMA_Paint_SO_ROIplanes(), SUMA_ProcessBrushStroke(), SUMA_RegisterEngineListCommand(), SUMA_ShowBrushStroke(), and SUMA_ShowDrawnROI().

#define dlist_tail (  list    )     ((list)->tail)
 

Definition at line 214 of file SUMA_Algorithms.h.

Referenced by dlist_destroy(), SUMA_1DROI_to_DrawnROI(), SUMA_AddFillROIDatum(), SUMA_AddNewPlane(), SUMA_Addto_ROIplane_List(), SUMA_AddToBrushStroke(), SUMA_AddToTailJunctionROIDatum(), SUMA_AddToTailROIDatum(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_BrushStrokeToNodeStroke(), SUMA_Build_Cluster_From_Node(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_Build_Mask_DrawnROI(), SUMA_cb_DrawROI_Redo(), SUMA_Draw_SO_ROI(), SUMA_DrawAxis(), SUMA_DrawBrushStroke(), SUMA_DrawnROI_to_1DDrawROI(), SUMA_DrawnROI_to_NIMLDrawnROI(), SUMA_FillToVoxelMask(), SUMA_FindClusters(), SUMA_FindDset(), SUMA_GetCx(), SUMA_getoffsets_ll(), SUMA_InsertDsetPointer(), SUMA_MaskDsetByClustList(), SUMA_MovePlaneDown(), SUMA_MovePlaneUp(), SUMA_NIMLDrawnROI_to_DrawnROI(), SUMA_NodesInROI(), SUMA_NodeStrokeToConnectedNodes(), SUMA_OverlaysToOrderedList(), SUMA_Paint_SO_ROIplanes(), SUMA_PlaneOrder_Info(), SUMA_PushActionStack(), SUMA_RedoAction(), SUMA_RegisterEngineListCommand(), SUMA_RegisterMessage(), SUMA_Show_SurfClust_list_Info(), SUMA_ShowBrushStroke(), SUMA_ShowDrawnROI(), SUMA_ShowOffset_ll_Info(), SUMA_Sort_ClustersList(), SUMA_SortedAxisSegmentList(), and SUMA_SurfClust_list_2_DsetMask().

#define list_data (  element    )     ((element)->data)
 

Definition at line 82 of file SUMA_Algorithms.h.

#define list_head (  list    )     ((list)->head)
 

Definition at line 74 of file SUMA_Algorithms.h.

#define list_is_head (  list,
element    )     ((element) == (list)->head ? 1 : 0)
 

Definition at line 78 of file SUMA_Algorithms.h.

#define list_is_tail (  element    )     ((element)->next == NULL ? 1 : 0)
 

Definition at line 80 of file SUMA_Algorithms.h.

#define list_next (  element    )     ((element)->next)
 

Definition at line 84 of file SUMA_Algorithms.h.

#define list_size (  list    )     ((list)->size)
 

Definition at line 72 of file SUMA_Algorithms.h.

Referenced by list_destroy(), list_ins_next(), and list_rem_next().

#define list_tail (  list    )     ((list)->tail)
 

Definition at line 76 of file SUMA_Algorithms.h.

Typedef Documentation

typedef struct CList_ CList
 

typedef struct CListElmt_ CListElmt
 

typedef struct DList_ DList
 

typedef struct DListElmt_ DListElmt
 

typedef struct List_ List
 

typedef struct ListElmt_ ListElmt
 

Function Documentation

void clist_destroy (  CList *    list ) 
 

Definition at line 277 of file SUMA_Algorithms.c.

References clist_rem_next(), clist_size, CList_::destroy, and CList_::head. 

00277                                 {
00278 
00279 void               *data;
00280 
00281 /*****************************************************************************
00282 *                                                                            *
00283 *  Remove each element.                                                      *
00284 *                                                                            *
00285 *****************************************************************************/
00286 
00287 while (clist_size(list) > 0) {
00288 
00289    if (clist_rem_next(list, list->head, (void **)&data) == 0 && list->destroy
00290       != NULL) {
00291 
00292       /***********************************************************************
00293       *                                                                      *
00294       *  Call a user-defined function to free dynamically allocated data.    *
00295       *                                                                      *
00296       ***********************************************************************/
00297 
00298       list->destroy(data);
00299 
00300    }
00301 
00302 }
00303 
00304 /*****************************************************************************
00305 *                                                                            *
00306 *  No operations are allowed now, but clear the structure as a precaution.   *
00307 *                                                                            *
00308 *****************************************************************************/
00309 
00310 memset(list, 0, sizeof(CList));
00311 
00312 return;
00313 
00314 }

void clist_init (  CList *    list,
void(*    destroy)(void *data)
) 
 

Definition at line 255 of file SUMA_Algorithms.c.

References CList_::destroy, CList_::head, and CList_::size. 

00255                                                           {
00256 
00257 /*****************************************************************************
00258 *                                                                            *
00259 *  Initialize the list.                                                      *
00260 *                                                                            *
00261 *****************************************************************************/
00262 
00263 list->size = 0;
00264 list->destroy = destroy;
00265 list->head = NULL;
00266 
00267 return;
00268 
00269 }

int clist_ins_next (  CList *    list,
CListElmt *    element,
const void *    data
) 
 

Definition at line 322 of file SUMA_Algorithms.c.

References clist_size, CListElmt_::data, CList_::head, malloc, CListElmt_::next, and CList_::size. 

00322                                                                       {
00323 
00324 CListElmt          *new_element;
00325 
00326 /*****************************************************************************
00327 *                                                                            *
00328 *  Allocate storage for the element.                                         *
00329 *                                                                            *
00330 *****************************************************************************/
00331 
00332 if ((new_element = (CListElmt *)malloc(sizeof(CListElmt))) == NULL)
00333    return -1;
00334 
00335 /*****************************************************************************
00336 *                                                                            *
00337 *  Insert the element into the list.                                         *
00338 *                                                                            *
00339 *****************************************************************************/
00340 
00341 new_element->data = (void *)data;
00342 
00343 if (clist_size(list) == 0) {
00344 
00345    /**************************************************************************
00346    *                                                                         *
00347    *  Handle insertion when the list is empty.                               *
00348    *                                                                         *
00349    **************************************************************************/
00350 
00351    new_element->next = new_element;
00352    list->head = new_element;
00353 
00354    }
00355 
00356 else {
00357 
00358    /**************************************************************************
00359    *                                                                         *
00360    *  Handle insertion when the list is not empty.                           *
00361    *                                                                         *
00362    **************************************************************************/
00363 
00364    new_element->next = element->next;
00365    element->next = new_element;
00366 
00367 }
00368 
00369 /*****************************************************************************
00370 *                                                                            *
00371 *  Adjust the size of the list to account for the inserted element.          *
00372 *                                                                            *
00373 *****************************************************************************/
00374 
00375 list->size++;
00376 
00377 return 0;
00378 
00379 }

int clist_rem_next (  CList *    list,
CListElmt *    element,
void **    data
) 
 

Definition at line 387 of file SUMA_Algorithms.c.

References clist_size, CListElmt_::data, free, CList_::head, CListElmt_::next, and CList_::size.

Referenced by clist_destroy(). 

00387                                                                  {
00388 
00389 CListElmt          *old_element;
00390 
00391 /*****************************************************************************
00392 *                                                                            *
00393 *  Do not allow removal from an empty list.                                  *
00394 *                                                                            *
00395 *****************************************************************************/
00396 
00397 if (clist_size(list) == 0)
00398    return -1;
00399 
00400 /*****************************************************************************
00401 *                                                                            *
00402 *  Remove the element from the list.                                         *
00403 *                                                                            *
00404 *****************************************************************************/
00405 
00406 *data = element->next->data;
00407 
00408 if (element->next == element) {
00409 
00410    /**************************************************************************
00411    *                                                                         *
00412    *  Handle removing the last element.                                      *
00413    *                                                                         *
00414    **************************************************************************/
00415 
00416    old_element = element->next;
00417    list->head = NULL;
00418 
00419    }
00420 
00421 else {
00422 
00423    /**************************************************************************
00424    *                                                                         *
00425    *  Handle removing other than the last element.                           *
00426    *                                                                         *
00427    **************************************************************************/
00428 
00429    old_element = element->next;
00430    element->next = element->next->next;
00431 
00432 }
00433 
00434 /*****************************************************************************
00435 *                                                                            *
00436 *  Free the storage allocated by the abstract data type.                     *
00437 *                                                                            *
00438 *****************************************************************************/
00439 
00440 free(old_element);
00441 
00442 /*****************************************************************************
00443 *                                                                            *
00444 *  Adjust the size of the list to account for the removed element.           *
00445 *                                                                            *
00446 *****************************************************************************/
00447 
00448 list->size--;
00449 
00450 return 0;
00451 
00452 }

void dlist_destroy (  DList *    list ) 
 

Definition at line 488 of file SUMA_Algorithms.c.

References DList_::destroy, dlist_remove(), dlist_size, and dlist_tail.

Referenced by SUMA_AddNewPlane(), SUMA_Addto_ROIplane_List(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_Build_Cluster_From_Node(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_DestroyList(), SUMA_DrawAxis(), SUMA_EmptyDestroyActionStack(), SUMA_EmptyDestroyList(), SUMA_FillToVoxelMask(), SUMA_Free_CommonFields(), SUMA_Free_ROI_PlaneData(), SUMA_MovePlaneDown(), SUMA_MovePlaneUp(), and SUMA_Paint_SO_ROIplanes(). 

00488                                 {
00489 
00490 void               *data;
00491 
00492 /*****************************************************************************
00493 *                                                                            *
00494 *  Remove each element.                                                      *
00495 *                                                                            *
00496 *****************************************************************************/
00497 
00498 while (dlist_size(list) > 0) {
00499 
00500    if (dlist_remove(list, dlist_tail(list), (void **)&data) == 0 && list->
00501       destroy != NULL) {
00502 
00503       /***********************************************************************
00504       *                                                                      *
00505       *  Call a user-defined function to free dynamically allocated data.    *
00506       *                                                                      *
00507       ***********************************************************************/
00508 
00509       list->destroy(data);
00510 
00511    }
00512 
00513 }
00514 
00515 /*****************************************************************************
00516 *                                                                            *
00517 *  No operations are allowed now, but clear the structure as a precaution.   *
00518 *                                                                            *
00519 *****************************************************************************/
00520 
00521 memset(list, 0, sizeof(DList));
00522 
00523 return;
00524 
00525 }

void dlist_init (  DList *    list,
void(*    destroy)(void *data)
) 
 

Definition at line 465 of file SUMA_Algorithms.c.

References DList_::destroy, DList_::head, DList_::size, and DList_::tail.

Referenced by SUMA_Addto_ROIplane_List(), SUMA_AllocateDrawnROI(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_Create_CommonFields(), SUMA_CreateActionStack(), SUMA_CreateBrushStroke(), SUMA_CreateList(), SUMA_CreateMessageList(), SUMA_FillToVoxelMask(), SUMA_FindClusters(), SUMA_getoffsets_ll(), SUMA_NIMLDrawnROI_to_DrawnROI(), SUMA_OverlaysToOrderedList(), and SUMA_SortedAxisSegmentList(). 

00465                                                           {
00466 
00467 /*****************************************************************************
00468 *                                                                            *
00469 *  Initialize the list.                                                      *
00470 *                                                                            *
00471 *****************************************************************************/
00472 
00473 list->size = 0;
00474 list->destroy = destroy;
00475 list->head = NULL;
00476 list->tail = NULL;
00477 
00478 return;
00479 
00480 }

int dlist_ins_next (  DList *    list,
DListElmt *    element,
const void *    data
) 
 

Definition at line 533 of file SUMA_Algorithms.c.

References DListElmt_::data, dlist_size, DList_::head, malloc, DListElmt_::next, DListElmt_::prev, DList_::size, and DList_::tail.

Referenced by SUMA_1DROI_to_DrawnROI(), SUMA_AddFillROIDatum(), SUMA_AddNewPlane(), SUMA_Addto_ROIplane_List(), SUMA_AddToBrushStroke(), SUMA_AddToTailJunctionROIDatum(), SUMA_AddToTailROIDatum(), SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_BrushStrokeToNodeStroke(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_FillToVoxelMask(), SUMA_FindClusters(), SUMA_getoffsets_ll(), SUMA_InsertDsetPointer(), SUMA_MovePlaneUp(), SUMA_NIMLDrawnROI_to_DrawnROI(), SUMA_OverlaysToOrderedList(), SUMA_PushActionStack(), SUMA_RegisterEngineListCommand(), SUMA_RegisterMessage(), and SUMA_SortedAxisSegmentList(). 

00533                                                                       {
00534 
00535 DListElmt          *new_element;
00536 
00537 /*****************************************************************************
00538 *                                                                            *
00539 *  Do not allow a NULL element unless the list is empty.                     *
00540 *                                                                            *
00541 *****************************************************************************/
00542 
00543 if (element == NULL && dlist_size(list) != 0)
00544    return -1;
00545 
00546 /*****************************************************************************
00547 *                                                                            *
00548 *  Allocate storage for the element.                                         *
00549 *                                                                            *
00550 *****************************************************************************/
00551 
00552 if ((new_element = (DListElmt *)malloc(sizeof(DListElmt))) == NULL)
00553    return -1;
00554 
00555 /*****************************************************************************
00556 *                                                                            *
00557 *  Insert the new element into the list.                                     *
00558 *                                                                            *
00559 *****************************************************************************/
00560 
00561 new_element->data = (void *)data;
00562 
00563 if (dlist_size(list) == 0) {
00564 
00565    /**************************************************************************
00566    *                                                                         *
00567    *  Handle insertion when the list is empty.                               *
00568    *                                                                         *
00569    **************************************************************************/
00570 
00571    list->head = new_element;
00572    list->head->prev = NULL;
00573    list->head->next = NULL;
00574    list->tail = new_element;
00575 
00576    }
00577 
00578 else {
00579 
00580    /**************************************************************************
00581    *                                                                         *
00582    *  Handle insertion when the list is not empty.                           *
00583    *                                                                         *
00584    **************************************************************************/
00585 
00586    new_element->next = element->next;
00587    new_element->prev = element;
00588 
00589    if (element->next == NULL)
00590       list->tail = new_element;
00591    else
00592       element->next->prev = new_element;
00593 
00594    element->next = new_element;
00595 
00596 }
00597 
00598 /*****************************************************************************
00599 *                                                                            *
00600 *  Adjust the size of the list to account for the inserted element.          *
00601 *                                                                            *
00602 *****************************************************************************/
00603 
00604 list->size++;
00605 
00606 return 0;
00607 
00608 }

int dlist_ins_prev (  DList *    list,
DListElmt *    element,
const void *    data
) 
 

Definition at line 617 of file SUMA_Algorithms.c.

References DListElmt_::data, dlist_size, DList_::head, malloc, DListElmt_::next, DListElmt_::prev, DList_::size, and DList_::tail.

Referenced by SUMA_AssembleAllROIList(), SUMA_AssembleColorPlaneList(), SUMA_AssembleGroupList(), SUMA_MovePlaneDown(), SUMA_OverlaysToOrderedList(), SUMA_RegisterEngineListCommand(), SUMA_Sort_ClustersList(), and SUMA_SortedAxisSegmentList(). 

00617                                                                       {
00618 
00619 DListElmt          *new_element;
00620 
00621 /*****************************************************************************
00622 *                                                                            *
00623 *  Do not allow a NULL element unless the list is empty.                     *
00624 *                                                                            *
00625 *****************************************************************************/
00626 
00627 if (element == NULL && dlist_size(list) != 0)
00628    return -1;
00629 
00630 /*****************************************************************************
00631 *                                                                            *
00632 *  Allocate storage to be managed by the abstract data type.                 *
00633 *                                                                            *
00634 *****************************************************************************/
00635 
00636 if ((new_element = (DListElmt *)malloc(sizeof(DListElmt))) == NULL)
00637    return -1;
00638 
00639 /*****************************************************************************
00640 *                                                                            *
00641 *  Insert the new element into the list.                                     *
00642 *                                                                            *
00643 *****************************************************************************/
00644 
00645 new_element->data = (void *)data;
00646 
00647 if (dlist_size(list) == 0) {
00648 
00649    /**************************************************************************
00650    *                                                                         *
00651    *  Handle insertion when the list is empty.                               *
00652    *                                                                         *
00653    **************************************************************************/
00654 
00655    list->head = new_element;
00656    list->head->prev = NULL;
00657    list->head->next = NULL;
00658    list->tail = new_element;
00659 
00660    }
00661 
00662 
00663 else {
00664 
00665    /**************************************************************************
00666    *                                                                         *
00667    *  Handle insertion when the list is not empty.                           *
00668    *                                                                         *
00669    **************************************************************************/
00670 
00671    new_element->next = element; 
00672    new_element->prev = element->prev;
00673 
00674    if (element->prev == NULL)
00675       list->head = new_element;
00676    else
00677       element->prev->next = new_element;
00678 
00679    element->prev = new_element;
00680 
00681 }
00682 
00683 
00684 /*****************************************************************************
00685 *                                                                            *
00686 *  Adjust the size of the list to account for the new element.               *
00687 *                                                                            *
00688 *****************************************************************************/
00689 
00690 list->size++;
00691 
00692 return 0;
00693 
00694 }

int dlist_remove (  DList *    list,
DListElmt *    element,
void **    data
) 
 

Definition at line 702 of file SUMA_Algorithms.c.

References DListElmt_::data, dlist_size, free, DList_::head, DListElmt_::next, DListElmt_::prev, DList_::size, and DList_::tail.

Referenced by dlist_destroy(), SUMA_AddFillROIDatum(), SUMA_AddToTailJunctionROIDatum(), SUMA_AddToTailROIDatum(), SUMA_BrushStrokeToNodeStroke(), SUMA_Build_Cluster_From_Node_NoRec(), SUMA_FillToVoxelMask(), SUMA_MovePlaneDown(), SUMA_MovePlaneUp(), SUMA_PushActionStack(), SUMA_ReleaseEngineListElement(), SUMA_ReleaseMessageListElement(), and SUMA_Sort_ClustersList(). 

00702                                                                {
00703 
00704 /*****************************************************************************
00705 *                                                                            *
00706 *  Do not allow a NULL element or removal from an empty list.                *
00707 *                                                                            *
00708 *****************************************************************************/
00709 
00710 if (element == NULL || dlist_size(list) == 0)
00711    return -1;
00712 
00713 /*****************************************************************************
00714 *                                                                            *
00715 *  Remove the element from the list.                                         *
00716 *                                                                            *
00717 *****************************************************************************/
00718 
00719 *data = element->data;
00720 
00721 if (element == list->head) {
00722 
00723    /**************************************************************************
00724    *                                                                         *
00725    *  Handle removal from the head of the list.                              *
00726    *                                                                         *
00727    **************************************************************************/
00728 
00729    list->head = element->next;
00730 
00731    if (list->head == NULL)
00732       list->tail = NULL;
00733    else
00734       element->next->prev = NULL;
00735 
00736    }
00737 
00738 else {
00739 
00740    /**************************************************************************
00741    *                                                                         *
00742    *  Handle removal from other than the head of the list.                   *
00743    *                                                                         *
00744    **************************************************************************/
00745 
00746    element->prev->next = element->next;
00747 
00748    if (element->next == NULL)
00749       list->tail = element->prev;
00750    else
00751       element->next->prev = element->prev;
00752 
00753 }
00754 
00755 /*****************************************************************************
00756 *                                                                            *
00757 *  Free the storage allocated by the abstract data type.                     *
00758 *                                                                            *
00759 *****************************************************************************/
00760 
00761 free(element);
00762 
00763 /*****************************************************************************
00764 *                                                                            *
00765 *  Adjust the size of the list to account for the removed element.           *
00766 *                                                                            *
00767 *****************************************************************************/
00768 
00769 list->size--;
00770 
00771 return 0;
00772 
00773 }

void list_destroy (  List *    list ) 
 

Definition at line 50 of file SUMA_Algorithms.c.

References List_::destroy, list_rem_next(), and list_size. 

00050                               {
00051 
00052 void               *data;
00053 
00054 /*****************************************************************************
00055 *                                                                            *
00056 *  Remove each element.                                                      *
00057 *                                                                            *
00058 *****************************************************************************/
00059 
00060 while (list_size(list) > 0) {
00061 
00062    if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy !=
00063       NULL) {
00064 
00065       /***********************************************************************
00066       *                                                                      *
00067       *  Call a user-defined function to free dynamically allocated data.    *
00068       *                                                                      *
00069       ***********************************************************************/
00070 
00071       list->destroy(data);
00072 
00073    }
00074 
00075 }
00076 
00077 /*****************************************************************************
00078 *                                                                            *
00079 *  No operations are allowed now, but clear the structure as a precaution.   *
00080 *                                                                            *
00081 *****************************************************************************/
00082 
00083 memset(list, 0, sizeof(List));
00084 
00085 return;
00086 
00087 }

void list_init (  List *    list,
void(*    destroy)(void *data)
) 
 

Definition at line 27 of file SUMA_Algorithms.c.

References List_::destroy, List_::head, List_::size, and List_::tail. 

00027                                                         {
00028 
00029 /*****************************************************************************
00030 *                                                                            *
00031 *  Initialize the list.                                                      *
00032 *                                                                            *
00033 *****************************************************************************/
00034 
00035 list->size = 0;
00036 list->destroy = destroy;
00037 list->head = NULL;
00038 list->tail = NULL;
00039 
00040 return;
00041 
00042 }

int list_ins_next (  List *    list,
ListElmt *    element,
const void *    data
) 
 

Definition at line 95 of file SUMA_Algorithms.c.

References ListElmt_::data, List_::head, list_size, malloc, ListElmt_::next, List_::size, and List_::tail. 

00095                                                                    {
00096 
00097 ListElmt           *new_element;
00098 
00099 /*****************************************************************************
00100 *                                                                            *
00101 *  Allocate storage for the element.                                         *
00102 *                                                                            *
00103 *****************************************************************************/
00104 
00105 if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL)
00106    return -1;
00107 
00108 /*****************************************************************************
00109 *                                                                            *
00110 *  Insert the element into the list.                                         *
00111 *                                                                            *
00112 *****************************************************************************/
00113 
00114 new_element->data = (void *)data;
00115 
00116 if (element == NULL) {
00117 
00118    /**************************************************************************
00119    *                                                                         *
00120    *  Handle insertion at the head of the list.                              *
00121    *                                                                         *
00122    **************************************************************************/
00123 
00124    if (list_size(list) == 0)
00125       list->tail = new_element;
00126 
00127    new_element->next = list->head;
00128    list->head = new_element;
00129 
00130    }
00131 
00132 else {
00133 
00134    /**************************************************************************
00135    *                                                                         *
00136    *  Handle insertion somewhere other than at the head.                     *
00137    *                                                                         *
00138    **************************************************************************/
00139 
00140    if (element->next == NULL)
00141       list->tail = new_element;
00142 
00143    new_element->next = element->next;
00144    element->next = new_element;
00145 
00146 }
00147 
00148 /*****************************************************************************
00149 *                                                                            *
00150 *  Adjust the size of the list to account for the inserted element.          *
00151 *                                                                            *
00152 *****************************************************************************/
00153 
00154 list->size++;
00155 
00156 return 0;
00157 
00158 }

int list_rem_next (  List *    list,
ListElmt *    element,
void **    data
) 
 

Definition at line 166 of file SUMA_Algorithms.c.

References ListElmt_::data, free, List_::head, list_size, ListElmt_::next, List_::size, and List_::tail.

Referenced by list_destroy(). 

00166                                                               {
00167 
00168 ListElmt           *old_element;
00169 
00170 /*****************************************************************************
00171 *                                                                            *
00172 *  Do not allow removal from an empty list.                                  *
00173 *                                                                            *
00174 *****************************************************************************/
00175 
00176 if (list_size(list) == 0)
00177    return -1;
00178 
00179 /*****************************************************************************
00180 *                                                                            *
00181 *  Remove the element from the list.                                         *
00182 *                                                                            *
00183 *****************************************************************************/
00184 
00185 if (element == NULL) {
00186 
00187    /**************************************************************************
00188    *                                                                         *
00189    *  Handle removal from the head of the list.                              *
00190    *                                                                         *
00191    **************************************************************************/
00192 
00193    *data = list->head->data;
00194    old_element = list->head;
00195    list->head = list->head->next;
00196 
00197    if (list_size(list) == 1)
00198       list->tail = NULL;
00199 
00200    }
00201 
00202 else {
00203 
00204    /**************************************************************************
00205    *                                                                         *
00206    *  Handle removal from somewhere other than the head.                     *
00207    *                                                                         *
00208    **************************************************************************/
00209 
00210    if (element->next == NULL)
00211       return -1;
00212 
00213    *data = element->next->data;
00214    old_element = element->next;
00215    element->next = element->next->next;
00216 
00217    if (element->next == NULL)
00218       list->tail = element;
00219 
00220 }
00221 
00222 /*****************************************************************************
00223 *                                                                            *
00224 *  Free the storage allocated by the abstract data type.                     *
00225 *                                                                            *
00226 *****************************************************************************/
00227 
00228 free(old_element);
00229 
00230 /*****************************************************************************
00231 *                                                                            *
00232 *  Adjust the size of the list to account for the removed element.           *
00233 *                                                                            *
00234 *****************************************************************************/
00235 
00236 list->size--;
00237 
00238 return 0;
00239 
00240 }
 
Powered by Plone

This site conforms to the following standards: