le_cfg_common.h

    1 
    2 /*
    3  * ====================== WARNING ======================
    4  *
    5  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    6  * DO NOT MODIFY IN ANY WAY.
    7  *
    8  * ====================== WARNING ======================
    9  */
   10 /**
   11  * @file le_cfg_common.h
   12  *
   13  * Type definitions for le_cfg.
   14  *
   15  */
   16 #ifndef LE_CFG_COMMON_H_INCLUDE_GUARD
   17 #define LE_CFG_COMMON_H_INCLUDE_GUARD
   18 
   19 
   20 #include "legato.h"
   21 
   22 #define IFGEN_LE_CFG_PROTOCOL_ID "4db45ee4887ce0305738f97e9c15d721"
   23 #define IFGEN_LE_CFG_MSG_SIZE 9239
   24 /** @addtogroup le_cfg
   25  *  @{ **/
   26 
   27 
   28 //--------------------------------------------------------------------------------------------------
   29 /**
   30  * Length of the strings used by this API.
   31  */
   32 //--------------------------------------------------------------------------------------------------
   33 #define LE_CFG_STR_LEN 511
   34 
   35 //--------------------------------------------------------------------------------------------------
   36 /**
   37  * Length of the strings used by this API, including the trailing NULL.
   38  */
   39 //--------------------------------------------------------------------------------------------------
   40 #define LE_CFG_STR_LEN_BYTES 512
   41 
   42 //--------------------------------------------------------------------------------------------------
   43 /**
   44  * Length of the binary data used by this API.
   45  */
   46 //--------------------------------------------------------------------------------------------------
   47 #define LE_CFG_BINARY_LEN 8704
   48 
   49 //--------------------------------------------------------------------------------------------------
   50 /**
   51  * Allowed length of a node name.
   52  */
   53 //--------------------------------------------------------------------------------------------------
   54 #define LE_CFG_NAME_LEN 255
   55 
   56 //--------------------------------------------------------------------------------------------------
   57 /**
   58  * The node name length, including a trailing NULL.
   59  */
   60 //--------------------------------------------------------------------------------------------------
   61 #define LE_CFG_NAME_LEN_BYTES 256
   62 
   63 //--------------------------------------------------------------------------------------------------
   64 /**
   65  * Reference to a tree iterator object.
   66  */
   67 //--------------------------------------------------------------------------------------------------
   68 typedef struct le_cfg_Iterator* le_cfg_IteratorRef_t;
   69 
   70 
   71 //--------------------------------------------------------------------------------------------------
   72 /**
   73  * Identifies the data type of node.
   74  */
   75 //--------------------------------------------------------------------------------------------------
   76 typedef enum
   77 {
   78     LE_CFG_TYPE_EMPTY = 0,
   79         ///< A node with no value.
   80     LE_CFG_TYPE_STRING = 1,
   81         ///< A string encoded as utf8.
   82     LE_CFG_TYPE_BOOL = 2,
   83         ///< Boolean value.
   84     LE_CFG_TYPE_INT = 3,
   85         ///< Signed 32-bit.
   86     LE_CFG_TYPE_FLOAT = 4,
   87         ///< 64-bit floating point value.
   88     LE_CFG_TYPE_STEM = 5,
   89         ///< Non-leaf node, this node is the parent of other nodes.
   90     LE_CFG_TYPE_DOESNT_EXIST = 6
   91         ///< Node doesn't exist.
   92 }
   93 le_cfg_nodeType_t;
   94 
   95 
   96 //--------------------------------------------------------------------------------------------------
   97 /**
   98  * Reference type used by Add/Remove functions for EVENT 'le_cfg_Change'
   99  */
  100 //--------------------------------------------------------------------------------------------------
  101 typedef struct le_cfg_ChangeHandler* le_cfg_ChangeHandlerRef_t;
  102 
  103 
  104 //--------------------------------------------------------------------------------------------------
  105 /**
  106  * Handler for node change notifications.
  107  */
  108 //--------------------------------------------------------------------------------------------------
  109 typedef void (*le_cfg_ChangeHandlerFunc_t)
  110 (
  111         void* contextPtr
  112         ///<
  113 );
  114 
  115 
  116 //--------------------------------------------------------------------------------------------------
  117 /**
  118  * Get if this client bound locally.
  119  */
  120 //--------------------------------------------------------------------------------------------------
  121 LE_SHARED bool ifgen_le_cfg_HasLocalBinding
  122 (
  123     void
  124 );
  125 
  126 
  127 //--------------------------------------------------------------------------------------------------
  128 /**
  129  * Init data that is common across all threads
  130  */
  131 //--------------------------------------------------------------------------------------------------
  132 LE_SHARED void ifgen_le_cfg_InitCommonData
  133 (
  134     void
  135 );
  136 
  137 
  138 //--------------------------------------------------------------------------------------------------
  139 /**
  140  * Perform common initialization and open a session
  141  */
  142 //--------------------------------------------------------------------------------------------------
  143 LE_SHARED le_result_t ifgen_le_cfg_OpenSession
  144 (
  145     le_msg_SessionRef_t _ifgen_sessionRef,
  146     bool isBlocking
  147 );
  148 
  149 //--------------------------------------------------------------------------------------------------
  150 /**
  151  * Create a read transaction and open a new iterator for traversing the config tree.
  152  *
  153  * This action creates a read lock on the given tree, which will start a read-timeout.
  154  * Once the read timeout expires, all active read iterators on that tree will be
  155  * expired and their clients will be killed.
  156  *
  157  * @note A tree transaction is global to that tree; a long-held read transaction will block other
  158  *        user's write transactions from being committed.
  159  *
  160  * @return This will return the newly created iterator reference.
  161  */
  162 //--------------------------------------------------------------------------------------------------
  163 LE_SHARED le_cfg_IteratorRef_t ifgen_le_cfg_CreateReadTxn
  164 (
  165     le_msg_SessionRef_t _ifgen_sessionRef,
  166         const char* LE_NONNULL basePath
  167         ///< [IN] Path to the location to create the new iterator.
  168 );
  169 
  170 //--------------------------------------------------------------------------------------------------
  171 /**
  172  * Create a write transaction and open a new iterator for both reading and writing.
  173  *
  174  * This action creates a write transaction. If the app holds the iterator for
  175  * longer than the configured write transaction timeout, the iterator will cancel the
  176  * transaction. Other reads will fail to return data, and all writes will be thrown away.
  177  *
  178  * @note A tree transaction is global to that tree; a long-held write transaction will block
  179  *       other user's write transactions from being started. Other trees in the system
  180  *       won't be affected.
  181  *
  182  * @return This will return a newly created iterator reference.
  183  */
  184 //--------------------------------------------------------------------------------------------------
  185 LE_SHARED le_cfg_IteratorRef_t ifgen_le_cfg_CreateWriteTxn
  186 (
  187     le_msg_SessionRef_t _ifgen_sessionRef,
  188         const char* LE_NONNULL basePath
  189         ///< [IN] Path to the location to create the new iterator.
  190 );
  191 
  192 //--------------------------------------------------------------------------------------------------
  193 /**
  194  * Closes the write iterator and commits the write transaction. This updates the config tree
  195  * with all of the writes that occurred within the iterator.
  196  *
  197  * @note This operation will also delete the iterator object.
  198  */
  199 //--------------------------------------------------------------------------------------------------
  200 LE_SHARED void ifgen_le_cfg_CommitTxn
  201 (
  202     le_msg_SessionRef_t _ifgen_sessionRef,
  203         le_cfg_IteratorRef_t iteratorRef
  204         ///< [IN] Iterator object to commit.
  205 );
  206 
  207 //--------------------------------------------------------------------------------------------------
  208 /**
  209  * Closes and frees the given iterator object. If the iterator is a write iterator, the transaction
  210  * will be canceled. If the iterator is a read iterator, the transaction will be closed. No data is
  211  * written to the tree
  212  *
  213  * @note This operation will also delete the iterator object.
  214  */
  215 //--------------------------------------------------------------------------------------------------
  216 LE_SHARED void ifgen_le_cfg_CancelTxn
  217 (
  218     le_msg_SessionRef_t _ifgen_sessionRef,
  219         le_cfg_IteratorRef_t iteratorRef
  220         ///< [IN] Iterator object to close.
  221 );
  222 
  223 //--------------------------------------------------------------------------------------------------
  224 /**
  225  * Changes the location of iterator. The path passed can be an absolute or a
  226  * relative path from the iterators current location.
  227  *
  228  * The target node does not need to exist. Writing a value to a non-existent node will
  229  * automatically create that node and any ancestor nodes (parent, parent's parent, etc.) that
  230  * also don't exist.
  231  */
  232 //--------------------------------------------------------------------------------------------------
  233 LE_SHARED void ifgen_le_cfg_GoToNode
  234 (
  235     le_msg_SessionRef_t _ifgen_sessionRef,
  236         le_cfg_IteratorRef_t iteratorRef,
  237         ///< [IN] Iterator to move.
  238         const char* LE_NONNULL newPath
  239         ///< [IN] Absolute or relative path from the current location.
  240 );
  241 
  242 //--------------------------------------------------------------------------------------------------
  243 /**
  244  * Move the iterator to the parent of the current node (moves up the tree).
  245  *
  246  * @return Return code will be one of the following values:
  247  *
  248  *         - LE_OK        - Commit was completed successfully.
  249  *         - LE_NOT_FOUND - Current node is the root node: has no parent.
  250  */
  251 //--------------------------------------------------------------------------------------------------
  252 LE_SHARED le_result_t ifgen_le_cfg_GoToParent
  253 (
  254     le_msg_SessionRef_t _ifgen_sessionRef,
  255         le_cfg_IteratorRef_t iteratorRef
  256         ///< [IN] Iterator to move.
  257 );
  258 
  259 //--------------------------------------------------------------------------------------------------
  260 /**
  261  * Moves the iterator to the the first child of the node from the current location.
  262  *
  263  * For read iterators without children, this function will fail. If the iterator is a write
  264  * iterator, then a new node is automatically created. If this node or newly created
  265  * children of this node are not written to, then this node will not persist even if the iterator is
  266  * committed.
  267  *
  268  * @return Return code will be one of the following values:
  269  *
  270  *         - LE_OK        - Move was completed successfully.
  271  *         - LE_NOT_FOUND - The given node has no children.
  272  */
  273 //--------------------------------------------------------------------------------------------------
  274 LE_SHARED le_result_t ifgen_le_cfg_GoToFirstChild
  275 (
  276     le_msg_SessionRef_t _ifgen_sessionRef,
  277         le_cfg_IteratorRef_t iteratorRef
  278         ///< [IN] Iterator object to move.
  279 );
  280 
  281 //--------------------------------------------------------------------------------------------------
  282 /**
  283  * Jumps the iterator to the next child node of the current node. Assuming the following tree:
  284  *
  285  * @code
  286  * baseNode
  287  *      |
  288  *      +childA
  289  *          |
  290  *          +valueA
  291  *          |
  292  *          +valueB
  293  * @endcode
  294  *
  295  * If the iterator is moved to the path, "/baseNode/childA/valueA". After the first
  296  * GoToNextSibling the iterator will be pointing at valueB. A second call to GoToNextSibling
  297  * will cause the function to return LE_NOT_FOUND.
  298  *
  299  * @return Returns one of the following values:
  300  *
  301  *         - LE_OK            - Commit was completed successfully.
  302  *         - LE_NOT_FOUND     - Iterator has reached the end of the current list of siblings.
  303  *                              Also returned if the the current node has no siblings.
  304  */
  305 //--------------------------------------------------------------------------------------------------
  306 LE_SHARED le_result_t ifgen_le_cfg_GoToNextSibling
  307 (
  308     le_msg_SessionRef_t _ifgen_sessionRef,
  309         le_cfg_IteratorRef_t iteratorRef
  310         ///< [IN] Iterator to iterate.
  311 );
  312 
  313 //--------------------------------------------------------------------------------------------------
  314 /**
  315  * Get path to the node where the iterator is currently pointed.
  316  *
  317  * Assuming the following tree:
  318  *
  319  * @code
  320  * baseNode
  321  *      |
  322  *      +childA
  323  *          |
  324  *          +valueA
  325  *          |
  326  *          +valueB
  327  * @endcode
  328  *
  329  * If the iterator was currently pointing at valueA, GetPath would return the following path:
  330  *
  331  * @code
  332  * /baseNode/childA/valueA
  333  * @endcode
  334  *
  335  * Optionally, a path to another node can be supplied to this function. So, if the iterator is
  336  * again on valueA and the relative path ".." is supplied then this function will return the
  337  * the path relative to the node given:
  338  *
  339  * @code
  340  * /baseNode/childA/
  341  * @endcode
  342  *
  343  * @return - LE_OK            - The write was completed successfully.
  344  *         - LE_OVERFLOW      - The supplied string buffer was not large enough to hold the value.
  345  */
  346 //--------------------------------------------------------------------------------------------------
  347 LE_SHARED le_result_t ifgen_le_cfg_GetPath
  348 (
  349     le_msg_SessionRef_t _ifgen_sessionRef,
  350         le_cfg_IteratorRef_t iteratorRef,
  351         ///< [IN] Iterator to move.
  352         const char* LE_NONNULL path,
  353         ///< [IN] Path to the target node. Can be an absolute path, or
  354         ///< a path relative from the iterator's current position.
  355         char* pathBuffer,
  356         ///< [OUT] Absolute path to the iterator's current node.
  357         size_t pathBufferSize
  358         ///< [IN]
  359 );
  360 
  361 //--------------------------------------------------------------------------------------------------
  362 /**
  363  * Get the data type of node where the iterator is currently pointing.
  364  *
  365  * @return le_cfg_nodeType_t value indicating the stored value.
  366  */
  367 //--------------------------------------------------------------------------------------------------
  368 LE_SHARED le_cfg_nodeType_t ifgen_le_cfg_GetNodeType
  369 (
  370     le_msg_SessionRef_t _ifgen_sessionRef,
  371         le_cfg_IteratorRef_t iteratorRef,
  372         ///< [IN] Iterator object to use to read from the tree.
  373         const char* LE_NONNULL path
  374         ///< [IN] Path to the target node. Can be an absolute path, or
  375         ///< a path relative from the iterator's current position.
  376 );
  377 
  378 //--------------------------------------------------------------------------------------------------
  379 /**
  380  * Get the name of the node where the iterator is currently pointing.
  381  *
  382  * @return - LE_OK       Read was completed successfully.
  383  *         - LE_OVERFLOW Supplied string buffer was not large enough to hold the value.
  384  */
  385 //--------------------------------------------------------------------------------------------------
  386 LE_SHARED le_result_t ifgen_le_cfg_GetNodeName
  387 (
  388     le_msg_SessionRef_t _ifgen_sessionRef,
  389         le_cfg_IteratorRef_t iteratorRef,
  390         ///< [IN] Iterator object to use to read from the tree.
  391         const char* LE_NONNULL path,
  392         ///< [IN] Path to the target node. Can be an absolute path, or
  393         ///< a path relative from the iterator's current position.
  394         char* name,
  395         ///< [OUT] Read the name of the node object.
  396         size_t nameSize
  397         ///< [IN]
  398 );
  399 
  400 //--------------------------------------------------------------------------------------------------
  401 /**
  402  * Add handler function for EVENT 'le_cfg_Change'
  403  *
  404  * This event provides information on changes to the given node object, or any of it's children,
  405  * where a change could be either a read, write, create or delete operation.
  406  */
  407 //--------------------------------------------------------------------------------------------------
  408 LE_SHARED le_cfg_ChangeHandlerRef_t ifgen_le_cfg_AddChangeHandler
  409 (
  410     le_msg_SessionRef_t _ifgen_sessionRef,
  411         const char* LE_NONNULL newPath,
  412         ///< [IN] Path to the object to watch.
  413         le_cfg_ChangeHandlerFunc_t handlerPtr,
  414         ///< [IN] Handler to receive change notification
  415         void* contextPtr
  416         ///< [IN]
  417 );
  418 
  419 //--------------------------------------------------------------------------------------------------
  420 /**
  421  * Remove handler function for EVENT 'le_cfg_Change'
  422  */
  423 //--------------------------------------------------------------------------------------------------
  424 LE_SHARED void ifgen_le_cfg_RemoveChangeHandler
  425 (
  426     le_msg_SessionRef_t _ifgen_sessionRef,
  427         le_cfg_ChangeHandlerRef_t handlerRef
  428         ///< [IN]
  429 );
  430 
  431 //--------------------------------------------------------------------------------------------------
  432 /**
  433  * Deletes the node specified by the path. If the node doesn't exist, nothing happens. All child
  434  * nodes are also deleted.
  435  *
  436  * If the path is empty, the iterator's current node is deleted.
  437  *
  438  * This function is only valid during a write transaction.
  439  */
  440 //--------------------------------------------------------------------------------------------------
  441 LE_SHARED void ifgen_le_cfg_DeleteNode
  442 (
  443     le_msg_SessionRef_t _ifgen_sessionRef,
  444         le_cfg_IteratorRef_t iteratorRef,
  445         ///< [IN] Iterator to use as a basis for the transaction.
  446         const char* LE_NONNULL path
  447         ///< [IN] Path to the target node. Can be an absolute path, or
  448         ///< a path relative from the iterator's current position.
  449 );
  450 
  451 //--------------------------------------------------------------------------------------------------
  452 /**
  453  * Check if the given node is empty. A node is also considered empty if it doesn't yet exist. A
  454  * node is also considered empty if it has no value or is a stem with no children.
  455  *
  456  * If the path is empty, the iterator's current node is queried for emptiness.
  457  *
  458  * Valid for both read and write transactions.
  459  *
  460  * @return A true if the node is considered empty, false if not.
  461  */
  462 //--------------------------------------------------------------------------------------------------
  463 LE_SHARED bool ifgen_le_cfg_IsEmpty
  464 (
  465     le_msg_SessionRef_t _ifgen_sessionRef,
  466         le_cfg_IteratorRef_t iteratorRef,
  467         ///< [IN] Iterator to use as a basis for the transaction.
  468         const char* LE_NONNULL path
  469         ///< [IN] Path to the target node. Can be an absolute path, or
  470         ///< a path relative from the iterator's current position.
  471 );
  472 
  473 //--------------------------------------------------------------------------------------------------
  474 /**
  475  * Clears out the node's value. If the node doesn't exist it will be created, and have no value.
  476  *
  477  * If the path is empty, the iterator's current node will be cleared. If the node is a stem
  478  * then all children will be removed from the tree.
  479  *
  480  * Only valid during a write transaction.
  481  */
  482 //--------------------------------------------------------------------------------------------------
  483 LE_SHARED void ifgen_le_cfg_SetEmpty
  484 (
  485     le_msg_SessionRef_t _ifgen_sessionRef,
  486         le_cfg_IteratorRef_t iteratorRef,
  487         ///< [IN] Iterator to use as a basis for the transaction.
  488         const char* LE_NONNULL path
  489         ///< [IN] Path to the target node. Can be an absolute path, or
  490         ///< a path relative from the iterator's current position.
  491 );
  492 
  493 //--------------------------------------------------------------------------------------------------
  494 /**
  495  * Checks to see if a given node in the config tree exists.
  496  *
  497  * @return True if the specified node exists in the tree. False if not.
  498  */
  499 //--------------------------------------------------------------------------------------------------
  500 LE_SHARED bool ifgen_le_cfg_NodeExists
  501 (
  502     le_msg_SessionRef_t _ifgen_sessionRef,
  503         le_cfg_IteratorRef_t iteratorRef,
  504         ///< [IN] Iterator to use as a basis for the transaction.
  505         const char* LE_NONNULL path
  506         ///< [IN] Path to the target node. Can be an absolute path, or
  507         ///< a path relative from the iterator's current position.
  508 );
  509 
  510 //--------------------------------------------------------------------------------------------------
  511 /**
  512  * Reads a string value from the config tree. If the value isn't a string, or if the node is
  513  * empty or doesn't exist, the default value will be returned.
  514  *
  515  * Valid for both read and write transactions.
  516  *
  517  * If the path is empty, the iterator's current node will be read.
  518  *
  519  * @return - LE_OK       - Read was completed successfully.
  520  *         - LE_OVERFLOW - Supplied string buffer was not large enough to hold the value.
  521  */
  522 //--------------------------------------------------------------------------------------------------
  523 LE_SHARED le_result_t ifgen_le_cfg_GetString
  524 (
  525     le_msg_SessionRef_t _ifgen_sessionRef,
  526         le_cfg_IteratorRef_t iteratorRef,
  527         ///< [IN] Iterator to use as a basis for the transaction.
  528         const char* LE_NONNULL path,
  529         ///< [IN] Path to the target node. Can be an absolute path,
  530         ///< or a path relative from the iterator's current
  531         ///< position.
  532         char* value,
  533         ///< [OUT] Buffer to write the value into.
  534         size_t valueSize,
  535         ///< [IN]
  536         const char* LE_NONNULL defaultValue
  537         ///< [IN] Default value to use if the original can't be
  538         ///<   read.
  539 );
  540 
  541 //--------------------------------------------------------------------------------------------------
  542 /**
  543  * Writes a string value to the config tree. Only valid during a write
  544  * transaction.
  545  *
  546  * If the path is empty, the iterator's current node will be set.
  547  */
  548 //--------------------------------------------------------------------------------------------------
  549 LE_SHARED void ifgen_le_cfg_SetString
  550 (
  551     le_msg_SessionRef_t _ifgen_sessionRef,
  552         le_cfg_IteratorRef_t iteratorRef,
  553         ///< [IN] Iterator to use as a basis for the transaction.
  554         const char* LE_NONNULL path,
  555         ///< [IN] Path to the target node. Can be an absolute path, or
  556         ///< a path relative from the iterator's current position.
  557         const char* LE_NONNULL value
  558         ///< [IN] Value to write.
  559 );
  560 
  561 //--------------------------------------------------------------------------------------------------
  562 /**
  563  *  Read a binary data from the config tree.  If the the node has a wrong type, is
  564  *  empty or doesn't exist, the default value will be returned.
  565  *
  566  *  Valid for both read and write transactions.
  567  *
  568  *  If the path is empty, the iterator's current node will be read.
  569  *
  570  *  \b Responds \b With:
  571  *
  572  *  This function will respond with one of the following values:
  573  *
  574  *          - LE_OK             - Read was completed successfully.
  575  *          - LE_FORMAT_ERROR   - if data can't be decoded.
  576  *          - LE_OVERFLOW       - Supplied buffer was not large enough to hold the value.
  577  */
  578 //--------------------------------------------------------------------------------------------------
  579 LE_SHARED le_result_t ifgen_le_cfg_GetBinary
  580 (
  581     le_msg_SessionRef_t _ifgen_sessionRef,
  582         le_cfg_IteratorRef_t iteratorRef,
  583         ///< [IN] Iterator to use as a basis for the transaction.
  584         const char* LE_NONNULL path,
  585         ///< [IN] Path to the target node. Can be an absolute path,
  586         ///< or a path relative from the iterator's current
  587         ///< position.
  588         uint8_t* valuePtr,
  589         ///< [OUT] Buffer to write the value into.
  590         size_t* valueSizePtr,
  591         ///< [INOUT]
  592         const uint8_t* defaultValuePtr,
  593         ///< [IN] Default value to use if the original can't be
  594         ///<   read.
  595         size_t defaultValueSize
  596         ///< [IN]
  597 );
  598 
  599 //--------------------------------------------------------------------------------------------------
  600 /**
  601  *  Write a binary data to the config tree.  Only valid during a write
  602  *  transaction.
  603  *
  604  *  If the path is empty, the iterator's current node will be set.
  605  *
  606  *  @note Binary data cannot be written to the 'system' tree.
  607  */
  608 //--------------------------------------------------------------------------------------------------
  609 LE_SHARED void ifgen_le_cfg_SetBinary
  610 (
  611     le_msg_SessionRef_t _ifgen_sessionRef,
  612         le_cfg_IteratorRef_t iteratorRef,
  613         ///< [IN] Iterator to use as a basis for the transaction.
  614         const char* LE_NONNULL path,
  615         ///< [IN] Path to the target node. Can be an absolute path, or
  616         ///< a path relative from the iterator's current position.
  617         const uint8_t* valuePtr,
  618         ///< [IN] Value to write.
  619         size_t valueSize
  620         ///< [IN]
  621 );
  622 
  623 //--------------------------------------------------------------------------------------------------
  624 /**
  625  * Reads a signed integer value from the config tree.
  626  *
  627  * If the underlying value is not an integer, the default value will be returned instead. The
  628  * default value is also returned if the node does not exist or if it's empty.
  629  *
  630  * If the value is a floating point value, then it will be rounded and returned as an integer.
  631  *
  632  * Valid for both read and write transactions.
  633  *
  634  * If the path is empty, the iterator's current node will be read.
  635  */
  636 //--------------------------------------------------------------------------------------------------
  637 LE_SHARED int32_t ifgen_le_cfg_GetInt
  638 (
  639     le_msg_SessionRef_t _ifgen_sessionRef,
  640         le_cfg_IteratorRef_t iteratorRef,
  641         ///< [IN] Iterator to use as a basis for the transaction.
  642         const char* LE_NONNULL path,
  643         ///< [IN] Path to the target node. Can be an absolute path, or
  644         ///< a path relative from the iterator's current position.
  645         int32_t defaultValue
  646         ///< [IN] Default value to use if the original can't be
  647         ///<   read.
  648 );
  649 
  650 //--------------------------------------------------------------------------------------------------
  651 /**
  652  * Writes a signed integer value to the config tree. Only valid during a
  653  * write transaction.
  654  *
  655  * If the path is empty, the iterator's current node will be set.
  656  */
  657 //--------------------------------------------------------------------------------------------------
  658 LE_SHARED void ifgen_le_cfg_SetInt
  659 (
  660     le_msg_SessionRef_t _ifgen_sessionRef,
  661         le_cfg_IteratorRef_t iteratorRef,
  662         ///< [IN] Iterator to use as a basis for the transaction.
  663         const char* LE_NONNULL path,
  664         ///< [IN] Path to the target node. Can be an absolute path, or
  665         ///< a path relative from the iterator's current position.
  666         int32_t value
  667         ///< [IN] Value to write.
  668 );
  669 
  670 //--------------------------------------------------------------------------------------------------
  671 /**
  672  * Reads a 64-bit floating point value from the config tree.
  673  *
  674  * If the value is an integer then the value will be promoted to a float. Otherwise, if the
  675  * underlying value is not a float or integer, the default value will be returned.
  676  *
  677  * If the path is empty, the iterator's current node will be read.
  678  *
  679  * @note Floating point values will only be stored up to 6 digits of precision.
  680  */
  681 //--------------------------------------------------------------------------------------------------
  682 LE_SHARED double ifgen_le_cfg_GetFloat
  683 (
  684     le_msg_SessionRef_t _ifgen_sessionRef,
  685         le_cfg_IteratorRef_t iteratorRef,
  686         ///< [IN] Iterator to use as a basis for the transaction.
  687         const char* LE_NONNULL path,
  688         ///< [IN] Path to the target node. Can be an absolute path, or
  689         ///< a path relative from the iterator's current position.
  690         double defaultValue
  691         ///< [IN] Default value to use if the original can't be
  692         ///<   read.
  693 );
  694 
  695 //--------------------------------------------------------------------------------------------------
  696 /**
  697  * Writes a 64-bit floating point value to the config tree. Only valid
  698  * during a write transaction.
  699  *
  700  * If the path is empty, the iterator's current node will be set.
  701  *
  702  * @note Floating point values will only be stored up to 6 digits of precision.
  703  */
  704 //--------------------------------------------------------------------------------------------------
  705 LE_SHARED void ifgen_le_cfg_SetFloat
  706 (
  707     le_msg_SessionRef_t _ifgen_sessionRef,
  708         le_cfg_IteratorRef_t iteratorRef,
  709         ///< [IN] Iterator to use as a basis for the transaction.
  710         const char* LE_NONNULL path,
  711         ///< [IN] Path to the target node. Can be an absolute path, or
  712         ///< a path relative from the iterator's current position.
  713         double value
  714         ///< [IN] Value to write.
  715 );
  716 
  717 //--------------------------------------------------------------------------------------------------
  718 /**
  719  * Reads a value from the tree as a boolean. If the node is empty or doesn't exist, the default
  720  * value is returned. Default value is also returned if the node is a different type than
  721  * expected.
  722  *
  723  * Valid for both read and write transactions.
  724  *
  725  * If the path is empty, the iterator's current node will be read.
  726  */
  727 //--------------------------------------------------------------------------------------------------
  728 LE_SHARED bool ifgen_le_cfg_GetBool
  729 (
  730     le_msg_SessionRef_t _ifgen_sessionRef,
  731         le_cfg_IteratorRef_t iteratorRef,
  732         ///< [IN] Iterator to use as a basis for the transaction.
  733         const char* LE_NONNULL path,
  734         ///< [IN] Path to the target node. Can be an absolute path, or
  735         ///< a path relative from the iterator's current position.
  736         bool defaultValue
  737         ///< [IN] Default value to use if the original can't be
  738         ///<   read.
  739 );
  740 
  741 //--------------------------------------------------------------------------------------------------
  742 /**
  743  * Writes a boolean value to the config tree. Only valid during a write
  744  * transaction.
  745  *
  746  * If the path is empty, the iterator's current node will be set.
  747  */
  748 //--------------------------------------------------------------------------------------------------
  749 LE_SHARED void ifgen_le_cfg_SetBool
  750 (
  751     le_msg_SessionRef_t _ifgen_sessionRef,
  752         le_cfg_IteratorRef_t iteratorRef,
  753         ///< [IN] Iterator to use as a basis for the transaction.
  754         const char* LE_NONNULL path,
  755         ///< [IN] Path to the target node. Can be an absolute path, or
  756         ///< a path relative from the iterator's current position.
  757         bool value
  758         ///< [IN] Value to write.
  759 );
  760 
  761 //--------------------------------------------------------------------------------------------------
  762 /**
  763  * Deletes the node specified by the path. If the node doesn't exist, nothing happens. All child
  764  * nodes are also deleted.
  765  */
  766 //--------------------------------------------------------------------------------------------------
  767 LE_SHARED void ifgen_le_cfg_QuickDeleteNode
  768 (
  769     le_msg_SessionRef_t _ifgen_sessionRef,
  770         const char* LE_NONNULL path
  771         ///< [IN] Path to the node to delete.
  772 );
  773 
  774 //--------------------------------------------------------------------------------------------------
  775 /**
  776  * Clears the current value of a node. If the node doesn't currently exist then it is created as a
  777  * new empty node.
  778  */
  779 //--------------------------------------------------------------------------------------------------
  780 LE_SHARED void ifgen_le_cfg_QuickSetEmpty
  781 (
  782     le_msg_SessionRef_t _ifgen_sessionRef,
  783         const char* LE_NONNULL path
  784         ///< [IN] Absolute or relative path to read from.
  785 );
  786 
  787 //--------------------------------------------------------------------------------------------------
  788 /**
  789  * Reads a string value from the config tree. If the value isn't a string, or if the node is
  790  * empty or doesn't exist, the default value will be returned.
  791  *
  792  * @return - LE_OK       - Commit was completed successfully.
  793  *         - LE_OVERFLOW - Supplied string buffer was not large enough to hold the value.
  794  */
  795 //--------------------------------------------------------------------------------------------------
  796 LE_SHARED le_result_t ifgen_le_cfg_QuickGetString
  797 (
  798     le_msg_SessionRef_t _ifgen_sessionRef,
  799         const char* LE_NONNULL path,
  800         ///< [IN] Path to read from.
  801         char* value,
  802         ///< [OUT] Value read from the requested node.
  803         size_t valueSize,
  804         ///< [IN]
  805         const char* LE_NONNULL defaultValue
  806         ///< [IN] Default value to use if the original can't be read.
  807 );
  808 
  809 //--------------------------------------------------------------------------------------------------
  810 /**
  811  * Writes a string value to the config tree.
  812  */
  813 //--------------------------------------------------------------------------------------------------
  814 LE_SHARED void ifgen_le_cfg_QuickSetString
  815 (
  816     le_msg_SessionRef_t _ifgen_sessionRef,
  817         const char* LE_NONNULL path,
  818         ///< [IN] Path to the value to write.
  819         const char* LE_NONNULL value
  820         ///< [IN] Value to write.
  821 );
  822 
  823 //--------------------------------------------------------------------------------------------------
  824 /**
  825  * Reads a binary data from the config tree. If the node type is different, or if the node is
  826  * empty or doesn't exist, the default value will be returned.
  827  *
  828  * @return - LE_OK              - Commit was completed successfully.
  829  *         - LE_FORMAT_ERROR    - if data can't be decoded.
  830  *         - LE_OVERFLOW        - Supplied buffer was not large enough to hold the value.
  831  */
  832 //--------------------------------------------------------------------------------------------------
  833 LE_SHARED le_result_t ifgen_le_cfg_QuickGetBinary
  834 (
  835     le_msg_SessionRef_t _ifgen_sessionRef,
  836         const char* LE_NONNULL path,
  837         ///< [IN] Path to the target node.
  838         uint8_t* valuePtr,
  839         ///< [OUT] Buffer to write the value into.
  840         size_t* valueSizePtr,
  841         ///< [INOUT]
  842         const uint8_t* defaultValuePtr,
  843         ///< [IN] Default value to use if the original can't be
  844         ///<   read.
  845         size_t defaultValueSize
  846         ///< [IN]
  847 );
  848 
  849 //--------------------------------------------------------------------------------------------------
  850 /**
  851  * Writes a binary data to the config tree.
  852  */
  853 //--------------------------------------------------------------------------------------------------
  854 LE_SHARED void ifgen_le_cfg_QuickSetBinary
  855 (
  856     le_msg_SessionRef_t _ifgen_sessionRef,
  857         const char* LE_NONNULL path,
  858         ///< [IN] Path to the target node.
  859         const uint8_t* valuePtr,
  860         ///< [IN] Value to write.
  861         size_t valueSize
  862         ///< [IN]
  863 );
  864 
  865 //--------------------------------------------------------------------------------------------------
  866 /**
  867  * Reads a signed integer value from the config tree. If the value is a floating point
  868  * value, then it will be rounded and returned as an integer. Otherwise If the underlying value is
  869  * not an integer or a float, the default value will be returned instead.
  870  *
  871  * If the value is empty or the node doesn't exist, the default value is returned instead.
  872  */
  873 //--------------------------------------------------------------------------------------------------
  874 LE_SHARED int32_t ifgen_le_cfg_QuickGetInt
  875 (
  876     le_msg_SessionRef_t _ifgen_sessionRef,
  877         const char* LE_NONNULL path,
  878         ///< [IN] Path to the value to write.
  879         int32_t defaultValue
  880         ///< [IN] Default value to use if the original can't be read.
  881 );
  882 
  883 //--------------------------------------------------------------------------------------------------
  884 /**
  885  * Writes a signed integer value to the config tree.
  886  */
  887 //--------------------------------------------------------------------------------------------------
  888 LE_SHARED void ifgen_le_cfg_QuickSetInt
  889 (
  890     le_msg_SessionRef_t _ifgen_sessionRef,
  891         const char* LE_NONNULL path,
  892         ///< [IN] Path to the value to write.
  893         int32_t value
  894         ///< [IN] Value to write.
  895 );
  896 
  897 //--------------------------------------------------------------------------------------------------
  898 /**
  899  * Reads a 64-bit floating point value from the config tree. If the value is an integer,
  900  * then it is promoted to a float. Otherwise, if the underlying value is not a float, or an
  901  * integer the default value will be returned.
  902  *
  903  * If the value is empty or the node doesn't exist, the default value is returned.
  904  *
  905  * @note Floating point values will only be stored up to 6 digits of precision.
  906  */
  907 //--------------------------------------------------------------------------------------------------
  908 LE_SHARED double ifgen_le_cfg_QuickGetFloat
  909 (
  910     le_msg_SessionRef_t _ifgen_sessionRef,
  911         const char* LE_NONNULL path,
  912         ///< [IN] Path to the value to write.
  913         double defaultValue
  914         ///< [IN] Default value to use if the original can't be read.
  915 );
  916 
  917 //--------------------------------------------------------------------------------------------------
  918 /**
  919  * Writes a 64-bit floating point value to the config tree.
  920  *
  921  * @note Floating point values will only be stored up to 6 digits of precision.
  922  */
  923 //--------------------------------------------------------------------------------------------------
  924 LE_SHARED void ifgen_le_cfg_QuickSetFloat
  925 (
  926     le_msg_SessionRef_t _ifgen_sessionRef,
  927         const char* LE_NONNULL path,
  928         ///< [IN] Path to the value to write.
  929         double value
  930         ///< [IN] Value to write.
  931 );
  932 
  933 //--------------------------------------------------------------------------------------------------
  934 /**
  935  * Reads a value from the tree as a boolean. If the node is empty or doesn't exist, the default
  936  * value is returned. This is also true if the node is a different type than expected.
  937  *
  938  * If the value is empty or the node doesn't exist, the default value is returned instead.
  939  */
  940 //--------------------------------------------------------------------------------------------------
  941 LE_SHARED bool ifgen_le_cfg_QuickGetBool
  942 (
  943     le_msg_SessionRef_t _ifgen_sessionRef,
  944         const char* LE_NONNULL path,
  945         ///< [IN] Path to the value to write.
  946         bool defaultValue
  947         ///< [IN] Default value to use if the original can't be read.
  948 );
  949 
  950 //--------------------------------------------------------------------------------------------------
  951 /**
  952  * Writes a boolean value to the config tree.
  953  */
  954 //--------------------------------------------------------------------------------------------------
  955 LE_SHARED void ifgen_le_cfg_QuickSetBool
  956 (
  957     le_msg_SessionRef_t _ifgen_sessionRef,
  958         const char* LE_NONNULL path,
  959         ///< [IN] Path to the value to write.
  960         bool value
  961         ///< [IN] Value to write.
  962 );
  963 /** @} **/
  964 #endif // LE_CFG_COMMON_H_INCLUDE_GUARD
LE_CFG_TYPE_BOOL
Boolean value. 
Definition: le_cfg_common.h:82
LE_SHARED
#define LE_SHARED
Definition: le_basics.h:300
le_cfg_nodeType_t
le_cfg_nodeType_t
Definition: le_cfg_common.h:76
le_result_t
le_result_t
Definition: le_basics.h:46
le_cfg_ChangeHandlerRef_t
struct le_cfg_ChangeHandler * le_cfg_ChangeHandlerRef_t
Definition: le_cfg_common.h:101
le_cfg_ChangeHandlerFunc_t
void(* le_cfg_ChangeHandlerFunc_t)(void *contextPtr)
Definition: le_cfg_common.h:110
LE_CFG_TYPE_STRING
A string encoded as utf8. 
Definition: le_cfg_common.h:80
le_msg_SessionRef_t
struct le_msg_Session * le_msg_SessionRef_t
Definition: le_messaging.h:860
le_cfg_IteratorRef_t
struct le_cfg_Iterator * le_cfg_IteratorRef_t
Definition: le_cfg_common.h:68
LE_CFG_TYPE_STEM
Non-leaf node, this node is the parent of other nodes. 
Definition: le_cfg_common.h:88
legato.h
LE_CFG_TYPE_FLOAT
64-bit floating point value. 
Definition: le_cfg_common.h:86
LE_CFG_TYPE_DOESNT_EXIST
Node doesn&#39;t exist. 
Definition: le_cfg_common.h:90
LE_CFG_TYPE_INT
Signed 32-bit. 
Definition: le_cfg_common.h:84
LE_CFG_TYPE_EMPTY
A node with no value. 
Definition: le_cfg_common.h:78