service/native/framework_unified/client/include/native_service/ns_xmlparser_if.h

   1 /**
   2  * @file ns_xmlparser_if.h
   3  * @brief \~english This file contains declaration of class CXmlParser, CXmlNode and CXmlAttr.
   4  *        This file provides the interface for Parsing XML file, API for operation on node
   5  *        of an xml structure.
   6  *
   7  */
   8 /** @addtogroup BaseSystem
   9  *  @{
  10  */
  11 /** @addtogroup native_service
  12  *  @ingroup BaseSystem
  13  *  @{
  14  */
  15 /** @addtogroup framework_unified
  16  *  @ingroup native_service
  17  *  @{
  18  */
  19 /*
  20  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
  21  *
  22  * Licensed under the Apache License, Version 2.0 (the "License");
  23  * you may not use this file except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *      http://www.apache.org/licenses/LICENSE-2.0
  27  *
  28  * Unless required by applicable law or agreed to in writing, software
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  */
  34
  35 #ifndef __FRAMEWORKUNIFIED_NATIVESERVICES_NS_XMLPARSER_INC_NS_XMLPARSER_IF_H__  // NOLINT  (build/header_guard)
  36 #define __FRAMEWORKUNIFIED_NATIVESERVICES_NS_XMLPARSER_INC_NS_XMLPARSER_IF_H__
  37
  38 ////////////////////////////////////////////////////////////////////////////////////////////////////
  39 /// Include Files
  40 ////////////////////////////////////////////////////////////////////////////////////////////////////
  41 #include <native_service/frameworkunified_types.h>
  42
  43 #include <libxml/tree.h>
  44 #include <libxml/xpath.h>
  45 #include <string>
  46 #include <list>
  47
  48 // defines the type of xml nodes
  49 /**
  50  * \~english  type of xml nodes
  51  */
  52 typedef enum _EFrameworkunifiedXmlNodeTypes {
  53   FRAMEWORKUNIFIED_XML_NODE_NONE = 0,  //!< \~english not exist node
  54   FRAMEWORKUNIFIED_XML_ELEMENT_NODE = 1,  //!< \~english element node
  55   FRAMEWORKUNIFIED_XML_ATTRIBUTE_NODE = 2,  //!< \~english attribute node
  56   FRAMEWORKUNIFIED_XML_TEXT_NODE = 3,  //!< \~english text node
  57   FRAMEWORKUNIFIED_XML_CDATA_SECTION_NODE = 4,  //!< \~english section node
  58   FRAMEWORKUNIFIED_XML_ENTITY_REF_NODE = 5,  //!< \~english entity ref node
  59   FRAMEWORKUNIFIED_XML_ENTITY_NODE = 6,  //!< \~english entity node
  60   FRAMEWORKUNIFIED_XML_PI_NODE = 7,  //!< \~english PI node
  61   FRAMEWORKUNIFIED_XML_COMMENT_NODE = 8,  //!< \~english comment node
  62   FRAMEWORKUNIFIED_XML_DOCUMENT_NODE = 9,  //!< \~english document node
  63   FRAMEWORKUNIFIED_XML_DOCUMENT_TYPE_NODE = 10,  //!< \~english document type node
  64   FRAMEWORKUNIFIED_XML_DOCUMENT_FRAG_NODE = 11,  //!< \~english document frag node
  65   FRAMEWORKUNIFIED_XML_NOTATION_NODE = 12,  //!< \~english notation node
  66   FRAMEWORKUNIFIED_XML_HTML_DOCUMENT_NODE = 13,  //!< \~english document node
  67   FRAMEWORKUNIFIED_XML_DTD_NODE = 14,  //!< \~english dtd node
  68   FRAMEWORKUNIFIED_XML_ELEMENT_DECL = 15,  //!< \~english element decl
  69   FRAMEWORKUNIFIED_XML_ATTRIBUTE_DECL = 16,  //!< \~english attribute decl
  70   FRAMEWORKUNIFIED_XML_ENTITY_DECL = 17,  //!< \~english entity decl
  71   FRAMEWORKUNIFIED_XML_NAMESPACE_DECL = 18,  //!< \~english namespace decl
  72   FRAMEWORKUNIFIED_XML_XINCLUDE_START = 19,  //!< \~english include start
  73   FRAMEWORKUNIFIED_XML_XINCLUDE_END = 20,  //!< \~english include end
  74   FRAMEWORKUNIFIED_XML_DOCB_DOCUMENT_NODE = 21  //!< \~english document node
  75 } EFrameworkunifiedXmlNodeTypes;
  76
  77 // forward declaration
  78 class CXmlNode;
  79 class CXmlAttr;
  80
  81 // list of CXmlNode
  82 typedef std::list<CXmlNode> TNodeList;
  83 typedef TNodeList::iterator TNodeListIterator;
  84
  85 // list of CXmlAttr
  86 typedef std::list<CXmlAttr> TAttrList;
  87 typedef std::list<CXmlAttr>::iterator TAttrListIterator;
  88
  89
  90 /**
  91  * @class CXmlNode
  92  * \~english @brief This class represents node of an XML.
  93  * \~english @par   Brief Introduction
  94  *        Provides API for performing operations on node.
  95  *
  96  */
  97 class CXmlNode {
  98   friend class CXmlParser;
  99
 100  public:
 101   ////////////////////////////////////////////////////////////////////////////////
 102   /// \ingroup CXmlNode
 103   /// \~english @par Brief
 104   ///       Destructor of CXmlNode class
 105   /// \~english @param None
 106   /// \~english @retval None
 107   /// \~english @par Prerequisite
 108   ///       - None
 109   /// \~english @par Inside state change
 110   ///       - None
 111   /// \~english @par None
 112   /// \~english @par Classification
 113   ///       Public
 114   /// \~english @par Type
 115   ///       Sync Only
 116   /// \~english @par Detail
 117   ///       Destructor of CXmlNode class
 118   /// \~english @see None
 119   ////////////////////////////////////////////////////////////////////////////////
 120   ~CXmlNode();
 121
 122   ////////////////////////////////////////////////////////////////////////////////
 123   /// \ingroup IsNull
 124   /// \~english @par Brief
 125   ///       Check xmlNodePtr
 126   /// \~english @param None
 127   /// \~english @retval BOOL true if valid else false
 128   /// \~english @par Prerequisite
 129   ///       - Load the shared library first
 130   ///       - Get CXmlNode from CXmlParser
 131   /// \~english @par Inside state change
 132   ///       - The API no inside state change
 133   /// \~english @par None
 134   /// \~english @par Classification
 135   ///       Public
 136   /// \~english @par Type
 137   ///       Sync Only
 138   /// \~english @par Detail
 139   ///       Checks whether the corresponding xmlNodePtr is valid or not
 140   /// \~english @see CXmlNode
 141   ////////////////////////////////////////////////////////////////////////////////
 142
 143   BOOL IsNull();
 144
 145   ////////////////////////////////////////////////////////////////////////////////
 146   /// \ingroup Type
 147   /// \~english @par Brief
 148   ///       Get type
 149   /// \~english @param  None
 150   /// \~english @retval FRAMEWORKUNIFIED_XML_NODE_NONE  not exist node
 151   /// \~english @retval FRAMEWORKUNIFIED_XML_ELEMENT_NODE   element node
 152   /// \~english @retval FRAMEWORKUNIFIED_XML_TEXT_NODE  text node
 153   /// \~english @retval FRAMEWORKUNIFIED_XML_CDATA_SECTION_NODE   section node
 154   /// \~english @retval FRAMEWORKUNIFIED_XML_ENTITY_REF_NODE  entity ref node
 155   /// \~english @retval FRAMEWORKUNIFIED_XML_ENTITY_NODE  entity node
 156   /// \~english @retval FRAMEWORKUNIFIED_XML_PI_NODE  PI node
 157   /// \~english @retval FRAMEWORKUNIFIED_XML_COMMENT_NODE   comment node
 158   /// \~english @retval FRAMEWORKUNIFIED_XML_DOCUMENT_NODE  document node
 159   /// \~english @retval FRAMEWORKUNIFIED_XML_DOCUMENT_TYPE_NODE   document type node
 160   /// \~english @retval FRAMEWORKUNIFIED_XML_DOCUMENT_FRAG_NODE   document frag node
 161   /// \~english @retval FRAMEWORKUNIFIED_XML_NOTATION_NODE  notation node
 162   /// \~english @retval FRAMEWORKUNIFIED_XML_HTML_DOCUMENT_NODE   document node
 163   /// \~english @retval FRAMEWORKUNIFIED_XML_DTD_NODE   dtd node
 164   /// \~english @retval FRAMEWORKUNIFIED_XML_ELEMENT_DECL   element decl
 165   /// \~english @retval FRAMEWORKUNIFIED_XML_ATTRIBUTE_DECL   attribute decl
 166   /// \~english @retval FRAMEWORKUNIFIED_XML_ENTITY_DECL  entity decl
 167   /// \~english @retval FRAMEWORKUNIFIED_XML_NAMESPACE_DECL   namespace decl
 168   /// \~english @retval FRAMEWORKUNIFIED_XML_XINCLUDE_START   include start
 169   /// \~english @retval FRAMEWORKUNIFIED_XML_XINCLUDE_END   include end
 170   /// \~english @retval FRAMEWORKUNIFIED_XML_DOCB_DOCUMENT_NODE   document node
 171   /// \~english @par Prerequisite
 172   ///       - Load the shared library first
 173   ///       - Get CXmlNode from CXmlParser
 174   /// \~english @par Inside state change
 175   ///       - The API no inside state change
 176   /// \~english @par None
 177   /// \~english @par Classification
 178   ///       Public
 179   /// \~english @par Type
 180   ///       Sync Only
 181   /// \~english @par Detail
 182   ///       Gets the type of XML node
 183   /// \~english @see CXmlNode
 184   ////////////////////////////////////////////////////////////////////////////////
 185
 186   EFrameworkunifiedXmlNodeTypes Type();
 187
 188   ////////////////////////////////////////////////////////////////////////////////
 189   /// \ingroup Name
 190   /// \~english @par Brief
 191   ///       Get name
 192   /// \~english @param  None
 193   /// \~english @retval std::string node name
 194   /// \~english @par Prerequisite
 195   ///       - Load the shared library first
 196   ///       - Get CXmlNode from CXmlParser
 197   /// \~english @par Inside state change
 198   ///       - The API no inside state change
 199   /// \~english @par None
 200   /// \~english @par Classification
 201   ///       Public
 202   /// \~english @par Type
 203   ///       Sync Only
 204   /// \~english @par Detail
 205   ///       Get the name/tag of an XML node
 206   /// \~english @see CXmlNode
 207   ////////////////////////////////////////////////////////////////////////////////
 208
 209   std::string Name();
 210
 211   ////////////////////////////////////////////////////////////////////////////////
 212   /// \ingroup GetContent
 213   /// \~english @par Brief
 214   ///       Get content
 215   /// \~english @param  None
 216   /// \~english @retval std::string content of current node
 217   /// \~english @par Prerequisite
 218   ///       - Load the shared library first
 219   ///       - Get CXmlNode from CXmlParser
 220   /// \~english @par Inside state change
 221   ///       - The API no inside state change
 222   /// \~english @par None
 223   /// \~english @par Classification
 224   ///       Public
 225   /// \~english @par Type
 226   ///       Sync Only
 227   /// \~english @par Detail
 228   ///       Gets the content of current node
 229   /// \~english @see CXmlNode
 230   ////////////////////////////////////////////////////////////////////////////////
 231
 232   std::string GetContent();
 233
 234   ////////////////////////////////////////////////////////////////////////////////
 235   /// \ingroup SetContent
 236   /// \~english @par Brief
 237   ///       Set content
 238   /// \~english @param  [IN] f_cUpdatedText
 239   ///       std::string  - updated value
 240   /// \~english @retval eFrameworkunifiedStatusOK Success
 241   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 242   /// \~english @par Prerequisite
 243   ///       - Load the shared library first
 244   ///       - Get CXmlNode from CXmlParser
 245   /// \~english @par Inside state change
 246   ///       - The API no inside state change
 247   /// \~english @par None
 248   /// \~english @par Classification
 249   ///       Public
 250   /// \~english @par Type
 251   ///       Sync Only
 252   /// \~english @par Detail
 253   ///       Set or update the content of current node. If the node has children then it removes all the child
 254   ///       nodes and sets the content for the current node.
 255   /// \~english @see CXmlNode
 256   ////////////////////////////////////////////////////////////////////////////////
 257
 258   EFrameworkunifiedStatus SetContent(std::string f_cUpdatedText);
 259
 260   ////////////////////////////////////////////////////////////////////////////////
 261   /// \ingroup GetAttributeValue
 262   /// \~english @par Brief
 263   ///       Get attribute
 264   /// \~english @param  [IN] f_cKey
 265   ///       std::string - attribute name
 266   /// \~english @param  [OUT] f_cAttributeValue
 267   ///       std::string& - attribute value
 268   /// \~english @retval eFrameworkunifiedStatusOK Success
 269   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 270   /// \~english @par Prerequisite
 271   ///       - Load the shared library first
 272   ///       - Get CXmlNode from CXmlParser
 273   /// \~english @par Inside state change
 274   ///       - The API no inside state change
 275   /// \~english @par None
 276   /// \~english @par Classification
 277   ///       Public
 278   /// \~english @par Type
 279   ///       Sync Only
 280   /// \~english @par Detail
 281   ///       Get the attribute's value for the key
 282   /// \~english @see CXmlNode
 283   ////////////////////////////////////////////////////////////////////////////////
 284
 285   EFrameworkunifiedStatus GetAttributeValue(std::string f_cKey, std::string &f_cAttributeValue);  // NOLINT  (readability/nolint)
 286
 287   ////////////////////////////////////////////////////////////////////////////////
 288   /// \ingroup SetAttributeValue
 289   /// \~english @par Brief
 290   ///       Set attribute
 291   /// \~english @param  [IN] f_cKey
 292   ///       std::string - attribute name
 293   /// \~english @param  [IN] f_cValue
 294   ///       std::string - attribute value
 295   /// \~english @retval eFrameworkunifiedStatusOK Success
 296   /// \~english @par Prerequisite
 297   ///       - Load the shared library first
 298   ///       - Get CXmlNode from CXmlParser
 299   /// \~english @par Inside state change
 300   ///       - The API no inside state change
 301   /// \~english @par None
 302   /// \~english @par Classification
 303   ///       Public
 304   /// \~english @par Type
 305   ///       Sync Only
 306   /// \~english @par Detail
 307   ///       Set the attribute's value for the key
 308   ///       If attribute is not found then new attribute key-value pair is created and added to node
 309   /// \~english @see CXmlNode
 310   ////////////////////////////////////////////////////////////////////////////////
 311
 312   EFrameworkunifiedStatus SetAttributeValue(std::string f_cKey, std::string f_cValue);
 313
 314   ////////////////////////////////////////////////////////////////////////////////
 315   /// \ingroup AddNewAttribute
 316   /// \~english @par Brief
 317   ///       Add new attribute
 318   /// \~english @param  [IN] f_cKey
 319   ///       std::string - attribute name
 320   /// \~english @param  [IN] f_cValue
 321   ///       std::string - attribute value
 322   /// \~english @retval eFrameworkunifiedStatusOK Success
 323   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 324   /// \~english @par Prerequisite
 325   ///       - Load the shared library first
 326   ///       - Get CXmlNode from CXmlParser
 327   /// \~english @par Inside state change
 328   ///       - The API no inside state change
 329   /// \~english @par None
 330   /// \~english @par Classification
 331   ///       Public
 332   /// \~english @par Type
 333   ///       Sync Only
 334   /// \~english @par Detail
 335   ///       Add new attribute to the node. If the attribute key is existing then it updates the existing
 336   ///       value with the new value or else adds the new attribute
 337   /// \~english @see CXmlNode
 338   ////////////////////////////////////////////////////////////////////////////////
 339
 340   EFrameworkunifiedStatus AddNewAttribute(std::string f_cKey, std::string f_cAttributeValue);
 341
 342   ////////////////////////////////////////////////////////////////////////////////
 343   /// \ingroup RemoveAttribute
 344   /// \~english @par Brief
 345   ///       Removes attribute
 346   /// \~english @param  [IN] f_cKey
 347   ///       std::string - attribute name
 348   /// \~english @retval eFrameworkunifiedStatusOK Success
 349   /// \~english @par Prerequisite
 350   ///       - Load the shared library first
 351   ///       - Get CXmlNode from CXmlParser
 352   /// \~english @par Inside state change
 353   ///       - The API no inside state change
 354   /// \~english @par None
 355   /// \~english @par Classification
 356   ///       Public
 357   /// \~english @par Type
 358   ///       Sync Only
 359   /// \~english @par Detail
 360   ///       Remove the attribute from the node with the specified key
 361   /// \~english @see CXmlNode
 362   ////////////////////////////////////////////////////////////////////////////////
 363
 364   EFrameworkunifiedStatus RemoveAttribute(std::string f_cKey);
 365
 366   ////////////////////////////////////////////////////////////////////////////////
 367   /// \ingroup GetAttributeItems
 368   /// \~english @par Brief
 369   ///       Get attributes list
 370   /// \~english @param  None
 371   /// \~english @retval TAttrList - list of all attributes of node or empty list in case of no attributes
 372   /// \~english @par Prerequisite
 373   ///       - Load the shared library first
 374   ///       - Get CXmlNode from CXmlParser
 375   /// \~english @par Inside state change
 376   ///       - The API no inside state change
 377   /// \~english @par None
 378   /// \~english @par Classification
 379   ///       Public
 380   /// \~english @par Type
 381   ///       Sync Only
 382   /// \~english @par Detail
 383   ///       Get the list of all the attribute's key and value of the node
 384   /// \~english @see CXmlNode
 385   ////////////////////////////////////////////////////////////////////////////////
 386
 387   TAttrList GetAttributeItems();
 388
 389   ////////////////////////////////////////////////////////////////////////////////
 390   /// \ingroup Parent
 391   /// \~english @par Brief
 392   ///       Get parent
 393   /// \~english @param  None
 394   /// \~english @retval CXmlNode - node object
 395   /// \~english @par Prerequisite
 396   ///       - Load the shared library first
 397   ///       - Get CXmlNode from CXmlParser
 398   /// \~english @par Inside state change
 399   ///       - The API no inside state change
 400   /// \~english @par None
 401   /// \~english @par Classification
 402   ///       Public
 403   /// \~english @par Type
 404   ///       Sync Only
 405   /// \~english @par Detail
 406   ///       Get the parent node of current node
 407   /// \~english @see CXmlNode
 408   ////////////////////////////////////////////////////////////////////////////////
 409
 410
 411   CXmlNode Parent();
 412
 413   ////////////////////////////////////////////////////////////////////////////////
 414   /// \ingroup FirstChild
 415   /// \~english @par Brief
 416   ///       Get first child
 417   /// \~english @param  None
 418   /// \~english @retval CXmlNode - node object
 419   /// \~english @par Prerequisite
 420   ///       - Load the shared library first
 421   ///       - Get CXmlNode from CXmlParser
 422   /// \~english @par Inside state change
 423   ///       - The API no inside state change
 424   /// \~english @par None
 425   /// \~english @par Classification
 426   ///       Public
 427   /// \~english @par Type
 428   ///       Sync Only
 429   /// \~english @par Detail
 430   ///       Get the first child node of current node
 431   /// \~english @see CXmlNode
 432   ////////////////////////////////////////////////////////////////////////////////
 433
 434   CXmlNode FirstChild();
 435
 436   ////////////////////////////////////////////////////////////////////////////////
 437   /// \ingroup LastChild
 438   /// \~english @par Brief
 439   ///       Get last child
 440   /// \~english @param  None
 441   /// \~english @retval CXmlNode - node object
 442   /// \~english @par Prerequisite
 443   ///       - Load the shared library first
 444   ///       - Get CXmlNode from CXmlParser
 445   /// \~english @par Inside state change
 446   ///       - The API no inside state change
 447   /// \~english @par None
 448   /// \~english @par Classification
 449   ///       Public
 450   /// \~english @par Type
 451   ///       Sync Only
 452   /// \~english @par Detail
 453   ///       Get the last child node of current node
 454   /// \~english @see CXmlNode
 455   ////////////////////////////////////////////////////////////////////////////////
 456
 457   CXmlNode LastChild();
 458
 459   ////////////////////////////////////////////////////////////////////////////////
 460   /// \ingroup Children
 461   /// \~english @par Brief
 462   ///       Get child list
 463   /// \~english @param  None
 464   /// \~english @retval TNodeList - list of all child node object
 465   /// \~english @par Prerequisite
 466   ///       - Load the shared library first
 467   ///       - Get CXmlNode from CXmlParser
 468   /// \~english @par Inside state change
 469   ///       - The API no inside state change
 470   /// \~english @par None
 471   /// \~english @par Classification
 472   ///       Public
 473   /// \~english @par Type
 474   ///       Sync Only
 475   /// \~english @par Detail
 476   ///       Get the list of all the child nodes of current node
 477   /// \~english @see CXmlNode
 478   ////////////////////////////////////////////////////////////////////////////////
 479
 480   TNodeList Children();
 481
 482   ////////////////////////////////////////////////////////////////////////////////
 483   /// \ingroup NextSibling
 484   /// \~english @par Brief
 485   ///       Get next node
 486   /// \~english @param  None
 487   /// \~english @retval CXmlNode - node object
 488   /// \~english @par Prerequisite
 489   ///       - Load the shared library first
 490   ///       - Get CXmlNode from CXmlParser
 491   /// \~english @par Inside state change
 492   ///       - The API no inside state change
 493   /// \~english @par None
 494   /// \~english @par Classification
 495   ///       Public
 496   /// \~english @par Type
 497   ///       Sync Only
 498   /// \~english @par Detail
 499   ///       Get the next sibling node of current node
 500   /// \~english @see CXmlNode
 501   ////////////////////////////////////////////////////////////////////////////////
 502
 503   CXmlNode NextSibling();
 504
 505   ////////////////////////////////////////////////////////////////////////////////
 506   /// \ingroup PrevSibling
 507   /// \~english @par Brief
 508   ///       Get previous node
 509   /// \~english @param  None
 510   /// \~english @retval CXmlNode - node object
 511   /// \~english @par Prerequisite
 512   ///       - Load the shared library first
 513   ///       - Get CXmlNode from CXmlParser
 514   /// \~english @par Inside state change
 515   ///       - The API no inside state change
 516   /// \~english @par None
 517   /// \~english @par Classification
 518   ///       Public
 519   /// \~english @par Type
 520   ///       Sync Only
 521   /// \~english @par Detail
 522   ///       Get the previous sibling node of current node
 523   /// \~english @see CXmlNode
 524   ////////////////////////////////////////////////////////////////////////////////
 525
 526   CXmlNode PrevSibling();
 527
 528   ////////////////////////////////////////////////////////////////////////////////
 529   /// \ingroup FindChildNode
 530   /// \~english @par Brief
 531   ///       Find child node
 532   /// \~english @param  [IN] f_cNodeName std::string - tag name of the node
 533   /// \~english @retval CXmlNode - node object
 534   /// \~english @par Prerequisite
 535   ///       - Load the shared library first
 536   ///       - Get CXmlNode from CXmlParser
 537   /// \~english @par Inside state change
 538   ///       - The API no inside state change
 539   /// \~english @par None
 540   /// \~english @par Classification
 541   ///       Public
 542   /// \~english @par Type
 543   ///       Sync Only
 544   /// \~english @par Detail
 545   ///       Get the first immediate sub node with matching node name
 546   ///       This function does not provide support to find node based on attribute value
 547   ///       Use FindNode() API of CXmlParser to find node based on XPath expression
 548   /// \~english @see CXmlNode
 549   ////////////////////////////////////////////////////////////////////////////////
 550
 551
 552   CXmlNode FindChildNode(std::string f_cNodeName);
 553
 554   ////////////////////////////////////////////////////////////////////////////////
 555   /// \ingroup FindAllChildNodes
 556   /// \~english @par Brief
 557   ///       Get list of all the immediate sub node
 558   /// \~english @param  [IN] f_cNodeName std::string - tag name of the node
 559   /// \~english @retval TNodeList - list of matching nodes
 560   /// \~english @par Prerequisite
 561   ///       - Load the shared library first
 562   ///       - Get CXmlNode from CXmlParser
 563   /// \~english @par Inside state change
 564   ///       - The API no inside state change
 565   /// \~english @par None
 566   /// \~english @par Classification
 567   ///       Public
 568   /// \~english @par Type
 569   ///       Sync Only
 570   /// \~english @par Detail
 571   ///       Get the list of all the immediate sub node matching tag as f_cNodeName.
 572   ///       This function does not provide support to find node based on attribute value.
 573   ///       Use FindNode() API of CXmlParser to find node based on XPath expression.
 574   /// \~english @see CXmlNode
 575   ////////////////////////////////////////////////////////////////////////////////
 576
 577   TNodeList FindAllChildNodes(std::string f_cNodeName);
 578
 579   ////////////////////////////////////////////////////////////////////////////////
 580   /// \ingroup GetContentOfChildNode
 581   /// \~english @par Brief
 582   ///       Find first level node
 583   /// \~english @param  [IN] f_cNodeName
 584   ///       std::string - name of the node
 585   /// \~english @param  [OUT] f_cContent
 586   ///       std::string& - content of the node
 587   /// \~english @retval eFrameworkunifiedStatusOK Success
 588   /// \~english @retval eFrameworkunifiedStatusFail Failed
 589   /// \~english @par Prerequisite
 590   ///       - Load the shared library first
 591   ///       - Get CXmlNode from CXmlParser
 592   /// \~english @par Inside state change
 593   ///       - The API no inside state change
 594   /// \~english @par None
 595   /// \~english @par Classification
 596   ///       Public
 597   /// \~english @par Type
 598   ///       Sync Only
 599   /// \~english @par Detail
 600   ///       Find the first level sub node matching tag as f_cNodeName
 601   /// \~english @see CXmlNode
 602   ////////////////////////////////////////////////////////////////////////////////
 603
 604   EFrameworkunifiedStatus GetContentOfChildNode(std::string f_cNodeName, std::string &f_cContent);  // NOLINT  (readability/nolint)
 605
 606   ////////////////////////////////////////////////////////////////////////////////
 607   /// \ingroup AddChildNode
 608   /// \~english @par Brief
 609   ///       Add sub node
 610   /// \~english @param  [IN] f_cNodeName
 611   ///       std::string - tag of the new node
 612   /// \~english @param  [IN] f_cText
 613   ///       std::string - content of the new node
 614   /// \~english @retval CXmlNode - object of child node
 615   /// \~english @par Prerequisite
 616   ///       - Load the shared library first
 617   ///       - Get CXmlNode from CXmlParser
 618   /// \~english @par Inside state change
 619   ///       - The API no inside state change
 620   /// \~english @par None
 621   /// \~english @par Classification
 622   ///       Public
 623   /// \~english @par Type
 624   ///       Sync Only
 625   /// \~english @par Detail
 626   ///       Add sub node to the current node
 627   /// \~english @see CXmlNode
 628   ////////////////////////////////////////////////////////////////////////////////
 629
 630   CXmlNode AddChildNode(std::string f_cNodeName, std::string f_cText = "");
 631
 632   ////////////////////////////////////////////////////////////////////////////////
 633   /// \ingroup AddSiblingNode
 634   /// \~english @par Brief
 635   ///       Add new node to siblings
 636   /// \~english @param  [IN] f_cNodeName
 637   ///       std::string - tag of the new node
 638   /// \~english @param  [IN] f_cText
 639   ///       std::string - content of the new node
 640   /// \~english @retval CXmlNode - object of sibling node
 641   /// \~english @par Prerequisite
 642   ///       - Load the shared library first
 643   ///       - Get CXmlNode from CXmlParser
 644   /// \~english @par Inside state change
 645   ///       - The API no inside state change
 646   /// \~english @par None
 647   /// \~english @par Classification
 648   ///       Public
 649   /// \~english @par Type
 650   ///       Sync Only
 651   /// \~english @par Detail
 652   ///       Add a new node to the list of siblings of current node
 653   /// \~english @see CXmlNode
 654   ////////////////////////////////////////////////////////////////////////////////
 655
 656   CXmlNode AddSiblingNode(std::string f_cNodeName, std::string f_cText = "");
 657
 658   ////////////////////////////////////////////////////////////////////////////////
 659   /// \ingroup RemoveChildNode
 660   /// \~english @par Brief
 661   ///       Remove child node
 662   /// \~english @param  [IN] f_cNodeName
 663   ///       std::string - name of child node
 664   /// \~english @retval eFrameworkunifiedStatusOK Success
 665   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 666   /// \~english @par Prerequisite
 667   ///       - Load the shared library first
 668   ///       - Get CXmlNode from CXmlParser
 669   /// \~english @par Inside state change
 670   ///       - The API no inside state change
 671   /// \~english @par None
 672   /// \~english @par Classification
 673   ///       Public
 674   /// \~english @par Type
 675   ///       Sync Only
 676   /// \~english @par Detail
 677   ///       Remove the child node from current node
 678   /// \~english @see CXmlNode
 679   ////////////////////////////////////////////////////////////////////////////////
 680
 681   EFrameworkunifiedStatus RemoveChildNode(std::string f_cNodeName);
 682
 683   ////////////////////////////////////////////////////////////////////////////////
 684   /// \ingroup ClearNode
 685   /// \~english @par Brief
 686   ///       Removes elements and attributes
 687   /// \~english @param  None
 688   /// \~english @retval eFrameworkunifiedStatusOK Success
 689   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 690   /// \~english @par Prerequisite
 691   ///       - Load the shared library first
 692   ///       - Get CXmlNode from CXmlParser
 693   /// \~english @par Inside state change
 694   ///       - The API no inside state change
 695   /// \~english @par None
 696   /// \~english @par Classification
 697   ///       Public
 698   /// \~english @par Type
 699   ///       Sync Only
 700   /// \~english @par Detail
 701   ///       This function removes all sub elements, clears all attributes,
 702   ///       and sets the text and tail attributes to None
 703   /// \~english @see CXmlNode
 704   ////////////////////////////////////////////////////////////////////////////////
 705   EFrameworkunifiedStatus ClearNode();
 706
 707  private:
 708   ////////////////////////////////////////////////////////////////////////////////////////////////
 709   /// CXmlNode
 710   /// Constructor of CXmlNode class
 711   ///
 712   /// \param
 713   ///
 714   /// \return
 715   ///
 716   ////////////////////////////////////////////////////////////////////////////////////////////////
 717   CXmlNode();
 718
 719   ////////////////////////////////////////////////////////////////////////////////////////////////
 720   /// CXmlNode
 721   /// Parameterized constructor of CXmlNode class
 722   ///
 723   /// \param f_pXmlNodePtr
 724   ///      xmlNodePtr - pointer of an xml node
 725   ///
 726   /// \return
 727   ///
 728   ////////////////////////////////////////////////////////////////////////////////////////////////
 729   CXmlNode(xmlNodePtr f_pXmlNodePtr);  // NOLINT  (readability/nolint)
 730
 731   ////////////////////////////////////////////////////////////////////////////////////////////////
 732   /// SetXmlNodePtr
 733   /// Sets the xmlNodePtr
 734   ///
 735   /// \param f_pXmlNodePtr
 736   ///      xmlNodePtr - pointer of an xml node
 737   ///
 738   /// \return VOID
 739   ///
 740   ////////////////////////////////////////////////////////////////////////////////////////////////
 741   VOID SetXmlNodePtr(xmlNodePtr f_pXmlNodePtr);
 742
 743   // pointer to xml node
 744   xmlNodePtr m_pXmlNodePtr;
 745 };
 746
 747
 748 /**
 749  * @class CXmlAttr
 750  * \~english @brief This class represents the attribute of an xml node.
 751  * \~english @par   Brief Introduction
 752  *        This class represents the attribute of an xml node.
 753  *
 754  */
 755 class CXmlAttr {
 756  public:
 757   ////////////////////////////////////////////////////////////////////////////////
 758   /// \ingroup CXmlAttr
 759   /// \~english @par Brief
 760   ///       CXmlAttr constructor
 761   /// \~english @param  None
 762   /// \~english @retval None
 763   /// \~english @par Prerequisite
 764   ///       - Load the shared library first
 765   /// \~english @par Inside state change
 766   ///       - The API no inside state change
 767   /// \~english @par None
 768   /// \~english @par Classification
 769   ///       Public
 770   /// \~english @par Type
 771   ///       Sync Only
 772   /// \~english @par Detail
 773   ///       Parameterized constructor of CXmlAttr class
 774   /// \~english @see None
 775   ////////////////////////////////////////////////////////////////////////////////
 776   CXmlAttr();
 777
 778   ////////////////////////////////////////////////////////////////////////////////
 779   /// \ingroup CXmlAttr
 780   /// \~english @par Brief
 781   ///       CXmlAttr constructor
 782   /// \~english @param  [IN] f_cKey
 783   ///       std::string - attributes key
 784   /// \~english @param  [IN] f_cValue
 785   ///       std::string - attributes value
 786   /// \~english @retval None
 787   /// \~english @par Prerequisite
 788   ///       - Load the shared library first
 789   /// \~english @par Inside state change
 790   ///       - The API no inside state change
 791   /// \~english @par None
 792   /// \~english @par Classification
 793   ///       Public
 794   /// \~english @par Type
 795   ///       Sync Only
 796   /// \~english @par Detail
 797   ///       Parameterized constructor of CXmlAttr class
 798   /// \~english @see None
 799   ////////////////////////////////////////////////////////////////////////////////
 800   CXmlAttr(std::string f_cKey, std::string f_cValue);
 801
 802   ////////////////////////////////////////////////////////////////////////////////
 803   /// \ingroup CXmlAttr
 804   /// \~english @par Brief
 805   ///       Destructor of CXmlAttr class
 806   /// \~english @param None
 807   /// \~english @retval None
 808   /// \~english @par Prerequisite
 809   ///       - None
 810   /// \~english @par Inside state change
 811   ///       - None
 812   /// \~english @par None
 813   /// \~english @par Classification
 814   ///       Public
 815   /// \~english @par Type
 816   ///       Sync Only
 817   /// \~english @par Detail
 818   ///       Destructor of CXmlAttr class
 819   /// \~english @see None
 820   ////////////////////////////////////////////////////////////////////////////////
 821   ~CXmlAttr();
 822
 823   // atrribute key
 824   std::string m_cKey;
 825
 826   // atrribute value
 827   std::string m_cValue;
 828 };
 829
 830 /**
 831  * @class CXmlParser
 832  * \~english @brief This class represents the XML parser.
 833  * \~english @par   Brief Introduction
 834  *        Provides API for parsing xml file. Also provides API to search node/nodes based on Xml Path
 835  *
 836  */
 837 class CXmlParser {
 838  public:
 839   ////////////////////////////////////////////////////////////////////////////////
 840   /// \ingroup CXmlParser
 841   /// \~english @par Brief
 842   ///       CXmlParser constructor
 843   /// \~english @param None
 844   /// \~english @retval None
 845   /// \~english @par Prerequisite
 846   ///       - Load the shared library first
 847   /// \~english @par Inside state change
 848   ///       - The API no inside state change
 849   /// \~english @par None
 850   /// \~english @par Classification
 851   ///       Public
 852   /// \~english @par Type
 853   ///       Sync Only
 854   /// \~english @par Detail
 855   ///       Constructor of CXmlParser class
 856   /// \~english @see None
 857   ////////////////////////////////////////////////////////////////////////////////
 858   CXmlParser();
 859
 860   ////////////////////////////////////////////////////////////////////////////////
 861   /// \ingroup CXmlParser
 862   /// \~english @par Brief
 863   ///       Destructor of CXmlParser class
 864   /// \~english @param None
 865   /// \~english @retval None
 866   /// \~english @par Prerequisite
 867   ///       - None
 868   /// \~english @par Inside state change
 869   ///       - The API no inside state change
 870   /// \~english @par None
 871   /// \~english @par Classification
 872   ///       Public
 873   /// \~english @par Type
 874   ///       Sync Only
 875   /// \~english @par Detail
 876   ///       Destructor of CXmlParser class
 877   /// \~english @see CXmlParser
 878   ////////////////////////////////////////////////////////////////////////////////
 879   ~CXmlParser();
 880
 881   ////////////////////////////////////////////////////////////////////////////////
 882   /// \ingroup ParseXml
 883   /// \~english @par Brief
 884   ///       Parses xml file
 885   /// \~english @param  [IN] f_cFileName
 886   ///      std::string - full path of xml file to be parsed
 887   /// \~english @retval eFrameworkunifiedStatusOK Success
 888   /// \~english @retval eFrameworkunifiedStatusInvldParam  Invalid parameter
 889   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 890   /// \~english @par Prerequisite
 891   ///       - Load the shared library first
 892   ///       - Get CXmlNode from CXmlParser
 893   /// \~english @par Inside state change
 894   ///       - The API no inside state change
 895   /// \~english @par None
 896   /// \~english @par Classification
 897   ///       Public
 898   /// \~english @par Type
 899   ///       Sync Only
 900   /// \~english @par Detail
 901   ///       Parses the xml file and creates a document structure
 902   /// \~english @see CXmlParser
 903   ////////////////////////////////////////////////////////////////////////////////
 904
 905   EFrameworkunifiedStatus ParseXml(std::string f_cFileName);
 906
 907   ////////////////////////////////////////////////////////////////////////////////
 908   /// \ingroup CreateNewXmlDoc
 909   /// \~english @par Brief
 910   ///       Creates new xml
 911   /// \~english @param  [IN] f_cRootNodeName
 912   ///      std::string - root node name in new doc
 913   /// \~english @retval eFrameworkunifiedStatusOK Success
 914   /// \~english @retval eFrameworkunifiedStatusInvldParam  Invalid parameter
 915   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 916   /// \~english @par Prerequisite
 917   ///       - Load the shared library first
 918   ///       - Get CXmlNode from CXmlParser
 919   /// \~english @par Inside state change
 920   ///       - The API no inside state change
 921   /// \~english @par None
 922   /// \~english @par Classification
 923   ///       Public
 924   /// \~english @par Type
 925   ///       Sync Only
 926   /// \~english @par Detail
 927   ///       Create a new xml document
 928   /// \~english @see CXmlParser
 929   ////////////////////////////////////////////////////////////////////////////////
 930
 931   EFrameworkunifiedStatus CreateNewXmlDoc(std::string f_cRootNodeName);
 932
 933   ////////////////////////////////////////////////////////////////////////////////
 934   /// \ingroup SaveXml
 935   /// \~english @par Brief
 936   ///       Save XML file
 937   /// \~english @param  [IN] f_cFileName
 938   ///      std::string - full path of output xml file
 939   ///            In case of parsing an xml file,
 940   ///               if f_cFileName is empty, output will be saved in source xml file
 941   ///               else output will be saved in user provided file path
 942   ///            In case of creating new xml document,
 943   ///               if f_cFileName is empty, returns error
 944   ///               else output will be saved in user provided file path
 945   /// \~english @retval eFrameworkunifiedStatusOK Success
 946   /// \~english @retval eFrameworkunifiedStatusInvldParam  Invalid parameter
 947   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
 948   /// \~english @par Prerequisite
 949   ///       - Load the shared library first
 950   ///       - Get CXmlNode from CXmlParser
 951   /// \~english @par Inside state change
 952   ///       - The API no inside state change
 953   /// \~english @par None
 954   /// \~english @par Classification
 955   ///       Public
 956   /// \~english @par Type
 957   ///       Sync Only
 958   /// \~english @par Detail
 959   ///       Save the updated structure to the XML file
 960   /// \~english @see CXmlParser
 961   ////////////////////////////////////////////////////////////////////////////////
 962
 963   EFrameworkunifiedStatus SaveXml(std::string f_cFileName = "");
 964
 965   ////////////////////////////////////////////////////////////////////////////////
 966   /// \ingroup GetRootNode
 967   /// \~english @par Brief
 968   ///       Get root node
 969   /// \~english @param None
 970   /// \~english @retval CXmlNode - root node object
 971   /// \~english @par Prerequisite
 972   ///       - Load the shared library first
 973   ///       - Get CXmlNode from CXmlParser
 974   /// \~english @par Inside state change
 975   ///       - The API no inside state change
 976   /// \~english @par None
 977   /// \~english @par Classification
 978   ///       Public
 979   /// \~english @par Type
 980   ///       Sync Only
 981   /// \~english @par Detail
 982   ///       Get the root node object
 983   /// \~english @see CXmlParser
 984   ////////////////////////////////////////////////////////////////////////////////
 985
 986   CXmlNode GetRootNode();
 987
 988   ////////////////////////////////////////////////////////////////////////////////
 989   /// \ingroup AddNewNode
 990   /// \~english @par Brief
 991   ///       Create and add node
 992   /// \~english @param  [IN] f_pParentNode
 993   ///       CXmlNode - parent node
 994   /// \~english @param  [IN] f_cNewNodeName
 995   ///       std::string - tag name of the new node
 996   /// \~english @param  [IN] f_cContent
 997   ///       std::string - text to set for the new node
 998   /// \~english @retval CXmlNode - new node object
 999   /// \~english @par Prerequisite
1000   ///       - Load the shared library first
1001   ///       - Get CXmlNode from CXmlParser
1002   /// \~english @par Inside state change
1003   ///       - The API no inside state change
1004   /// \~english @par None
1005   /// \~english @par Classification
1006   ///       Public
1007   /// \~english @par Type
1008   ///       Sync Only
1009   /// \~english @par Detail
1010   ///       Create new node and add it to the parent node
1011   /// \~english @see CXmlParser
1012   ////////////////////////////////////////////////////////////////////////////////
1013
1014   CXmlNode AddNewNode(CXmlNode m_pParentNode, std::string f_cNewNodeName, std::string f_cContent = "");
1015
1016   ////////////////////////////////////////////////////////////////////////////////
1017   /// \ingroup RemoveNode
1018   /// \~english @par Brief
1019   ///      Remove node
1020   /// \~english @param  [IN] f_pNode
1021   ///      CXmlNode - node object
1022   /// \~english @retval eFrameworkunifiedStatusOK Success
1023   /// \~english @retval eFrameworkunifiedStatusNullPointer Null pointer
1024   /// \~english @par Prerequisite
1025   ///       - Load the shared library first
1026   ///       - Get CXmlNode from CXmlParser
1027   /// \~english @par Inside state change
1028   ///       - The API no inside state change
1029   /// \~english @par None
1030   /// \~english @par Classification
1031   ///       Public
1032   /// \~english @par Type
1033   ///       Sync Only
1034   /// \~english @par Detail
1035   ///       Remove the node from the xml
1036   /// \~english @see CXmlParser
1037   ////////////////////////////////////////////////////////////////////////////////
1038
1039   EFrameworkunifiedStatus RemoveNode(CXmlNode m_pNode);
1040
1041   ////////////////////////////////////////////////////////////////////////////////
1042   /// \ingroup FindNode
1043   /// \~english @par Brief
1044   ///       Find first matching node
1045   /// \~english @param  [IN] f_cNodePath
1046   ///       std::string - name or path of node(XPath) path is relative to current node or absolute path
1047   /// \~english @param  [IN] f_pCurrentNode
1048   ///       CXmlNode - current node
1049   /// \~english @retval CXmlNode - node object
1050   /// \~english @par Prerequisite
1051   ///       - Load the shared library first
1052   ///       - Get CXmlNode from CXmlParser
1053   /// \~english @par Inside state change
1054   ///       - The API no inside state change
1055   /// \~english @par None
1056   /// \~english @par Classification
1057   ///       Public
1058   /// \~english @par Type
1059   ///       Sync Only
1060   /// \~english @par Detail
1061   ///       Find the first matching node, by tag name or path relative to current node path or
1062   ///       absolute path. Here the path is XPath expression
1063   /// \~english @see CXmlParser
1064   ////////////////////////////////////////////////////////////////////////////////
1065
1066
1067   CXmlNode FindNode(std::string f_cNodePath, CXmlNode f_pCurrentNode);
1068
1069   ////////////////////////////////////////////////////////////////////////////////
1070   /// \ingroup FindAllNodes
1071   /// \~english @par Brief
1072   ///       Find all matching node
1073   /// \~english @param  [IN] f_cNodePath
1074   ///       std::string - name or path of node(XPath) path is relative to current node or absolute path
1075   /// \~english @param  [IN] f_pCurrentNode
1076   ///       CXmlNode - current node
1077   /// \~english @retval TNodeList - list of matching nodes
1078   /// \~english @par Prerequisite
1079   ///       - Load the shared library first
1080   ///       - Get CXmlNode from CXmlParser
1081   /// \~english @par Inside state change
1082   ///       - The API no inside state change
1083   /// \~english @par None
1084   /// \~english @par Classification
1085   ///       Public
1086   /// \~english @par Type
1087   ///       Sync Only
1088   /// \~english @par Detail
1089   ///       Find all the matching node, by tag name or path relative to current node path or
1090   ///       absolute path.
1091   /// \~english @see CXmlParser
1092   ////////////////////////////////////////////////////////////////////////////////
1093
1094   TNodeList FindAllNodes(std::string f_cNodePath, CXmlNode f_pCurrentNode);
1095
1096  private:
1097   ////////////////////////////////////////////////////////////////////////////////////////////////
1098   /// GetNodeSet
1099   /// Gets the node set resulting from search of nodepath using XPath
1100   ///
1101   /// \param f_cNodePath
1102   ///      std::string - name or path of node
1103   ///            path is relative to current node or absolute path
1104   /// \param f_pCurrentNode
1105   ///      CXmlNode - current node
1106   ///
1107   /// \return xmlXPathObjectPtr
1108   ///     xmlXPathObjectPtr - returns the xpath object pointer containing nodes pointer
1109   ///
1110   ////////////////////////////////////////////////////////////////////////////////////////////////
1111   xmlXPathObjectPtr GetNodeSet(std::string f_cNodePath, CXmlNode f_pCurrentNode);
1112
1113   ////////////////////////////////////////////////////////////////////////////////////////////////
1114   /// IsReadable
1115   /// Checks whether the file exists or not
1116   ///
1117   /// \param
1118   ///
1119   /// \return VOID
1120   ///
1121   ////////////////////////////////////////////////////////////////////////////////////////////////
1122   BOOL IsReadable(const std::string &filename);
1123
1124   ////////////////////////////////////////////////////////////////////////////////////////////////
1125   /// ClearDocument
1126   /// Clears the document structure and resets the root node
1127   ///
1128   /// \param
1129   ///
1130   /// \return VOID
1131   ///
1132   ////////////////////////////////////////////////////////////////////////////////////////////////
1133   VOID ClearDocument();
1134
1135   // pointer to structure created from xml after parsing
1136   xmlDocPtr m_pXmlDoc;
1137
1138   // stores the name/path of source xml file
1139   std::string m_cFileName;
1140
1141   // pointer to the root node of xml structure
1142   CXmlNode m_pRootNode;
1143 };
1144
1145
1146 #endif  /* __FRAMEWORKUNIFIED_NATIVESERVICES_NS_XMLPARSER_INC_NS_XMLPARSER_IF_H__ */  // NOLINT  (build/header_guard)
1147 /** @}*/
1148 /** @}*/
1149 /** @}*/
1150 /** @}*/