//-------------------------------------------------------------------------------------------------- static Context_t* GetContext ( Parser_t* parserPtr ) //-------------------------------------------------------------------------------------------------- { le_sls_Link_t* linkPtr = le_sls_Peek(&parserPtr->contextStack); LE_ASSERT(linkPtr != NULL); return CONTAINER_OF(linkPtr, Context_t, link); }
//-------------------------------------------------------------------------------------------------- static le_json_EventHandler_t GetEventHandler ( Parser_t* parserPtr ) //-------------------------------------------------------------------------------------------------- { le_sls_Link_t* linkPtr = le_sls_Peek(&parserPtr->contextStack); LE_ASSERT(linkPtr != NULL); return CONTAINER_OF(linkPtr, Context_t, link)->eventHandler; }
//-------------------------------------------------------------------------------------------------- static dstr_Ref_t FirstSegmentRef ( dstr_Ref_t headRef ///< [IN] The head of the string. ) //-------------------------------------------------------------------------------------------------- { VALIDATE_HEADER(headRef); le_sls_Link_t* linkPtr = le_sls_Peek(&headRef->head.list); if (linkPtr == NULL) { return NULL; } return CONTAINER_OF(linkPtr, Dstr_t, body.link); }
//-------------------------------------------------------------------------------------------------- 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; }