//-------------------------------------------------------------------------------------------------- le_result_t ni_GetNodeName ( ni_IteratorRef_t iteratorRef, ///< The iterator object to access. const char* pathPtr, ///< Optional path to another node in the tree. char* destBufferPtr, ///< The buffer to copy string data into. size_t bufferMax ///< The maximum size of the string buffer. ) //-------------------------------------------------------------------------------------------------- { // Make sure we were given a buffer. if (bufferMax == 0) { return LE_OVERFLOW; } // If we have a current node, get it's name. Otherwise we'll have to get the name from the // path. tdb_NodeRef_t nodeRef = ni_GetNode(iteratorRef, pathPtr); if (nodeRef != NULL) { return tdb_GetNodeName(nodeRef, destBufferPtr, bufferMax); } // Clear out the target buffer and attempt get the last named segment on our path string. If // that fails then we're on the root node and just return an empty string. *destBufferPtr = 0; if (le_pathIter_GoToEnd(iteratorRef->pathIterRef) != LE_OK) { return le_pathIter_GetCurrentNode(iteratorRef->pathIterRef, destBufferPtr, bufferMax); } return LE_OK; }
//-------------------------------------------------------------------------------------------------- le_result_t ni_GoToNextSibling ( ni_IteratorRef_t iteratorRef ///< The iterator object to access. ) //-------------------------------------------------------------------------------------------------- { // If the current node exists, then look to it for a sibling node. Otherwise, a non-existant // node can not have siblings. if (iteratorRef->currentNodeRef != NULL) { tdb_NodeRef_t newNodeRef = tdb_GetNextActiveSiblingNode(iteratorRef->currentNodeRef); if (newNodeRef == NULL) { return LE_NOT_FOUND; } // Looks like we found a new node, so replace the node name at the end of the path. iteratorRef->currentNodeRef = newNodeRef; char namePtr[MAX_NODE_NAME] = { 0 }; tdb_GetNodeName(newNodeRef, namePtr, MAX_NODE_NAME); if (le_pathIter_GoToEnd(iteratorRef->pathIterRef) != LE_NOT_FOUND) { le_pathIter_Truncate(iteratorRef->pathIterRef); } le_pathIter_Append(iteratorRef->pathIterRef, namePtr); return LE_OK; } return LE_NOT_FOUND; }
//-------------------------------------------------------------------------------------------------- le_result_t ni_GoToFirstChild ( ni_IteratorRef_t iteratorRef ///< The iterator object to access. ) //-------------------------------------------------------------------------------------------------- { if (iteratorRef->currentNodeRef != NULL) { tdb_NodeRef_t newNodeRef = tdb_GetFirstActiveChildNode(iteratorRef->currentNodeRef); if (newNodeRef == NULL) { return LE_NOT_FOUND; } iteratorRef->currentNodeRef = newNodeRef; char namePtr[MAX_NODE_NAME] = { 0 }; tdb_GetNodeName(newNodeRef, namePtr, MAX_NODE_NAME); le_pathIter_Append(iteratorRef->pathIterRef, namePtr); return LE_OK; } return LE_NOT_FOUND; }
//-------------------------------------------------------------------------------------------------- le_result_t ni_GoToFirstChild ( ni_IteratorRef_t iteratorRef ///< [IN] The iterator object to access. ) //-------------------------------------------------------------------------------------------------- { if (iteratorRef->currentNodeRef != NULL) { tdb_NodeRef_t newNodeRef = tdb_GetFirstActiveChildNode(iteratorRef->currentNodeRef); if (newNodeRef == NULL) { return LE_NOT_FOUND; } iteratorRef->currentNodeRef = newNodeRef; char name[LE_CFG_NAME_LEN_BYTES] = ""; tdb_GetNodeName(newNodeRef, name, sizeof(name)); le_pathIter_Append(iteratorRef->pathIterRef, name); return LE_OK; } return LE_NOT_FOUND; }
//-------------------------------------------------------------------------------------------------- le_result_t ni_GetNodeName ( ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access. const char* pathPtr, ///< [IN] Optional path to another node in the tree. char* destBufferPtr, ///< [OUT] The buffer to copy string data into. size_t bufferMax ///< [IN] The maximum size of the string buffer. ) //-------------------------------------------------------------------------------------------------- { // Make sure we were given a buffer. if (bufferMax == 0) { return LE_OVERFLOW; } // If we have a current node, get it's name. Otherwise we'll have to get the name from the // path. tdb_NodeRef_t nodeRef = ni_GetNode(iteratorRef, pathPtr); // If the iterator was closed during the GetNode, then that means there was a fatal problem // encountered. if (iteratorRef->isTerminated) { // At this point we know the client has been disconnected. So just return fault so that the // calling code can know this. return LE_FAULT; } if (nodeRef != NULL) { return tdb_GetNodeName(nodeRef, destBufferPtr, bufferMax); } // Looks like a node wasn't found. So, try to get the name of the node from the sub-path. Or // if a sub-path was not specified, get the name from the iterator's base path. *destBufferPtr = '\0'; if (strcmp(pathPtr, "") != 0) { le_pathIter_Ref_t subPathIter = le_pathIter_CreateForUnix(pathPtr); le_result_t result = le_pathIter_GoToEnd(iteratorRef->pathIterRef); if (result == LE_OK) { result = le_pathIter_GetCurrentNode(subPathIter, destBufferPtr, bufferMax); } le_pathIter_Delete(subPathIter); return result; } LE_ASSERT(le_pathIter_GoToEnd(iteratorRef->pathIterRef) == LE_OK); return le_pathIter_GetCurrentNode(iteratorRef->pathIterRef, destBufferPtr, bufferMax); }
//-------------------------------------------------------------------------------------------------- le_result_t ni_SetNodeName ( ni_IteratorRef_t iteratorRef, ///< [IN] The iterator object to access. const char* pathPtr, ///< [IN] Optional path to another node in the tree. const char* namePtr ///< [IN] The new name to use. ) //-------------------------------------------------------------------------------------------------- { // Try to get or create the requested node. If the optional sub-path results in a new path that // overflows, then the node get will fail. tdb_NodeRef_t nodeRef = ni_TryCreateNode(iteratorRef, pathPtr); le_result_t result = LE_OK; if (nodeRef) { // Ok, the existing path is ok. Cache the existing node name, in case we have to revert it // later, then set the new name. We may have to revert the name later, because, while the // new name itself may be ok. The name may actually be too long for the path limit. char oldName[LE_CFG_NAME_LEN_BYTES] = ""; LE_ASSERT(tdb_GetNodeName(nodeRef, oldName, sizeof(oldName)) == LE_OK); result = tdb_SetNodeName(nodeRef, namePtr); if (result == LE_OK) { // The new name passed validation, now we have to make sure that the full path to the // node is still ok. So, first we have to check, was a relative path used. if (strcmp(pathPtr, "") == 0) { // Looks like the caller was using the iterator's current node. So, remove the old // name from the end of the iterator's current path, and append the new name. If // this fails, it's because the new absolute path is too long, so name change fails, // and we have to revert the changes. LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, "..") == LE_OK); result = le_pathIter_Append(iteratorRef->pathIterRef, namePtr); if (result != LE_OK) { LE_ASSERT(le_pathIter_Append(iteratorRef->pathIterRef, oldName) == LE_OK); } } else { // The user is accessing a node relative to the iterator's current node. So, we // need too build up a new path and validate that the new name still fits within our // limits. The new path ref is for validation only and can be safely discarded once // the check is complete. le_pathIter_Ref_t newPathRef = le_pathIter_Clone(iteratorRef->pathIterRef); result = le_pathIter_Append(newPathRef, pathPtr); if (result == LE_OK) { LE_ASSERT(le_pathIter_Append(newPathRef, "..") == LE_OK); result = le_pathIter_Append(newPathRef, namePtr); } le_pathIter_Delete(newPathRef); } // If we got to this point and everything is ok, then we know that the name set was ok, // and that the resultant path with the new name is also ok. So, make sure that this // node exists in the next commit. Otherwise, revert the node to it's old name and // report the error to the caller. if (result == LE_OK) { tdb_EnsureExists(nodeRef); } else { LE_ASSERT(tdb_SetNodeName(nodeRef, oldName) == LE_OK); } } } return result; }