//-------------------------------------------------------------------------------------------------- static dstr_Ref_t NextSegmentRef ( dstr_Ref_t headRef, ///< [IN] The head of the string. dstr_Ref_t currentPtr ///< [IN] The current sub-section of the string. ) //-------------------------------------------------------------------------------------------------- { VALIDATE_HEADER(headRef); LE_FATAL_IF(currentPtr == NULL, "Fatal corrupted string iteration detected."); le_sls_Link_t* linkPtr = le_sls_PeekNext(&headRef->head.list, ¤tPtr->body.link); if (linkPtr == NULL) { return NULL; } return CONTAINER_OF(linkPtr, Dstr_t, body.link); }
//-------------------------------------------------------------------------------------------------- static void FreeAnyAfter ( dstr_Ref_t headRef, ///< [IN] The head of the string. dstr_Ref_t currentPtr ///< [IN] The current sub-section of the string. ) //-------------------------------------------------------------------------------------------------- { VALIDATE_HEADER(headRef); LE_FATAL_IF(currentPtr == NULL, "Corrupted string free encountered."); le_sls_Link_t* linkPtr; while ((linkPtr = le_sls_PeekNext(&headRef->head.list, ¤tPtr->body.link)) != NULL) { dstr_Ref_t segmentRef = CONTAINER_OF(linkPtr, Dstr_t, body.link); le_sls_RemoveAfter(&headRef->head.list, ¤tPtr->body.link); le_mem_Release(segmentRef); } }
//-------------------------------------------------------------------------------------------------- static msgProtocol_Protocol_t* FindProtocol ( const char* protocolId ///< [in] String uniquely identifying the the protocol and version. ) //-------------------------------------------------------------------------------------------------- { le_sls_Link_t* linkPtr; LOCK linkPtr = le_sls_Peek(&ProtocolList); while (linkPtr != NULL) { msgProtocol_Protocol_t* protocolPtr = CONTAINER_OF(linkPtr, msgProtocol_Protocol_t, link); if (strcmp(protocolId, protocolPtr->id) == 0) { UNLOCK return protocolPtr; } linkPtr = le_sls_PeekNext(&ProtocolList, linkPtr); }
static le_result_t TestSinglyLinkLists(size_t maxListSize) { // Node definition. typedef struct { le_sls_Link_t link; uint32_t id; } idRecord_t; int i; le_sls_List_t list0, list1; printf("\n"); printf("*** Unit Test for le_singlyLinkedList module. ***\n"); // // Multiple list creation // // Initialize the lists list0 = LE_SLS_LIST_INIT; list1 = LE_SLS_LIST_INIT; printf("One singly linked list was successfully created.\n"); // // Attempt to query empty list // if ( (le_sls_Peek(&list0) != NULL) || (le_sls_Pop(&list0) != NULL) ) { printf("Query of empty list failed: %d", __LINE__); return LE_FAULT; } printf("Query of empty list correct.\n"); // // Node insertions // { idRecord_t* newNodePtr; le_sls_Link_t* prevLinkPtr; // Queue nodes to list0. for (i = 0; i < maxListSize; i++) { // Create the new node newNodePtr = (idRecord_t*)malloc(sizeof(idRecord_t)); newNodePtr->id = i; // Initialize the link. newNodePtr->link = LE_SLS_LINK_INIT; if (i < maxListSize/2) { // Insert the new node to the tail. le_sls_Queue(&list0, &(newNodePtr->link)); } else { // Insert to the tail using insert after. le_sls_AddAfter(&list0, prevLinkPtr, &(newNodePtr->link)); } prevLinkPtr = &(newNodePtr->link); } printf("%zu nodes were queued to the tail of list0.\n", maxListSize); // Stack nodes to list1. for (i = 0; i < maxListSize; i++) { // Create the new node newNodePtr = (idRecord_t*)malloc(sizeof(idRecord_t)); newNodePtr->id = i; // Initialize the link. newNodePtr->link = LE_SLS_LINK_INIT; // Insert the new node to the head. le_sls_Stack(&list1, &(newNodePtr->link)); } printf("%zu nodes were stacked to the head of list1.\n", maxListSize); } // // Check that all the nodes have been added properly // { idRecord_t* nodePtr; le_sls_Link_t* link0Ptr = le_sls_Peek(&list0); le_sls_Link_t* link1Ptr = le_sls_Peek(&list1); if ( (link0Ptr == NULL) || (link1Ptr == NULL) ) { printf("Link error: %d", __LINE__); return LE_FAULT; } i = 0; do { // Get the node from list 0 nodePtr = CONTAINER_OF(link0Ptr, idRecord_t, link); // Check the node. if ( nodePtr->id != i) { printf("Link error: %d", __LINE__); return LE_FAULT; } // Get the node from list 1 nodePtr = CONTAINER_OF(link1Ptr, idRecord_t, link); // Check the node. if ( nodePtr->id != maxListSize - i - 1) { printf("Link error: %d", __LINE__); return LE_FAULT; } // Move to the next node. link0Ptr = le_sls_PeekNext(&list0, link0Ptr); link1Ptr = le_sls_PeekNext(&list1, link1Ptr); i++; } while (link0Ptr != NULL); // Make sure everything is correct. if ( (i != maxListSize) || (link1Ptr != NULL) ) { printf("Link error: %d", __LINE__); return LE_FAULT; } } printf("Checked that all nodes added to the head and tails are all correct.\n"); // // Pop nodes. // { //pop half the list. for (i = 0; i < (maxListSize / 2); i++) { le_sls_Pop(&list0); } } printf("Popped half the nodes from the head of list0.\n"); // Check that the list is still in tact. { idRecord_t* nodePtr; // For list 0. le_sls_Link_t* linkPtr = le_sls_Peek(&list0); i = maxListSize/2; do { nodePtr = CONTAINER_OF(linkPtr, idRecord_t, link); if (nodePtr->id != i++) { printf("Link error: %d", __LINE__); return LE_FAULT; } linkPtr = le_sls_PeekNext(&list0, linkPtr); } while (linkPtr != NULL); // Check that the number of links left is correct. if (i != maxListSize) { printf("Wrong number of links: %d", __LINE__); return LE_FAULT; } } printf("Checked that all nodes were properly popped from the lists.\n"); // // Check for list corruption. // { le_sls_Link_t* linkPtr; if (le_sls_IsListCorrupted(&list0)) { printf("List0 is corrupt but shouldn't be: %d", __LINE__); return LE_FAULT; } // Access one of the links directly. This should corrupt the list. linkPtr = le_sls_Peek(&list0); linkPtr = le_sls_PeekNext(&list0, linkPtr); linkPtr->nextPtr = NULL; if (!le_sls_IsListCorrupted(&list0)) { printf("List0 is not corrupted but should be: %d", __LINE__); return LE_FAULT; } } printf("Checked lists for corruption.\n"); printf("*** Unit Test for le_singlyLinkedList module passed. ***\n"); printf("\n"); return LE_OK; }