//--------------------------------------------------------------------------------------------------
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;
}
