nsframework/framework_unified/client/NS_XMLConfigeParser/library/src/ns_xmlparser_node.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 ////////////////////////////////////////////////////////////////////////////////////////////////////
  18 /// \ingroup  tag_NS_XmlParser
  19 /// \brief    This file contains implementation of CXmlNode class.
  20 ///
  21 ////////////////////////////////////////////////////////////////////////////////////////////////////
  22
  23 ////////////////////////////////////////////////////////////////////////////////////////////////////
  24 // Include Files
  25 ////////////////////////////////////////////////////////////////////////////////////////////////////
  26 #include <native_service/ns_xmlparser_if.h>
  27 #include <string>
  28 #include "ns_xmlconfig_parser_frameworkunifiedlog.h"
  29
  30
  31 ////////////////////////////////////////////////////////////////////////////////////////////////
  32 /// CXmlNode
  33 /// Constructor
  34 ////////////////////////////////////////////////////////////////////////////////////////////////
  35 CXmlNode::CXmlNode(): m_pXmlNodePtr(NULL) {
  36   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  37   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  38 }
  39
  40 ////////////////////////////////////////////////////////////////////////////////////////////////
  41 /// CXmlNode
  42 /// Parameterized Constructor
  43 ////////////////////////////////////////////////////////////////////////////////////////////////
  44 CXmlNode::CXmlNode(xmlNodePtr f_pXmlNodePtr): m_pXmlNodePtr(f_pXmlNodePtr) {
  45   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  46   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  47 }
  48
  49 ////////////////////////////////////////////////////////////////////////////////////////////////
  50 /// ~CXmlNode
  51 /// Destructor
  52 ////////////////////////////////////////////////////////////////////////////////////////////////
  53 CXmlNode::~CXmlNode() {
  54   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  55   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  56 }
  57
  58 ////////////////////////////////////////////////////////////////////////////////////////////////
  59 /// SetXmlNodePtr
  60 /// Sets the xmlNodePtr in class
  61 ////////////////////////////////////////////////////////////////////////////////////////////////
  62 VOID CXmlNode::SetXmlNodePtr(xmlNodePtr f_pXmlNodePtr) {
  63   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  64   m_pXmlNodePtr = f_pXmlNodePtr;
  65   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  66 }
  67
  68 ////////////////////////////////////////////////////////////////////////////////////////////////
  69 /// IsNull
  70 /// Checks whether the node is valid or not
  71 ////////////////////////////////////////////////////////////////////////////////////////////////
  72 BOOL CXmlNode::IsNull() {
  73   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  74   BOOL l_bNull = FALSE;
  75
  76   if (NULL == m_pXmlNodePtr) {
  77     l_bNull = TRUE;
  78   }
  79
  80   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  81   return l_bNull;
  82 }
  83
  84 ////////////////////////////////////////////////////////////////////////////////////////////////
  85 /// Type
  86 /// Gets the type of node
  87 ////////////////////////////////////////////////////////////////////////////////////////////////
  88 EFrameworkunifiedXmlNodeTypes CXmlNode::Type() {
  89   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  90   EFrameworkunifiedXmlNodeTypes l_eNodeType = FRAMEWORKUNIFIED_XML_NODE_NONE;
  91
  92   if (NULL != m_pXmlNodePtr) {
  93     switch (m_pXmlNodePtr->type) {
  94       case XML_ELEMENT_NODE:
  95         l_eNodeType = FRAMEWORKUNIFIED_XML_ELEMENT_NODE;
  96         break;
  97       case XML_ATTRIBUTE_NODE:
  98         l_eNodeType = FRAMEWORKUNIFIED_XML_ATTRIBUTE_NODE;
  99         break;
 100       case XML_TEXT_NODE:
 101         l_eNodeType = FRAMEWORKUNIFIED_XML_TEXT_NODE;
 102         break;
 103       case XML_CDATA_SECTION_NODE:
 104         l_eNodeType = FRAMEWORKUNIFIED_XML_CDATA_SECTION_NODE;
 105         break;
 106       case XML_ENTITY_REF_NODE:
 107         l_eNodeType = FRAMEWORKUNIFIED_XML_ENTITY_REF_NODE;
 108         break;
 109       case XML_ENTITY_NODE:
 110         l_eNodeType = FRAMEWORKUNIFIED_XML_ENTITY_NODE;
 111         break;
 112       case XML_PI_NODE:
 113         l_eNodeType = FRAMEWORKUNIFIED_XML_PI_NODE;
 114         break;
 115       case XML_COMMENT_NODE:
 116         l_eNodeType = FRAMEWORKUNIFIED_XML_COMMENT_NODE;
 117         break;
 118       case XML_DOCUMENT_NODE:
 119         l_eNodeType = FRAMEWORKUNIFIED_XML_DOCUMENT_NODE;
 120         break;
 121       case XML_DOCUMENT_TYPE_NODE:
 122         l_eNodeType = FRAMEWORKUNIFIED_XML_DOCUMENT_TYPE_NODE;
 123         break;
 124       case XML_DOCUMENT_FRAG_NODE:
 125         l_eNodeType = FRAMEWORKUNIFIED_XML_DOCUMENT_FRAG_NODE;
 126         break;
 127       case XML_NOTATION_NODE:
 128         l_eNodeType = FRAMEWORKUNIFIED_XML_NOTATION_NODE;
 129         break;
 130       case XML_HTML_DOCUMENT_NODE:
 131         l_eNodeType = FRAMEWORKUNIFIED_XML_HTML_DOCUMENT_NODE;
 132         break;
 133       case XML_DTD_NODE:
 134         l_eNodeType = FRAMEWORKUNIFIED_XML_DTD_NODE;
 135         break;
 136       case XML_ELEMENT_DECL:
 137         l_eNodeType = FRAMEWORKUNIFIED_XML_ELEMENT_DECL;
 138         break;
 139       case XML_ATTRIBUTE_DECL:
 140         l_eNodeType = FRAMEWORKUNIFIED_XML_ATTRIBUTE_DECL;
 141         break;
 142       case XML_ENTITY_DECL:
 143         l_eNodeType = FRAMEWORKUNIFIED_XML_ENTITY_DECL;
 144         break;
 145       case XML_NAMESPACE_DECL:
 146         l_eNodeType = FRAMEWORKUNIFIED_XML_NAMESPACE_DECL;
 147         break;
 148       case XML_XINCLUDE_START:
 149         l_eNodeType = FRAMEWORKUNIFIED_XML_XINCLUDE_START;
 150         break;
 151       case XML_XINCLUDE_END:
 152         l_eNodeType = FRAMEWORKUNIFIED_XML_XINCLUDE_END;
 153         break;
 154       default:
 155         break;
 156     }
 157   }
 158
 159   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 160   return l_eNodeType;
 161 }
 162
 163 ////////////////////////////////////////////////////////////////////////////////////////////////
 164 /// Name
 165 /// Gets the name of node
 166 ////////////////////////////////////////////////////////////////////////////////////////////////
 167 std::string CXmlNode::Name() {
 168   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 169   std::string l_cNodeName = "";
 170
 171   if (NULL != m_pXmlNodePtr && NULL != m_pXmlNodePtr->name) {
 172     l_cNodeName = std::string((PCSTR)m_pXmlNodePtr->name);  // LCOV_EXCL_BR_LINE 11: except branch
 173   }
 174
 175   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 176   return l_cNodeName;
 177 }
 178
 179 ////////////////////////////////////////////////////////////////////////////////////////////////
 180 /// GetContent
 181 /// Gets the content of node
 182 ////////////////////////////////////////////////////////////////////////////////////////////////
 183 std::string CXmlNode::GetContent() {
 184   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 185   std::string l_cText = "";
 186
 187   if ((NULL != m_pXmlNodePtr) &&
 188       (NULL != m_pXmlNodePtr->children) &&
 189       (XML_TEXT_NODE == m_pXmlNodePtr->children->type) &&
 190       (NULL == m_pXmlNodePtr->children->next)) {
 191     xmlChar * p_xmlText = xmlNodeGetContent(m_pXmlNodePtr);
 192     l_cText = std::string((PCSTR)p_xmlText);  // LCOV_EXCL_BR_LINE 11: except branch
 193     xmlFree(p_xmlText);  // LCOV_EXCL_BR_LINE 11: except branch
 194   }
 195
 196   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 197   return l_cText;
 198 }
 199
 200 ////////////////////////////////////////////////////////////////////////////////////////////////
 201 /// SetContent
 202 /// Sets or updates the content of current node.
 203 ////////////////////////////////////////////////////////////////////////////////////////////////
 204 EFrameworkunifiedStatus CXmlNode::SetContent(std::string f_cUpdatedText) {
 205   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 206   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 207
 208   if (NULL != m_pXmlNodePtr) {
 209     xmlNodeSetContent(m_pXmlNodePtr, (const xmlChar *)f_cUpdatedText.c_str());
 210   } else {
 211     l_eStatus = eFrameworkunifiedStatusNullPointer;
 212   }
 213
 214   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 215   return l_eStatus;
 216 }
 217
 218 ////////////////////////////////////////////////////////////////////////////////////////////////
 219 /// GetAttributeValue
 220 /// Gets the attribute's value for the key.
 221 ////////////////////////////////////////////////////////////////////////////////////////////////
 222 EFrameworkunifiedStatus CXmlNode::GetAttributeValue(std::string f_cKey, std::string &f_cAttributeValue) {
 223   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 224   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 225
 226   if (NULL != m_pXmlNodePtr) {
 227     xmlChar *l_pAttrValue = xmlGetProp(m_pXmlNodePtr,
 228                                        (const xmlChar *)f_cKey.c_str());
 229     if (NULL != l_pAttrValue) {
 230       f_cAttributeValue.assign((PCSTR)l_pAttrValue);
 231
 232       xmlFree(l_pAttrValue);
 233       l_pAttrValue = NULL;
 234     } else {
 235       l_eStatus = eFrameworkunifiedStatusNullPointer;
 236       FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Attribute key :: %s not found", f_cKey.c_str());
 237     }
 238   } else {
 239     l_eStatus = eFrameworkunifiedStatusNullPointer;
 240     FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Node ptr is NULL");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"
 241   }
 242
 243   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 244   return l_eStatus;
 245 }
 246
 247 ////////////////////////////////////////////////////////////////////////////////////////////////
 248 /// SetAttributeValue
 249 /// Sets the attribute's value for the key
 250 ////////////////////////////////////////////////////////////////////////////////////////////////
 251 EFrameworkunifiedStatus CXmlNode::SetAttributeValue(std::string f_cKey, std::string f_cValue) {
 252   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 253   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 254
 255   FRAMEWORKUNIFIEDLOG(ZONE_NS_WAR, __FUNCTION__, "SetAttributeValue feature is not available,"
 256       "Reason: This API is not supported by libxml2 present in PosixBasedOS001");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"
 257
 258   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 259   return l_eStatus;
 260 }
 261
 262 ////////////////////////////////////////////////////////////////////////////////////////////////
 263 /// AddNewAttribute
 264 /// Add new attribute to the node
 265 ////////////////////////////////////////////////////////////////////////////////////////////////
 266 EFrameworkunifiedStatus CXmlNode::AddNewAttribute(std::string f_cKey, std::string f_cAttributeValue) {
 267   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 268   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 269   xmlChar* p_key = reinterpret_cast<xmlChar*>(const_cast<char*>(f_cKey.c_str()));
 270   xmlChar* p_value = reinterpret_cast<xmlChar*>(const_cast<char*>(f_cAttributeValue.c_str()));
 271   if (NULL != m_pXmlNodePtr) {
 272     if (NULL == xmlNewNsProp(m_pXmlNodePtr,
 273                              NULL,
 274                              p_key,
 275                              p_value)) {
 276       l_eStatus = eFrameworkunifiedStatusNullPointer;
 277       FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Unable to add new property :: %s", f_cKey.c_str());
 278     }
 279   } else {
 280     l_eStatus = eFrameworkunifiedStatusNullPointer;
 281     FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Node ptr is NULL");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"
 282   }
 283
 284   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 285   return l_eStatus;
 286 }
 287
 288 ////////////////////////////////////////////////////////////////////////////////////////////////
 289 /// RemoveAttribute
 290 /// Removes the attribute from the node with the specified key
 291 ////////////////////////////////////////////////////////////////////////////////////////////////
 292 EFrameworkunifiedStatus CXmlNode::RemoveAttribute(std::string f_cKey) {
 293   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 294   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 295
 296   FRAMEWORKUNIFIEDLOG(ZONE_NS_WAR, __FUNCTION__, "RemoveAttribute feature is not available,"
 297       "Reason: This API is not supported by libxml2 present in PosixBasedOS001");  // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h"
 298
 299   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 300   return l_eStatus;
 301 }
 302
 303 ////////////////////////////////////////////////////////////////////////////////////////////////
 304 /// GetAttributeItems
 305 /// Gets the list of all the attribute's key and value of the node
 306 ////////////////////////////////////////////////////////////////////////////////////////////////
 307 TAttrList CXmlNode::GetAttributeItems() {
 308   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 309   TAttrList l_cAttrList;
 310   std::string l_cKey;
 311   std::string l_cValue;
 312
 313   if (NULL != m_pXmlNodePtr) {
 314     for (xmlAttrPtr l_pAttr = m_pXmlNodePtr->properties;
 315          l_pAttr != NULL;
 316          l_pAttr = l_pAttr->next) {
 317       l_cKey = (PCSTR)l_pAttr->name;
 318       l_cValue = "";
 319
 320       if (NULL != l_pAttr->children) {
 321         l_cValue = (PCSTR)l_pAttr->children->content;
 322       }
 323
 324       CXmlAttr l_pXmlAttr(l_cKey, l_cValue);
 325       l_cAttrList.push_back(l_pXmlAttr);  // LCOV_EXCL_BR_LINE 11: except branch
 326     }
 327   }
 328
 329   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 330   return l_cAttrList;
 331 }
 332
 333 ////////////////////////////////////////////////////////////////////////////////////////////////
 334 /// Parent
 335 /// Gets the parent node
 336 ////////////////////////////////////////////////////////////////////////////////////////////////
 337 CXmlNode CXmlNode::Parent() {
 338   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 339   CXmlNode l_pXmlNode;
 340
 341   if (NULL != m_pXmlNodePtr && NULL != m_pXmlNodePtr->parent) {
 342     if (XML_ELEMENT_NODE == m_pXmlNodePtr->parent->type) {
 343       l_pXmlNode.SetXmlNodePtr(m_pXmlNodePtr->parent);  // LCOV_EXCL_BR_LINE 11: except branch
 344     }
 345   }
 346
 347   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 348   return l_pXmlNode;
 349 }
 350
 351 ////////////////////////////////////////////////////////////////////////////////////////////////
 352 /// FirstChild
 353 /// Gets the first child of node
 354 ////////////////////////////////////////////////////////////////////////////////////////////////
 355 CXmlNode CXmlNode::FirstChild() {
 356   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 357   CXmlNode l_pXmlNode;
 358
 359   if (NULL != m_pXmlNodePtr) {
 360     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->children;
 361          l_pNodePtr != NULL;
 362          l_pNodePtr = l_pNodePtr->next) {
 363       if (XML_ELEMENT_NODE == l_pNodePtr->type) {
 364         l_pXmlNode.SetXmlNodePtr(l_pNodePtr);  // LCOV_EXCL_BR_LINE 11: except branch
 365         break;
 366       }
 367     }
 368   }
 369
 370   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 371   return l_pXmlNode;
 372 }
 373
 374 ////////////////////////////////////////////////////////////////////////////////////////////////
 375 /// LastChild
 376 /// Gets the last child of node
 377 ////////////////////////////////////////////////////////////////////////////////////////////////
 378 CXmlNode CXmlNode::LastChild() {
 379   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 380   CXmlNode l_pXmlNode;
 381
 382   if (NULL != m_pXmlNodePtr) {
 383     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->last;
 384          l_pNodePtr != NULL;
 385          l_pNodePtr = l_pNodePtr->prev) {
 386       if (XML_ELEMENT_NODE == l_pNodePtr->type) {
 387         l_pXmlNode.SetXmlNodePtr(l_pNodePtr);  // LCOV_EXCL_BR_LINE 11: except branch
 388         break;
 389       }
 390     }
 391   }
 392
 393   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 394   return l_pXmlNode;
 395 }
 396
 397 ////////////////////////////////////////////////////////////////////////////////////////////////
 398 /// Children
 399 /// Gets the list of all the child node of current node
 400 ////////////////////////////////////////////////////////////////////////////////////////////////
 401 TNodeList CXmlNode::Children() {
 402   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 403   TNodeList l_pNodeList;
 404
 405   if (NULL != m_pXmlNodePtr) {
 406     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->children;
 407          l_pNodePtr != NULL;
 408          l_pNodePtr = l_pNodePtr->next) {
 409       if (XML_ELEMENT_NODE == l_pNodePtr->type) {
 410         CXmlNode l_pXmlNode(l_pNodePtr);
 411         l_pNodeList.push_back(l_pXmlNode);
 412       }
 413     }
 414   }
 415
 416   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 417   return l_pNodeList;
 418 }
 419
 420 ////////////////////////////////////////////////////////////////////////////////////////////////
 421 /// NextSibling
 422 /// Gets the next sibling node of current node
 423 ////////////////////////////////////////////////////////////////////////////////////////////////
 424 CXmlNode CXmlNode::NextSibling() {
 425   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 426   CXmlNode l_pXmlNode;
 427
 428   if (NULL != m_pXmlNodePtr) {
 429     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->next;
 430          l_pNodePtr != NULL;
 431          l_pNodePtr = l_pNodePtr->next) {
 432       if (XML_ELEMENT_NODE == l_pNodePtr->type) {
 433         l_pXmlNode.SetXmlNodePtr(l_pNodePtr);  // LCOV_EXCL_BR_LINE 11: except branch
 434         break;
 435       }
 436     }
 437   }
 438
 439   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 440   return l_pXmlNode;
 441 }
 442
 443 ////////////////////////////////////////////////////////////////////////////////////////////////
 444 /// PrevSibling
 445 /// Gets the previous sibling node of current node
 446 ////////////////////////////////////////////////////////////////////////////////////////////////
 447 CXmlNode CXmlNode::PrevSibling() {
 448   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 449   CXmlNode l_pXmlNode;
 450
 451   if (NULL != m_pXmlNodePtr) {
 452     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->prev;
 453          l_pNodePtr != NULL;
 454          l_pNodePtr = l_pNodePtr->prev) {
 455       if (XML_ELEMENT_NODE == l_pNodePtr->type) {
 456         l_pXmlNode.SetXmlNodePtr(l_pNodePtr);  // LCOV_EXCL_BR_LINE 11: except branch
 457         break;
 458       }
 459     }
 460   }
 461
 462   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 463   return l_pXmlNode;
 464 }
 465
 466 ////////////////////////////////////////////////////////////////////////////////////////////////
 467 /// FindChildNode
 468 /// Finds the first immediate sub node matching tag as f_cNodeName.
 469 ////////////////////////////////////////////////////////////////////////////////////////////////
 470 CXmlNode CXmlNode::FindChildNode(std::string f_cNodeName) {
 471   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 472   CXmlNode l_pXmlNode;
 473
 474   if (NULL != m_pXmlNodePtr) {
 475     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->children;
 476          l_pNodePtr != NULL;
 477          l_pNodePtr = l_pNodePtr->next) {
 478       if ((XML_ELEMENT_NODE == m_pXmlNodePtr->type) &&
 479           (0 == f_cNodeName.compare((PCSTR)l_pNodePtr->name))) {
 480         l_pXmlNode.SetXmlNodePtr(l_pNodePtr);  // LCOV_EXCL_BR_LINE 11: except branch
 481         break;
 482       }
 483     }
 484   }
 485
 486   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 487   return l_pXmlNode;
 488 }
 489
 490 ////////////////////////////////////////////////////////////////////////////////////////////////
 491 /// FindAllChildNodes
 492 /// Gets the list of all the immediate sub node matching tag as f_cNodeName.
 493 ////////////////////////////////////////////////////////////////////////////////////////////////
 494 TNodeList CXmlNode::FindAllChildNodes(std::string f_cNodeName) {
 495   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 496   TNodeList l_pNodeList;
 497
 498   if (NULL != m_pXmlNodePtr) {
 499     for (xmlNodePtr l_pNodePtr = m_pXmlNodePtr->children;
 500          l_pNodePtr != NULL;
 501          l_pNodePtr = l_pNodePtr->next) {
 502       if ((XML_ELEMENT_NODE == m_pXmlNodePtr->type) &&
 503           (0 == f_cNodeName.compare((PCSTR)l_pNodePtr->name))) {
 504         CXmlNode l_pXmlNode(l_pNodePtr);
 505         l_pNodeList.push_back(l_pXmlNode);
 506       }
 507     }
 508   }
 509
 510   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 511   return l_pNodeList;
 512 }
 513
 514 ////////////////////////////////////////////////////////////////////////////////////////////////
 515 /// GetContentOfChildNode
 516 /// Finds the first level sub node matching tag as f_cNodeName.
 517 ////////////////////////////////////////////////////////////////////////////////////////////////
 518 EFrameworkunifiedStatus CXmlNode::GetContentOfChildNode(std::string f_cNodeName, std::string &f_cContent) {
 519   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 520   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 521
 522   CXmlNode l_pXmlNode = FindChildNode(f_cNodeName);
 523
 524   if (!l_pXmlNode.IsNull()) {
 525     f_cContent.assign(l_pXmlNode.GetContent());
 526   } else {
 527     l_eStatus = eFrameworkunifiedStatusFail;
 528   }
 529
 530   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 531   return l_eStatus;
 532 }
 533
 534 ////////////////////////////////////////////////////////////////////////////////////////////////
 535 /// AddChildNode
 536 /// Adds sub node to the current node
 537 ////////////////////////////////////////////////////////////////////////////////////////////////
 538 CXmlNode CXmlNode::AddChildNode(std::string f_cNodeName, std::string f_cText) {
 539   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 540
 541   // pointer of child node
 542   xmlNodePtr l_pChildNode = NULL;
 543
 544   // content of child node
 545   xmlChar *l_cNodeContent = NULL;
 546
 547   // validate the node name
 548   if (NULL != m_pXmlNodePtr && 0 < f_cNodeName.length()) {
 549     if (0 < f_cText.length()) {
 550       xmlChar* p_text = reinterpret_cast<xmlChar*>(const_cast<char*>(f_cText.c_str()));
 551       l_cNodeContent = p_text;
 552     }
 553
 554     if (NULL == (l_pChildNode = xmlNewDocNode(m_pXmlNodePtr->doc,
 555                                               m_pXmlNodePtr->ns,
 556                                               (const xmlChar *)f_cNodeName.c_str(),
 557                                               l_cNodeContent))) {
 558       FRAMEWORKUNIFIEDLOG(ZONE_NS_ERR, __FUNCTION__, "Error creating child node");
 559     } else {
 560       l_pChildNode->type = XML_ELEMENT_NODE;
 561       l_pChildNode->parent = m_pXmlNodePtr;
 562       l_pChildNode->doc = m_pXmlNodePtr->doc;
 563
 564       // if there is no other child to the parent
 565       if (m_pXmlNodePtr->children == NULL) {
 566         m_pXmlNodePtr->children = l_pChildNode;
 567         m_pXmlNodePtr->last = l_pChildNode;
 568       } else {  // else add the new child to the end of children list
 569         // temp node
 570         xmlNodePtr l_pTempNode = m_pXmlNodePtr->last;
 571         l_pTempNode->next = l_pChildNode;
 572         l_pChildNode->prev = l_pTempNode;
 573
 574         m_pXmlNodePtr->last = l_pChildNode;
 575       }
 576     }
 577   }
 578
 579   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 580   return CXmlNode(l_pChildNode);
 581 }
 582
 583 ////////////////////////////////////////////////////////////////////////////////////////////////
 584 /// AddSiblingNode
 585 /// Adds new node as sibling to the current node
 586 ////////////////////////////////////////////////////////////////////////////////////////////////
 587 CXmlNode CXmlNode::AddSiblingNode(std::string f_cNodeName, std::string f_cText) {
 588   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 589
 590   xmlNodePtr l_pNewNode = NULL;
 591   xmlNodePtr l_pSiblingNode = NULL;
 592
 593   if (NULL != m_pXmlNodePtr &&
 594       !this->Parent().IsNull()) {  // check whether the node is root node
 595     if (NULL != (l_pNewNode = xmlNewNode(NULL,
 596                                          (const xmlChar *)f_cNodeName.c_str()))) {
 597       if (0 < f_cText.length()) {
 598         xmlChar* p_text = reinterpret_cast<xmlChar*>(const_cast<char*>(f_cText.c_str()));
 599         xmlNodeSetContent(l_pNewNode, p_text);
 600       }
 601
 602       l_pSiblingNode = xmlAddSibling(m_pXmlNodePtr,
 603                                      l_pNewNode);
 604     }
 605   }
 606
 607   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 608   return CXmlNode(l_pSiblingNode);
 609 }
 610
 611 ////////////////////////////////////////////////////////////////////////////////////////////////
 612 /// RemoveChildNode
 613 /// Removes the child node from current node
 614 ////////////////////////////////////////////////////////////////////////////////////////////////
 615 EFrameworkunifiedStatus CXmlNode::RemoveChildNode(std::string f_cNodeName) {
 616   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 617   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 618
 619   CXmlNode l_pXmlNode = FindChildNode(f_cNodeName);
 620   if (!l_pXmlNode.IsNull()) {
 621     xmlUnlinkNode(l_pXmlNode.m_pXmlNodePtr);
 622     xmlFreeNode(l_pXmlNode.m_pXmlNodePtr);
 623   } else {
 624     l_eStatus = eFrameworkunifiedStatusNullPointer;
 625   }
 626
 627   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 628   return l_eStatus;
 629 }
 630
 631 ////////////////////////////////////////////////////////////////////////////////////////////////
 632 /// ClearNode
 633 /// Clears the contents, attributes of node
 634 ////////////////////////////////////////////////////////////////////////////////////////////////
 635 EFrameworkunifiedStatus CXmlNode::ClearNode() {
 636   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 637   EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
 638
 639   if (NULL != m_pXmlNodePtr) {
 640     for (xmlNodePtr l_pXmlNode = m_pXmlNodePtr->children;
 641          l_pXmlNode != NULL;
 642          l_pXmlNode = m_pXmlNodePtr->children) {
 643       xmlUnlinkNode(l_pXmlNode);
 644       xmlFreeNode(l_pXmlNode);
 645     }
 646
 647     for (xmlAttrPtr l_pXmlAttr = m_pXmlNodePtr->properties;
 648          l_pXmlAttr != NULL;
 649          l_pXmlAttr = m_pXmlNodePtr->properties) {
 650       xmlRemoveProp(l_pXmlAttr);
 651     }
 652   } else {
 653     l_eStatus = eFrameworkunifiedStatusNullPointer;
 654   }
 655
 656   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 657   return l_eStatus;
 658 }