diff --git a/EPTF_Applib_LWM2M_CNL113859.tpd b/EPTF_Applib_LWM2M_CNL113859.tpd
index 02304c6..dfb6414 100644
--- a/EPTF_Applib_LWM2M_CNL113859.tpd
+++ b/EPTF_Applib_LWM2M_CNL113859.tpd
@@ -11,7 +11,7 @@
     Description:        tpd project file
     Rev:                R1B
     Prodnr:             CNL 113 859
-    Updated:            2018-05-31
+    Updated:            2020-03-17
     Contact:            http://ttcn.ericsson.se
 -->
 <TITAN_Project_File_Information version="1.0">
@@ -35,6 +35,7 @@
     <FileResource projectRelativePath="EPTF_LwM2M_LGen_Functions.ttcn" relativeURI="src/EPTF_LwM2M_LGen_Functions.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Object_Definitions.ttcn" relativeURI="src/EPTF_LwM2M_Object_Definitions.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Object_Functions.ttcn" relativeURI="src/EPTF_LwM2M_Object_Functions.ttcn"/>
+    <FileResource projectRelativePath="EPTF_LwM2M_Object_Decoders.ttcn" relativeURI="src/EPTF_LwM2M_Object_Decoders.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Transport_Definitions.ttcn" relativeURI="src/EPTF_LwM2M_Transport_Definitions.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Tests.ttcn" relativeURI="test/EPTF_LwM2M_Tests.ttcn"/>
   </Files>
diff --git a/LightweightM2M_EncDec.tpd b/LightweightM2M_EncDec.tpd
index 04faf05..a3e9c3c 100644
--- a/LightweightM2M_EncDec.tpd
+++ b/LightweightM2M_EncDec.tpd
@@ -11,7 +11,7 @@
     Description:        tpd project file
     Rev:                R1B
     Prodnr:             CNL 113 859
-    Updated:            2017-05-
+    Updated:            2020-03-17
     Contact:            http://ttcn.ericsson.se
 -->
 <TITAN_Project_File_Information version="1.0">
@@ -24,6 +24,10 @@
     <FileResource projectRelativePath="LightweightM2M_Types.ttcn" relativeURI="src/LightweightM2M_Types.ttcn"/>
     <FileResource projectRelativePath="LWM2M_TLV_Types.ttcn" relativeURI="src/LWM2M_TLV_Types.ttcn"/>
     <FileResource projectRelativePath="LWM2M_TLV_EncDec.ttcn" relativeURI="src/LWM2M_TLV_EncDec.ttcn"/>
+    <FileResource projectRelativePath="LWM2M_JSON_Types.ttcn" relativeURI="src/LWM2M_JSON_Types.ttcn"/>
+    <FileResource projectRelativePath="LWM2M_JSON_EncDec.ttcn" relativeURI="src/LWM2M_JSON_EncDec.ttcn"/>
+    <FileResource projectRelativePath="LWM2M_Plain_EncDec.ttcn" relativeURI="src/LWM2M_Plain_EncDec.ttcn"/>
+    <FileResource projectRelativePath="LWM2M_Opaque_EncDec.ttcn" relativeURI="src/LWM2M_Opaque_EncDec.ttcn"/>
   </Files>
   <ActiveConfiguration>Default</ActiveConfiguration>
   <Configurations>
diff --git a/LightweightM2M_Stack.tpd b/LightweightM2M_Stack.tpd
index adbffc7..0597876 100644
--- a/LightweightM2M_Stack.tpd
+++ b/LightweightM2M_Stack.tpd
@@ -11,7 +11,7 @@
     Description:        tpd project file
     Rev:                R1B
     Prodnr:             CNL 113 859
-    Updated:            2018-05-31
+    Updated:            2020-03-17
     Contact:            http://ttcn.ericsson.se
 -->
 <TITAN_Project_File_Information version="1.0">
@@ -23,6 +23,7 @@
     <FileResource projectRelativePath="EPTF_LwM2M_LGen_Functions.ttcn" relativeURI="src/EPTF_LwM2M_LGen_Functions.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Object_Definitions.ttcn" relativeURI="src/EPTF_LwM2M_Object_Definitions.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Object_Functions.ttcn" relativeURI="src/EPTF_LwM2M_Object_Functions.ttcn"/>
+    <FileResource projectRelativePath="EPTF_LwM2M_Object_Decoders.ttcn" relativeURI="src/EPTF_LwM2M_Object_Decoders.ttcn"/>
     <FileResource projectRelativePath="EPTF_LwM2M_Transport_Definitions.ttcn" relativeURI="src/EPTF_LwM2M_Transport_Definitions.ttcn"/>
   </Files>
   <ActiveConfiguration>Default</ActiveConfiguration>
diff --git a/apidoc/Data/ConfigFileInfo.nd b/apidoc/Data/ConfigFileInfo.nd
index 511f999..6c170bd 100644
--- a/apidoc/Data/ConfigFileInfo.nd
+++ b/apidoc/Data/ConfigFileInfo.nd
Binary files differ
diff --git a/apidoc/Data/FileInfo.nd b/apidoc/Data/FileInfo.nd
index 467cca0..2f13ff7 100644
--- a/apidoc/Data/FileInfo.nd
+++ b/apidoc/Data/FileInfo.nd
@@ -1,13 +1,18 @@
 1.52
 TTCN3
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_LGen_Definitions.ttcn	1580733820	1	EPTF_LwM2M_LGen_Definitions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_Object_Functions.ttcn	1580733820	1	EPTF_LwM2M_Object_Functions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_Transport_Definitions.ttcn	1580733820	1	EPTF_LwM2M_Transport_Definitions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_Object_Definitions.ttcn	1580733820	1	EPTF_LwM2M_Object_Definitions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LWM2M_TLV_EncDec.ttcn	1580733820	0	/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LWM2M_TLV_EncDec.ttcn
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LightweightM2M_Types.ttcn	1580733820	1	LightweightM2M_Types
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LWM2M_TLV_Types.ttcn	1580733820	0	/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LWM2M_TLV_Types.ttcn
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_LGen_Functions.ttcn	1580733820	1	EPTF_LwM2M_LGen_Functions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LightweightM2M_CoAP_Binding.ttcn	1580733820	0	/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/LightweightM2M_CoAP_Binding.ttcn
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn	1580733820	1	EPTF_LwM2M_CoapApplibTransport_Functions
-/home/ETHGRY/Titan_FOSS/ApplicationLibraries/LWM2M/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn	1580733820	1	EPTF_LwM2M_CoapApplibTransport_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_LGen_Definitions.ttcn	1583334157	1	EPTF_LwM2M_LGen_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn	1583333365	1	EPTF_LwM2M_CoapApplibTransport_Functions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_Transport_Definitions.ttcn	1583338318	1	EPTF_LwM2M_Transport_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn	1583333346	1	EPTF_LwM2M_CoapApplibTransport_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_Object_Decoders.ttcn	1583337408	1	EPTF_LwM2M_Object_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_Object_Functions.ttcn	1583337807	1	EPTF_LwM2M_Object_Functions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_JSON_EncDec.ttcn	1583333470	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_JSON_EncDec.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_JSON_Types.ttcn	1583333488	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_JSON_Types.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LightweightM2M_CoAP_Binding.ttcn	1584466794	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LightweightM2M_CoAP_Binding.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_Plain_EncDec.ttcn	1583333514	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_Plain_EncDec.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_Object_Definitions.ttcn	1583337985	1	EPTF_LwM2M_Object_Definitions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LightweightM2M_Types.ttcn	1583333576	1	LightweightM2M_Types
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_Opaque_EncDec.ttcn	1583333503	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_Opaque_EncDec.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_TLV_Types.ttcn	1583338242	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_TLV_Types.ttcn
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/EPTF_LwM2M_LGen_Functions.ttcn	1583769682	1	EPTF_LwM2M_LGen_Functions
+/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_TLV_EncDec.ttcn	1583333527	0	/home/eantwuh/build/git/miot_ft/src/Libraries/EPTF_Applib_LWM2M_CNL113859/src/LWM2M_TLV_EncDec.ttcn
diff --git a/apidoc/Data/ImageFileInfo.nd b/apidoc/Data/ImageFileInfo.nd
index 278e2bf..95df73a 100644
--- a/apidoc/Data/ImageFileInfo.nd
+++ b/apidoc/Data/ImageFileInfo.nd
Binary files differ
diff --git a/apidoc/Data/ImageReferenceTable.nd b/apidoc/Data/ImageReferenceTable.nd
index b6ead97..169033a 100644
--- a/apidoc/Data/ImageReferenceTable.nd
+++ b/apidoc/Data/ImageReferenceTable.nd
Binary files differ
diff --git a/apidoc/Data/IndexInfo.nd b/apidoc/Data/IndexInfo.nd
index 6c7b85e..abd63be 100644
--- a/apidoc/Data/IndexInfo.nd
+++ b/apidoc/Data/IndexInfo.nd
Binary files differ
diff --git a/apidoc/Data/PreviousMenuState.nd b/apidoc/Data/PreviousMenuState.nd
index c6d4146..30d6334 100644
--- a/apidoc/Data/PreviousMenuState.nd
+++ b/apidoc/Data/PreviousMenuState.nd
Binary files differ
diff --git a/apidoc/Data/PreviousSettings.nd b/apidoc/Data/PreviousSettings.nd
index c20c0bd..7012d5c 100644
--- a/apidoc/Data/PreviousSettings.nd
+++ b/apidoc/Data/PreviousSettings.nd
Binary files differ
diff --git a/apidoc/Data/SymbolTable.nd b/apidoc/Data/SymbolTable.nd
index e323dcf..b7f567b 100644
--- a/apidoc/Data/SymbolTable.nd
+++ b/apidoc/Data/SymbolTable.nd
Binary files differ
diff --git a/apidoc/Languages.txt b/apidoc/Languages.txt
index 8010ca3..2ce6a55 100755
--- a/apidoc/Languages.txt
+++ b/apidoc/Languages.txt
@@ -122,5 +122,5 @@
    Type Prototype Enders: ; \n
    Constant Prototype Enders: ; }
    Template Prototype Enders: := {
-   Component Prototype Enders: ; {
    Altstep Prototype Enders: ; {
+   Component Prototype Enders: ; {
diff --git a/apidoc/Menu.txt b/apidoc/Menu.txt
index e3ec154..89ee373 100644
--- a/apidoc/Menu.txt
+++ b/apidoc/Menu.txt
@@ -1,7 +1,7 @@
 Format: 1.52
 
 
-Title: LwM2M_Applib
+Title: Massive IoT Test Tools
 SubTitle: API Documentation
 
 Footer: Copyright 2020 Test Competence Center
@@ -43,6 +43,7 @@
 File: EPTF_LwM2M_LGen_Definitions  (EPTF_LwM2M_LGen_Definitions.ttcn)
 File: EPTF_LwM2M_LGen_Functions  (EPTF_LwM2M_LGen_Functions.ttcn)
 File: EPTF_LwM2M_Object_Definitions  (EPTF_LwM2M_Object_Definitions.ttcn)
+File: EPTF_LwM2M_Object_Definitions  (EPTF_LwM2M_Object_Decoders.ttcn)
 File: EPTF_LwM2M_Object_Functions  (EPTF_LwM2M_Object_Functions.ttcn)
 File: EPTF_LwM2M_Transport_Definitions  (EPTF_LwM2M_Transport_Definitions.ttcn)
 File: LightweightM2M_Types  (LightweightM2M_Types.ttcn)
diff --git a/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html
index 8983bd4..2e22b42 100644
--- a/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_CoapApplibTransport_Definitions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_CoapApplibTransport_Definitions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -13,9 +13,9 @@
 
 <div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_CoapApplibTransport_debug"></a>tsp_EPTF_LwM2M_CoapApplibTransport_debug</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Enabled/disable debug logging</p><h4 class=CHeading>Type</h4><p><b>boolean</b></p><h4 class=CHeading>Default value</h4><p><b>false</b></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_CoapApplibTransport_CT"></a>EPTF_LwM2M_CoapApplibTransport_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>LWM2M local transport component realized with &lt;EPTF_COAP_LGen_CT&gt;</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_CT.jpg)</p><h4 class=CHeading>Extensions</h4><ul><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')">EPTF_LwM2M_Transport_Provider_CT</a></li><li>&lt;EPTF_COAP_LGen_CT&gt;</li><li>&lt;EPTF_Base_CT&gt;</li></ul><h4 class=CHeading>Ports</h4><p>-</p><h4 class=CHeading>Timers</h4><p>-</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_EPTF_LwM2M_CoapApplibTransport_initialized</td><td class=CDLDescription><b>boolean</b> - Flag to indicate if the init function was already called</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=LFunction id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')">f_EPTF_LwM2M_CoapApplibTransport_init</a> (<b>in charstring</b> pl_name)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=LFunction id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')">f_EPTF_LwM2M_CoapApplibTransport_cleanup</a> ()</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=LFunction id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')">f_EPTF_LwM2M_CoapApplibTransport_send</a> (<b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')">EPTF_LwM2M_PDU</a> pl_msg)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=LFunction id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')">f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a> (<b>in</b> &lt;EPTF_COAP_PDU&gt; pl_message, in <b>boolean</b> p_duplicate)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=LFunction id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')">f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a> (<b>in</b> &lt;EPTF_COAP_EventDescriptor&gt; pl_event)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=LFunction id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')">f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a> (<b>in</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath" class=LType id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')">ObjectPath</a> p_path)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_CoapApplibTransport_CT"></a>EPTF_LwM2M_CoapApplibTransport_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>LWM2M local transport component realized with &lt;EPTF_COAP_LGen_CT&gt;</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_CT.jpg"><h4 class=CHeading>Extensions</h4><ul><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')">EPTF_LwM2M_Transport_Provider_CT</a></li><li>&lt;EPTF_COAP_LGen_CT&gt;</li><li>&lt;EPTF_Base_CT&gt;</li></ul><h4 class=CHeading>Ports</h4><p>-</p><h4 class=CHeading>Timers</h4><p>-</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_EPTF_LwM2M_CoapApplibTransport_initialized</td><td class=CDLDescription><b>boolean</b> - Flag to indicate if the init function was already called</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=LFunction id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')">f_EPTF_LwM2M_CoapApplibTransport_init</a> (<b>in charstring</b> pl_name)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=LFunction id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')">f_EPTF_LwM2M_CoapApplibTransport_cleanup</a> ()</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=LFunction id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')">f_EPTF_LwM2M_CoapApplibTransport_send</a> (<b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')">EPTF_LwM2M_PDU</a> pl_msg)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=LFunction id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')">f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a> (<b>in</b> &lt;EPTF_COAP_PDU&gt; pl_message, in <b>boolean</b> p_duplicate)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=LFunction id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')">f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a> (<b>in</b> &lt;EPTF_COAP_EventDescriptor&gt; pl_event)</li><li><a href="EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=LFunction id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')">f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a> (<b>in</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath" class=LType id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')">ObjectPath</a> p_path)</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_CoapApplibTransport_Statistics"></a>EPTF_LwM2M_CoapApplibTransport_Statistics</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_CoapApplibTransport_Statistics</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing counters for transport related statistics</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_Statistics.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>nofReceivedMessages</td><td class=CDLDescription><b>integer</b> - number of received messages</td></tr><tr><td class=CDLEntry>nofSentMessages</td><td class=CDLDescription><b>integer</b> - number of sent messages</td></tr><tr><td class=CDLEntry>nofDecodingErrors</td><td class=CDLDescription><b>integer</b> - number of times the COAP messages couldn&rsquo;t be mapped to LwM2M</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_CoapApplibTransport_Statistics"></a>EPTF_LwM2M_CoapApplibTransport_Statistics</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_CoapApplibTransport_Statistics</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing counters for transport related statistics</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_Statistics.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>nofReceivedMessages</td><td class=CDLDescription><b>integer</b> - number of received messages</td></tr><tr><td class=CDLEntry>nofSentMessages</td><td class=CDLDescription><b>integer</b> - number of sent messages</td></tr><tr><td class=CDLEntry>nofDecodingErrors</td><td class=CDLDescription><b>integer</b> - number of times the COAP messages couldn&rsquo;t be mapped to LwM2M</td></tr></table></div></div></div>
 
 </div><!--Content-->
 
diff --git a/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html
index ca5d4a3..a238490 100644
--- a/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_CoapApplibTransport_Functions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_CoapApplibTransport_Functions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
diff --git a/apidoc/html/files/EPTF_LwM2M_LGen_Definitions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_LGen_Definitions-ttcn.html
index 66d9133..c49af65 100644
--- a/apidoc/html/files/EPTF_LwM2M_LGen_Definitions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_LGen_Definitions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_LGen_Definitions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_LGen_Definitions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -9,7 +9,7 @@
 
 
 
-<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_LGen_Definitions"></a>EPTF_LwM2M_LGen_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the definitions for the LWM2M load generator component</p><h4 class=CHeading>Module depends on</h4><ul><li><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=LFile id=link103 onMouseOver="ShowTip(event, 'tt96', 'link103')" onMouseOut="HideTip('tt96')">EPTF_LwM2M_Object_Definitions</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=LFile id=link104 onMouseOver="ShowTip(event, 'tt97', 'link104')" onMouseOut="HideTip('tt97')">EPTF_LwM2M_Transport_Definitions</a></li><li>&lt;EPTF_CLL_LGenBase_Definitions&gt;</li><li>&lt;EPTF_CLL_Logging_Definitions&gt;</li><li>&lt;EPTF_CLL_FBQ_Definitions&gt;</li><li><a href="LightweightM2M_Types-ttcn.html#LightweightM2M_Types" class=LFile id=link105 onMouseOver="ShowTip(event, 'tt98', 'link105')" onMouseOut="HideTip('tt98')">LightweightM2M_Types</a></li></ul><h4 class=CHeading>Module Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_log_error</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_log_error" class=LModuleParameter id=link106 onMouseOver="ShowTip(event, 'tt99', 'link106')" onMouseOut="HideTip('tt99')">tsp_EPTF_LwM2M_LGen_log_error</a> - <b>boolean</b> - Enabled/disable error logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_log_warning</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_log_warning" class=LModuleParameter id=link107 onMouseOver="ShowTip(event, 'tt100', 'link107')" onMouseOut="HideTip('tt100')">tsp_EPTF_LwM2M_LGen_log_warning</a> - <b>boolean</b> - Enabled/disable warning logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_debug</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_debug" class=LModuleParameter id=link108 onMouseOver="ShowTip(event, 'tt101', 'link108')" onMouseOut="HideTip('tt101')">tsp_EPTF_LwM2M_LGen_debug</a> - <b>boolean</b> - Enabled/disable debug logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_debugVerbose</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_debugVerbose" class=LModuleParameter id=link109 onMouseOver="ShowTip(event, 'tt102', 'link109')" onMouseOut="HideTip('tt102')">tsp_EPTF_LwM2M_LGen_debugVerbose</a> - <b>boolean</b> - Enabled/disable verbose debug logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_templates</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link110 onMouseOver="ShowTip(event, 'tt103', 'link110')" onMouseOut="HideTip('tt103')">tsp_EPTF_LwM2M_LGen_templates</a> - <a href="#LwM2M_Template_List" class=LType id=link111 onMouseOver="ShowTip(event, 'tt9', 'link111')" onMouseOut="HideTip('tt9')">LwM2M_Template_List</a> - LWM2M template definitions for sending</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_objectSpecifications</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=LModuleParameter id=link112 onMouseOver="ShowTip(event, 'tt104', 'link112')" onMouseOut="HideTip('tt104')">tsp_EPTF_LwM2M_LGen_objectSpecifications</a> - <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=LType id=link113 onMouseOver="ShowTip(event, 'tt105', 'link113')" onMouseOut="HideTip('tt105')">LwM2M_ObjectSpecification_List</a> - Additional smart object specifications to be loaded</td></tr></table><h4 class=CHeading>Events</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>LWM2M Register request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Register" class=LConstant id=link114 onMouseOver="ShowTip(event, 'tt15', 'link114')" onMouseOut="HideTip('tt15')">c_LwM2M_eventIdx_Register</a>, <a href="#c_LwM2M_eventName_Register" class=LConstant id=link115 onMouseOver="ShowTip(event, 'tt16', 'link115')" onMouseOut="HideTip('tt16')">c_LwM2M_eventName_Register</a></td></tr><tr><td class=CDLEntry>LWM2M Update request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Update" class=LConstant id=link116 onMouseOver="ShowTip(event, 'tt17', 'link116')" onMouseOut="HideTip('tt17')">c_LwM2M_eventIdx_Update</a>, <a href="#c_LwM2M_eventName_Update" class=LConstant id=link117 onMouseOver="ShowTip(event, 'tt18', 'link117')" onMouseOut="HideTip('tt18')">c_LwM2M_eventName_Update</a></td></tr><tr><td class=CDLEntry>LWM2M Deregister request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Deregister" class=LConstant id=link118 onMouseOver="ShowTip(event, 'tt19', 'link118')" onMouseOut="HideTip('tt19')">c_LwM2M_eventIdx_Deregister</a>, <a href="#c_LwM2M_eventName_Deregister" class=LConstant id=link119 onMouseOver="ShowTip(event, 'tt20', 'link119')" onMouseOut="HideTip('tt20')">c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=CDLEntry>LWM2M Read request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Read" class=LConstant id=link120 onMouseOver="ShowTip(event, 'tt21', 'link120')" onMouseOut="HideTip('tt21')">c_LwM2M_eventIdx_Read</a>, <a href="#c_LwM2M_eventName_Read" class=LConstant id=link121 onMouseOver="ShowTip(event, 'tt22', 'link121')" onMouseOut="HideTip('tt22')">c_LwM2M_eventName_Read</a></td></tr><tr><td class=CDLEntry>LWM2M Write request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Write" class=LConstant id=link122 onMouseOver="ShowTip(event, 'tt23', 'link122')" onMouseOut="HideTip('tt23')">c_LwM2M_eventIdx_Write</a>, <a href="#c_LwM2M_eventName_Write" class=LConstant id=link123 onMouseOver="ShowTip(event, 'tt24', 'link123')" onMouseOut="HideTip('tt24')">c_LwM2M_eventName_Write</a></td></tr><tr><td class=CDLEntry>LWM2M Execute request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Execute" class=LConstant id=link124 onMouseOver="ShowTip(event, 'tt25', 'link124')" onMouseOut="HideTip('tt25')">c_LwM2M_eventIdx_Execute</a>, <a href="#c_LwM2M_eventName_Execute" class=LConstant id=link125 onMouseOver="ShowTip(event, 'tt26', 'link125')" onMouseOut="HideTip('tt26')">c_LwM2M_eventName_Execute</a></td></tr><tr><td class=CDLEntry>LWM2M Create request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Create" class=LConstant id=link126 onMouseOver="ShowTip(event, 'tt27', 'link126')" onMouseOut="HideTip('tt27')">c_LwM2M_eventIdx_Create</a>, <a href="#c_LwM2M_eventName_Create" class=LConstant id=link127 onMouseOver="ShowTip(event, 'tt28', 'link127')" onMouseOut="HideTip('tt28')">c_LwM2M_eventName_Create</a></td></tr><tr><td class=CDLEntry>LWM2M Delete request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Delete" class=LConstant id=link128 onMouseOver="ShowTip(event, 'tt29', 'link128')" onMouseOut="HideTip('tt29')">c_LwM2M_eventIdx_Delete</a>, <a href="#c_LwM2M_eventName_Delete" class=LConstant id=link129 onMouseOver="ShowTip(event, 'tt30', 'link129')" onMouseOut="HideTip('tt30')">c_LwM2M_eventName_Delete</a></td></tr><tr><td class=CDLEntry>LWM2M 1xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_1xx" class=LConstant id=link130 onMouseOver="ShowTip(event, 'tt45', 'link130')" onMouseOut="HideTip('tt45')">c_LwM2M_eventIdx_1xx</a>, <a href="#c_LwM2M_eventName_1xx" class=LConstant id=link131 onMouseOver="ShowTip(event, 'tt46', 'link131')" onMouseOut="HideTip('tt46')">c_LwM2M_eventName_1xx</a></td></tr><tr><td class=CDLEntry>LWM2M 2xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_2xx" class=LConstant id=link132 onMouseOver="ShowTip(event, 'tt47', 'link132')" onMouseOut="HideTip('tt47')">c_LwM2M_eventIdx_2xx</a>, <a href="#c_LwM2M_eventName_2xx" class=LConstant id=link133 onMouseOver="ShowTip(event, 'tt48', 'link133')" onMouseOut="HideTip('tt48')">c_LwM2M_eventName_2xx</a></td></tr><tr><td class=CDLEntry>LWM2M 3xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_3xx" class=LConstant id=link134 onMouseOver="ShowTip(event, 'tt49', 'link134')" onMouseOut="HideTip('tt49')">c_LwM2M_eventIdx_3xx</a>, <a href="#c_LwM2M_eventName_3xx" class=LConstant id=link135 onMouseOver="ShowTip(event, 'tt50', 'link135')" onMouseOut="HideTip('tt50')">c_LwM2M_eventName_3xx</a></td></tr><tr><td class=CDLEntry>LWM2M 4xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_4xx" class=LConstant id=link136 onMouseOver="ShowTip(event, 'tt51', 'link136')" onMouseOut="HideTip('tt51')">c_LwM2M_eventIdx_4xx</a>, <a href="#c_LwM2M_eventName_4xx" class=LConstant id=link137 onMouseOver="ShowTip(event, 'tt52', 'link137')" onMouseOut="HideTip('tt52')">c_LwM2M_eventName_4xx</a></td></tr><tr><td class=CDLEntry>LWM2M 5xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_5xx" class=LConstant id=link138 onMouseOver="ShowTip(event, 'tt53', 'link138')" onMouseOut="HideTip('tt53')">c_LwM2M_eventIdx_5xx</a>, <a href="#c_LwM2M_eventName_5xx" class=LConstant id=link139 onMouseOver="ShowTip(event, 'tt54', 'link139')" onMouseOut="HideTip('tt54')">c_LwM2M_eventName_5xx</a></td></tr><tr><td class=CDLEntry>LWM2M 6xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_6xx" class=LConstant id=link140 onMouseOver="ShowTip(event, 'tt55', 'link140')" onMouseOut="HideTip('tt55')">c_LwM2M_eventIdx_6xx</a>, <a href="#c_LwM2M_eventName_6xx" class=LConstant id=link141 onMouseOver="ShowTip(event, 'tt56', 'link141')" onMouseOut="HideTip('tt56')">c_LwM2M_eventName_6xx</a></td></tr><tr><td class=CDLEntry>LWM2M 3xxto6xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_3xxto6xx" class=LConstant id=link142 onMouseOver="ShowTip(event, 'tt57', 'link142')" onMouseOut="HideTip('tt57')">c_LwM2M_eventIdx_3xxto6xx</a>, <a href="#c_LwM2M_eventName_3xxto6xx" class=LConstant id=link143 onMouseOver="ShowTip(event, 'tt58', 'link143')" onMouseOut="HideTip('tt58')">c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=CDLEntry>LWM2M resource not observed any more indication</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_resourceNotObservedIndication" class=LConstant id=link144 onMouseOver="ShowTip(event, 'tt59', 'link144')" onMouseOut="HideTip('tt59')">c_LwM2M_eventIdx_resourceNotObservedIndication</a>, <a href="#c_LwM2M_eventName_resourceNotObservedIndication" class=LConstant id=link145 onMouseOver="ShowTip(event, 'tt60', 'link145')" onMouseOut="HideTip('tt60')">c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr></table><h4 class=CHeading>TestSteps</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>LWM2M load template</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link146 onMouseOver="ShowTip(event, 'tt106', 'link146')" onMouseOut="HideTip('tt106')">f_LwM2M_step_loadTemplate_byIntIdx</a>, <a href="#c_LwM2M_stepName_loadTemplate_byIntIdx" class=LConstant id=link147 onMouseOver="ShowTip(event, 'tt64', 'link147')" onMouseOut="HideTip('tt64')">c_LwM2M_stepName_loadTemplate_byIntIdx</a>, <a href="#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=LConstant id=link148 onMouseOver="ShowTip(event, 'tt63', 'link148')" onMouseOut="HideTip('tt63')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a> <a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link149 onMouseOver="ShowTip(event, 'tt107', 'link149')" onMouseOut="HideTip('tt107')">f_LwM2M_step_loadTemplate_byStringId</a>, <a href="#c_LwM2M_stepName_send" class=LConstant id=link150 onMouseOver="ShowTip(event, 'tt66', 'link150')" onMouseOut="HideTip('tt66')">c_LwM2M_stepName_send</a>, <a href="#c_LwM2M_stepIdx_loadTemplate_byStringId" class=LConstant id=link151 onMouseOver="ShowTip(event, 'tt83', 'link151')" onMouseOut="HideTip('tt83')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=CDLEntry>LWM2M send</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link152 onMouseOver="ShowTip(event, 'tt108', 'link152')" onMouseOut="HideTip('tt108')">f_LwM2M_step_send</a>, <a href="#c_LwM2M_stepName_send" class=LConstant id=link153 onMouseOver="ShowTip(event, 'tt66', 'link153')" onMouseOut="HideTip('tt66')">c_LwM2M_stepName_send</a>, <a href="#c_LwM2M_stepIdx_send" class=LConstant id=link154 onMouseOver="ShowTip(event, 'tt65', 'link154')" onMouseOut="HideTip('tt65')">c_LwM2M_stepIdx_send</a></td></tr><tr><td class=CDLEntry>LWM2M create device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link155 onMouseOver="ShowTip(event, 'tt109', 'link155')" onMouseOut="HideTip('tt109')">f_LwM2M_step_createDevice</a>, <a href="#c_LwM2M_stepName_createDevice" class=LConstant id=link156 onMouseOver="ShowTip(event, 'tt68', 'link156')" onMouseOut="HideTip('tt68')">c_LwM2M_stepName_createDevice</a>, <a href="#c_LwM2M_stepIdx_createDevice" class=LConstant id=link157 onMouseOver="ShowTip(event, 'tt67', 'link157')" onMouseOut="HideTip('tt67')">c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=CDLEntry>LWM2M clean up device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link158 onMouseOver="ShowTip(event, 'tt110', 'link158')" onMouseOut="HideTip('tt110')">f_LwM2M_step_cleanupDevice</a>, <a href="#c_LwM2M_stepName_cleanupDevice" class=LConstant id=link159 onMouseOver="ShowTip(event, 'tt70', 'link159')" onMouseOut="HideTip('tt70')">c_LwM2M_stepName_cleanupDevice</a>, <a href="#c_LwM2M_stepIdx_cleanupDevice" class=LConstant id=link160 onMouseOver="ShowTip(event, 'tt69', 'link160')" onMouseOut="HideTip('tt69')">c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=CDLEntry>LWM2M log device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link161 onMouseOver="ShowTip(event, 'tt111', 'link161')" onMouseOut="HideTip('tt111')">f_LwM2M_step_logDevice</a>, <a href="#c_LwM2M_stepName_logDevice" class=LConstant id=link162 onMouseOver="ShowTip(event, 'tt72', 'link162')" onMouseOut="HideTip('tt72')">c_LwM2M_stepName_logDevice</a>, <a href="#c_LwM2M_stepIdx_logDevice" class=LConstant id=link163 onMouseOver="ShowTip(event, 'tt71', 'link163')" onMouseOut="HideTip('tt71')">c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=CDLEntry>LWM2M create object</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link164 onMouseOver="ShowTip(event, 'tt112', 'link164')" onMouseOut="HideTip('tt112')">f_LwM2M_step_createObject</a>, <a href="#c_LwM2M_stepName_createObject" class=LConstant id=link165 onMouseOver="ShowTip(event, 'tt74', 'link165')" onMouseOut="HideTip('tt74')">c_LwM2M_stepName_createObject</a>, <a href="#c_LwM2M_stepIdx_createObject" class=LConstant id=link166 onMouseOver="ShowTip(event, 'tt73', 'link166')" onMouseOut="HideTip('tt73')">c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=CDLEntry>LWM2M create object instance</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link167 onMouseOver="ShowTip(event, 'tt113', 'link167')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createObjectInstance</a>, <a href="#c_LwM2M_stepName_createObjectInstance" class=LConstant id=link168 onMouseOver="ShowTip(event, 'tt76', 'link168')" onMouseOut="HideTip('tt76')">c_LwM2M_stepName_createObjectInstance</a>, <a href="#c_LwM2M_stepIdx_createObjectInstance" class=LConstant id=link169 onMouseOver="ShowTip(event, 'tt75', 'link169')" onMouseOut="HideTip('tt75')">c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=CDLEntry>LWM2M handle READ request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link170 onMouseOver="ShowTip(event, 'tt114', 'link170')" onMouseOut="HideTip('tt114')">f_LwM2M_step_handleReadRequest</a>, <a href="#c_LwM2M_stepName_handleReadRequest" class=LConstant id=link171 onMouseOver="ShowTip(event, 'tt78', 'link171')" onMouseOut="HideTip('tt78')">c_LwM2M_stepName_handleReadRequest</a>, <a href="#c_LwM2M_stepIdx_handleReadRequest" class=LConstant id=link172 onMouseOver="ShowTip(event, 'tt77', 'link172')" onMouseOut="HideTip('tt77')">c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=CDLEntry>LWM2M handle WRITE request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link173 onMouseOver="ShowTip(event, 'tt115', 'link173')" onMouseOut="HideTip('tt115')">f_LwM2M_step_handleWriteRequest</a>, <a href="#c_LwM2M_stepName_handleWriteRequest" class=LConstant id=link174 onMouseOver="ShowTip(event, 'tt80', 'link174')" onMouseOut="HideTip('tt80')">c_LwM2M_stepName_handleWriteRequest</a>, <a href="#c_LwM2M_stepIdx_handleWriteRequest" class=LConstant id=link175 onMouseOver="ShowTip(event, 'tt79', 'link175')" onMouseOut="HideTip('tt79')">c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=CDLEntry>LWM2M handle EXECUTE request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link176 onMouseOver="ShowTip(event, 'tt116', 'link176')" onMouseOut="HideTip('tt116')">f_LwM2M_step_handleExecuteRequest</a>, <a href="#c_LwM2M_stepName_handleExecuteRequest" class=LConstant id=link177 onMouseOver="ShowTip(event, 'tt82', 'link177')" onMouseOut="HideTip('tt82')">c_LwM2M_stepName_handleExecuteRequest</a>, <a href="#c_LwM2M_stepIdx_handleExecuteRequest" class=LConstant id=link178 onMouseOver="ShowTip(event, 'tt81', 'link178')" onMouseOut="HideTip('tt81')">c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=CDLEntry>LWM2M send NOTIFICATION</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=LFunction id=link179 onMouseOver="ShowTip(event, 'tt117', 'link179')" onMouseOut="HideTip('tt117')">f_LwM2M_step_sendNotificationForObservedResources</a>, <a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link180 onMouseOver="ShowTip(event, 'tt86', 'link180')" onMouseOut="HideTip('tt86')">c_LwM2M_stepName_sendNotificationForObservedResources</a>, <a href="#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=LConstant id=link181 onMouseOver="ShowTip(event, 'tt85', 'link181')" onMouseOut="HideTip('tt85')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr></table><h4 class=CHeading>Class Diagram</h4><p>(see EPTF_LwM2M_LGen_Definitions.classes.jpg)</p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Definitions" >EPTF_LwM2M_LGen_Definitions</a></td><td class=SDescription>This module contains the definitions for the LWM2M load generator component</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_log_error" >tsp_EPTF_LwM2M_LGen_log_error</a></td><td class=SDescription>Enabled/disable error logging</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_log_warning" >tsp_EPTF_LwM2M_LGen_log_warning</a></td><td class=SDescription>Enabled/disable warning logging</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_debug" >tsp_EPTF_LwM2M_LGen_debug</a></td><td class=SDescription>Enabled/disable debug logging</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_debugVerbose" >tsp_EPTF_LwM2M_LGen_debugVerbose</a></td><td class=SDescription>Enabled/disable verbose debug logging</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_templates" >tsp_EPTF_LwM2M_LGen_templates</a></td><td class=SDescription>List of LWM2M messages for sending</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_objectSpecifications" >tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td><td class=SDescription>List of smart object specifications (needed for creating smart object instances)</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">c_LwM2M_behaviorType</a></td><td class=SDescription>Constant for LWM2M behaviour name</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_EntityCtx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td><td class=SDescription>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_EntityCtx_List" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">LwM2M_EntityCtx_List</a></td><td class=SDescription>List of <a href="#LwM2M_EntityCtx" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_EntityCtx_DB" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">LwM2M_EntityCtx_DB</a></td><td class=SDescription>Storing LWM2M entity contexts</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Device" id=link6 onMouseOver="ShowTip(event, 'tt5', 'link6')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></td><td class=SDescription>Storing the state and smart object of a simulated LWM2M device</td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_Device_State" >LwM2M_Device_State</a></td><td class=SDescription>States of a <a href="#LwM2M_Device" class=LType id=link7 onMouseOver="ShowTip(event, 'tt5', 'link7')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</td></tr><tr class="SEnumeration SMarked"><td class=SEntry><a href="#LwM2M_Block1_Handling" >LwM2M_Block1_Handling</a></td><td class=SDescription>Block1 handling strategy of a <a href="#LwM2M_Device" class=LType id=link8 onMouseOver="ShowTip(event, 'tt5', 'link8')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Device_List" id=link9 onMouseOver="ShowTip(event, 'tt6', 'link9')" onMouseOut="HideTip('tt6')">LwM2M_Device_List</a></td><td class=SDescription>List of <a href="#LwM2M_Device" class=LType id=link10 onMouseOver="ShowTip(event, 'tt5', 'link10')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Device_DB" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">LwM2M_Device_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_Device" class=LType id=link12 onMouseOver="ShowTip(event, 'tt5', 'link12')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Template" id=link13 onMouseOver="ShowTip(event, 'tt8', 'link13')" onMouseOut="HideTip('tt8')">LwM2M_Template</a></td><td class=SDescription>Grouping a &lt;LWM2M_PDU&gt; with an id so that the message can be loaded from an FSM later by using the id</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Template_List" id=link14 onMouseOver="ShowTip(event, 'tt9', 'link14')" onMouseOut="HideTip('tt9')">LwM2M_Template_List</a></td><td class=SDescription>List of <a href="#LwM2M_Template" class=LType id=link15 onMouseOver="ShowTip(event, 'tt8', 'link15')" onMouseOut="HideTip('tt8')">LwM2M_Template</a></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Template_DB" id=link16 onMouseOver="ShowTip(event, 'tt10', 'link16')" onMouseOut="HideTip('tt10')">LwM2M_Template_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_Template" class=LType id=link17 onMouseOver="ShowTip(event, 'tt8', 'link17')" onMouseOut="HideTip('tt8')">LwM2M_Template</a> instances</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_StepCtx" id=link18 onMouseOver="ShowTip(event, 'tt11', 'link18')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a></td><td class=SDescription>Stores the most important pointers that are used from a test steps</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_LGen_CT" id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">EPTF_LwM2M_LGen_CT</a></td><td class=SDescription>LWM2M load generator component</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Statistics" id=link20 onMouseOver="ShowTip(event, 'tt13', 'link20')" onMouseOut="HideTip('tt13')">EPTF_LwM2M_LGen_Statistics</a></td><td class=SDescription>Storing counters for load generator related statistics</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_Message_Statistics" id=link21 onMouseOver="ShowTip(event, 'tt14', 'link21')" onMouseOut="HideTip('tt14')">EPTF_LwM2M_Message_Statistics</a></td><td class=SDescription>Storing counters for message related statistics</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Register" id=link22 onMouseOver="ShowTip(event, 'tt15', 'link22')" onMouseOut="HideTip('tt15')">c_LwM2M_eventIdx_Register</a></td><td class=SDescription>Integer constant for the LWM2M Register request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Register" id=link23 onMouseOver="ShowTip(event, 'tt16', 'link23')" onMouseOut="HideTip('tt16')">c_LwM2M_eventName_Register</a></td><td class=SDescription>Charstring constant for the LWM2M Register request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Update" id=link24 onMouseOver="ShowTip(event, 'tt17', 'link24')" onMouseOut="HideTip('tt17')">c_LwM2M_eventIdx_Update</a></td><td class=SDescription>Integer constant for the LWM2M Update request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Update" id=link25 onMouseOver="ShowTip(event, 'tt18', 'link25')" onMouseOut="HideTip('tt18')">c_LwM2M_eventName_Update</a></td><td class=SDescription>Charstring constant for the LWM2M Update request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Deregister" id=link26 onMouseOver="ShowTip(event, 'tt19', 'link26')" onMouseOut="HideTip('tt19')">c_LwM2M_eventIdx_Deregister</a></td><td class=SDescription>Integer constant for the LWM2M Deregister request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Deregister" id=link27 onMouseOver="ShowTip(event, 'tt20', 'link27')" onMouseOut="HideTip('tt20')">c_LwM2M_eventName_Deregister</a></td><td class=SDescription>Charstring constant for the LWM2M Deregister request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Read" id=link28 onMouseOver="ShowTip(event, 'tt21', 'link28')" onMouseOut="HideTip('tt21')">c_LwM2M_eventIdx_Read</a></td><td class=SDescription>Integer constant for the LWM2M Read request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Read" id=link29 onMouseOver="ShowTip(event, 'tt22', 'link29')" onMouseOut="HideTip('tt22')">c_LwM2M_eventName_Read</a></td><td class=SDescription>Charstring constant for the LWM2M Read request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Write" id=link30 onMouseOver="ShowTip(event, 'tt23', 'link30')" onMouseOut="HideTip('tt23')">c_LwM2M_eventIdx_Write</a></td><td class=SDescription>Integer constant for the LWM2M Write request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Write" id=link31 onMouseOver="ShowTip(event, 'tt24', 'link31')" onMouseOut="HideTip('tt24')">c_LwM2M_eventName_Write</a></td><td class=SDescription>Charstring constant for the LWM2M Write request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Execute" id=link32 onMouseOver="ShowTip(event, 'tt25', 'link32')" onMouseOut="HideTip('tt25')">c_LwM2M_eventIdx_Execute</a></td><td class=SDescription>Integer constant for the LWM2M Execute request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Execute" id=link33 onMouseOver="ShowTip(event, 'tt26', 'link33')" onMouseOut="HideTip('tt26')">c_LwM2M_eventName_Execute</a></td><td class=SDescription>Charstring constant for the LWM2M Execute request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Create" id=link34 onMouseOver="ShowTip(event, 'tt27', 'link34')" onMouseOut="HideTip('tt27')">c_LwM2M_eventIdx_Create</a></td><td class=SDescription>Integer constant for the LWM2M Create request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Create" id=link35 onMouseOver="ShowTip(event, 'tt28', 'link35')" onMouseOut="HideTip('tt28')">c_LwM2M_eventName_Create</a></td><td class=SDescription>Charstring constant for the LWM2M Create request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Delete" id=link36 onMouseOver="ShowTip(event, 'tt29', 'link36')" onMouseOut="HideTip('tt29')">c_LwM2M_eventIdx_Delete</a></td><td class=SDescription>Integer constant for the LWM2M Delete request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Delete" id=link37 onMouseOver="ShowTip(event, 'tt30', 'link37')" onMouseOut="HideTip('tt30')">c_LwM2M_eventName_Delete</a></td><td class=SDescription>Charstring constant for the LWM2M Delete request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Observe" id=link38 onMouseOver="ShowTip(event, 'tt31', 'link38')" onMouseOut="HideTip('tt31')">c_LwM2M_eventIdx_Observe</a></td><td class=SDescription>Integer constant for the LWM2M Observe request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Observe" id=link39 onMouseOver="ShowTip(event, 'tt32', 'link39')" onMouseOut="HideTip('tt32')">c_LwM2M_eventName_Observe</a></td><td class=SDescription>Charstring constant for the LWM2M Observe request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_WriteFWUri" id=link40 onMouseOver="ShowTip(event, 'tt33', 'link40')" onMouseOut="HideTip('tt33')">c_LwM2M_eventIdx_WriteFWUri</a></td><td class=SDescription>Integer constant for the LWM2M WriteFWUri request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_WriteFWUri" id=link41 onMouseOver="ShowTip(event, 'tt34', 'link41')" onMouseOut="HideTip('tt34')">c_LwM2M_eventName_WriteFWUri</a></td><td class=SDescription>Charstring constant for the LWM2M WriteFWUri request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_WriteFWPackage" id=link42 onMouseOver="ShowTip(event, 'tt35', 'link42')" onMouseOut="HideTip('tt35')">c_LwM2M_eventIdx_WriteFWPackage</a></td><td class=SDescription>Integer constant for the LWM2M WriteFWPackage request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_WriteFWPackage" id=link43 onMouseOver="ShowTip(event, 'tt36', 'link43')" onMouseOut="HideTip('tt36')">c_LwM2M_eventName_WriteFWPackage</a></td><td class=SDescription>Charstring constant for the LWM2M WriteFWPackage request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link44 onMouseOver="ShowTip(event, 'tt37', 'link44')" onMouseOut="HideTip('tt37')">c_LwM2M_eventIdx_ExecuteFWUpdate</a></td><td class=SDescription>Integer constant for the LWM2M ExecuteFWUpdate request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_ExecuteFWUpdate" id=link45 onMouseOver="ShowTip(event, 'tt38', 'link45')" onMouseOut="HideTip('tt38')">c_LwM2M_eventName_ExecuteFWUpdate</a></td><td class=SDescription>Charstring constant for the LWM2M ExecuteFWUpdate request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Delete" id=link46 onMouseOver="ShowTip(event, 'tt39', 'link46')" onMouseOut="HideTip('tt39')">c_LwM2M_eventIdx_BS_Delete</a></td><td class=SDescription>Integer constant for the LWM2M BS_Delete request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Delete" id=link47 onMouseOver="ShowTip(event, 'tt40', 'link47')" onMouseOut="HideTip('tt40')">c_LwM2M_eventName_BS_Delete</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Delete request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Finish" id=link48 onMouseOver="ShowTip(event, 'tt41', 'link48')" onMouseOut="HideTip('tt41')">c_LwM2M_eventIdx_BS_Finish</a></td><td class=SDescription>Integer constant for the LWM2M BS_Finish request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Finish" id=link49 onMouseOver="ShowTip(event, 'tt42', 'link49')" onMouseOut="HideTip('tt42')">c_LwM2M_eventName_BS_Finish</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Finish request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Discover" id=link50 onMouseOver="ShowTip(event, 'tt43', 'link50')" onMouseOut="HideTip('tt43')">c_LwM2M_eventIdx_BS_Discover</a></td><td class=SDescription>Integer constant for the LWM2M BS_Discover request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Discover" id=link51 onMouseOver="ShowTip(event, 'tt44', 'link51')" onMouseOut="HideTip('tt44')">c_LwM2M_eventName_BS_Discover</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Discover request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_1xx" id=link52 onMouseOver="ShowTip(event, 'tt45', 'link52')" onMouseOut="HideTip('tt45')">c_LwM2M_eventIdx_1xx</a></td><td class=SDescription>Integer constant for the LWM2M 1xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_1xx" id=link53 onMouseOver="ShowTip(event, 'tt46', 'link53')" onMouseOut="HideTip('tt46')">c_LwM2M_eventName_1xx</a></td><td class=SDescription>Charstring constant for the LWM2M 1xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_2xx" id=link54 onMouseOver="ShowTip(event, 'tt47', 'link54')" onMouseOut="HideTip('tt47')">c_LwM2M_eventIdx_2xx</a></td><td class=SDescription>Integer constant for the LWM2M 2xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_2xx" id=link55 onMouseOver="ShowTip(event, 'tt48', 'link55')" onMouseOut="HideTip('tt48')">c_LwM2M_eventName_2xx</a></td><td class=SDescription>Charstring constant for the LWM2M 2xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_3xx" id=link56 onMouseOver="ShowTip(event, 'tt49', 'link56')" onMouseOut="HideTip('tt49')">c_LwM2M_eventIdx_3xx</a></td><td class=SDescription>Integer constant for the LWM2M 3xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_3xx" id=link57 onMouseOver="ShowTip(event, 'tt50', 'link57')" onMouseOut="HideTip('tt50')">c_LwM2M_eventName_3xx</a></td><td class=SDescription>Charstring constant for the LWM2M 3xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_4xx" id=link58 onMouseOver="ShowTip(event, 'tt51', 'link58')" onMouseOut="HideTip('tt51')">c_LwM2M_eventIdx_4xx</a></td><td class=SDescription>Integer constant for the LWM2M 4xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_4xx" id=link59 onMouseOver="ShowTip(event, 'tt52', 'link59')" onMouseOut="HideTip('tt52')">c_LwM2M_eventName_4xx</a></td><td class=SDescription>Charstring constant for the LWM2M 4xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_5xx" id=link60 onMouseOver="ShowTip(event, 'tt53', 'link60')" onMouseOut="HideTip('tt53')">c_LwM2M_eventIdx_5xx</a></td><td class=SDescription>Integer constant for the LWM2M 5xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_5xx" id=link61 onMouseOver="ShowTip(event, 'tt54', 'link61')" onMouseOut="HideTip('tt54')">c_LwM2M_eventName_5xx</a></td><td class=SDescription>Charstring constant for the LWM2M 5xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_6xx" id=link62 onMouseOver="ShowTip(event, 'tt55', 'link62')" onMouseOut="HideTip('tt55')">c_LwM2M_eventIdx_6xx</a></td><td class=SDescription>Integer constant for the LWM2M 6xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_6xx" id=link63 onMouseOver="ShowTip(event, 'tt56', 'link63')" onMouseOut="HideTip('tt56')">c_LwM2M_eventName_6xx</a></td><td class=SDescription>Charstring constant for the LWM2M 6xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_3xxto6xx" id=link64 onMouseOver="ShowTip(event, 'tt57', 'link64')" onMouseOut="HideTip('tt57')">c_LwM2M_eventIdx_3xxto6xx</a></td><td class=SDescription>Integer constant for the LWM2M 6xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_3xxto6xx" id=link65 onMouseOver="ShowTip(event, 'tt58', 'link65')" onMouseOut="HideTip('tt58')">c_LwM2M_eventName_3xxto6xx</a></td><td class=SDescription>Charstring constant for the LWM2M 6xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link66 onMouseOver="ShowTip(event, 'tt59', 'link66')" onMouseOut="HideTip('tt59')">c_LwM2M_eventIdx_resourceNotObservedIndication</a></td><td class=SDescription>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_resourceNotObservedIndication" id=link67 onMouseOver="ShowTip(event, 'tt60', 'link67')" onMouseOut="HideTip('tt60')">c_LwM2M_eventName_resourceNotObservedIndication</a></td><td class=SDescription>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_atomicBlock1Finished" id=link68 onMouseOver="ShowTip(event, 'tt61', 'link68')" onMouseOut="HideTip('tt61')">c_LwM2M_eventIdx_atomicBlock1Finished</a></td><td class=SDescription>Integer constant for indicating that a block1 transfer was finished</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_atomicBlock1Finished" id=link69 onMouseOver="ShowTip(event, 'tt62', 'link69')" onMouseOut="HideTip('tt62')">c_LwM2M_eventName_atomicBlock1Finished</a></td><td class=SDescription>Charstring constant for indicating that a block1 transfer was finished</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link70 onMouseOver="ShowTip(event, 'tt63', 'link70')" onMouseOut="HideTip('tt63')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td><td class=SDescription>Integer constant for the LWM2M loadTemplate (param: integer index) test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link71 onMouseOver="ShowTip(event, 'tt64', 'link71')" onMouseOut="HideTip('tt64')">c_LwM2M_stepName_loadTemplate_byIntIdx</a></td><td class=SDescription>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_send" id=link72 onMouseOver="ShowTip(event, 'tt65', 'link72')" onMouseOut="HideTip('tt65')">c_LwM2M_stepIdx_send</a></td><td class=SDescription>Integer constant for the LWM2M send test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_send" id=link73 onMouseOver="ShowTip(event, 'tt66', 'link73')" onMouseOut="HideTip('tt66')">c_LwM2M_stepName_send</a></td><td class=SDescription>Charstring constant for the LWM2M send test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createDevice" id=link74 onMouseOver="ShowTip(event, 'tt67', 'link74')" onMouseOut="HideTip('tt67')">c_LwM2M_stepIdx_createDevice</a></td><td class=SDescription>Integer constant for the LWM2M create device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createDevice" id=link75 onMouseOver="ShowTip(event, 'tt68', 'link75')" onMouseOut="HideTip('tt68')">c_LwM2M_stepName_createDevice</a></td><td class=SDescription>Charstring constant for the LWM2M create device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_cleanupDevice" id=link76 onMouseOver="ShowTip(event, 'tt69', 'link76')" onMouseOut="HideTip('tt69')">c_LwM2M_stepIdx_cleanupDevice</a></td><td class=SDescription>Integer constant for the LWM2M clean up device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_cleanupDevice" id=link77 onMouseOver="ShowTip(event, 'tt70', 'link77')" onMouseOut="HideTip('tt70')">c_LwM2M_stepName_cleanupDevice</a></td><td class=SDescription>Charstring constant for the LWM2M clean up device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_logDevice" id=link78 onMouseOver="ShowTip(event, 'tt71', 'link78')" onMouseOut="HideTip('tt71')">c_LwM2M_stepIdx_logDevice</a></td><td class=SDescription>Integer constant for the LWM2M log device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_logDevice" id=link79 onMouseOver="ShowTip(event, 'tt72', 'link79')" onMouseOut="HideTip('tt72')">c_LwM2M_stepName_logDevice</a></td><td class=SDescription>Charstring constant for the LWM2M log device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createObject" id=link80 onMouseOver="ShowTip(event, 'tt73', 'link80')" onMouseOut="HideTip('tt73')">c_LwM2M_stepIdx_createObject</a></td><td class=SDescription>Integer constant for the LWM2M create object test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createObject" id=link81 onMouseOver="ShowTip(event, 'tt74', 'link81')" onMouseOut="HideTip('tt74')">c_LwM2M_stepName_createObject</a></td><td class=SDescription>Charstring constant for the LWM2M create object test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createObjectInstance" id=link82 onMouseOver="ShowTip(event, 'tt75', 'link82')" onMouseOut="HideTip('tt75')">c_LwM2M_stepIdx_createObjectInstance</a></td><td class=SDescription>Integer constant for the LWM2M create object instance test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createObjectInstance" id=link83 onMouseOver="ShowTip(event, 'tt76', 'link83')" onMouseOut="HideTip('tt76')">c_LwM2M_stepName_createObjectInstance</a></td><td class=SDescription>Charstring constant for the LWM2M create object instance test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleReadRequest" id=link84 onMouseOver="ShowTip(event, 'tt77', 'link84')" onMouseOut="HideTip('tt77')">c_LwM2M_stepIdx_handleReadRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle READ request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleReadRequest" id=link85 onMouseOver="ShowTip(event, 'tt78', 'link85')" onMouseOut="HideTip('tt78')">c_LwM2M_stepName_handleReadRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle READ request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleWriteRequest" id=link86 onMouseOver="ShowTip(event, 'tt79', 'link86')" onMouseOut="HideTip('tt79')">c_LwM2M_stepIdx_handleWriteRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle WRITE request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleWriteRequest" id=link87 onMouseOver="ShowTip(event, 'tt80', 'link87')" onMouseOut="HideTip('tt80')">c_LwM2M_stepName_handleWriteRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle WRITE request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleExecuteRequest" id=link88 onMouseOver="ShowTip(event, 'tt81', 'link88')" onMouseOut="HideTip('tt81')">c_LwM2M_stepIdx_handleExecuteRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle EXECUTE request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleExecuteRequest" id=link89 onMouseOver="ShowTip(event, 'tt82', 'link89')" onMouseOut="HideTip('tt82')">c_LwM2M_stepName_handleExecuteRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle EXECUTE request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link90 onMouseOver="ShowTip(event, 'tt83', 'link90')" onMouseOut="HideTip('tt83')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></td><td class=SDescription>Integer constant for the LWM2M load template (param: string id of the template) test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_loadTemplate_byStringId" id=link91 onMouseOver="ShowTip(event, 'tt84', 'link91')" onMouseOut="HideTip('tt84')">c_LwM2M_stepName_loadTemplate_byStringId</a></td><td class=SDescription>Charstring constant for the LWM2M load template (param: string id of the template) test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link92 onMouseOver="ShowTip(event, 'tt85', 'link92')" onMouseOut="HideTip('tt85')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td><td class=SDescription>Integer constant for the LWM2M send notification for observed resources test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" id=link93 onMouseOver="ShowTip(event, 'tt86', 'link93')" onMouseOut="HideTip('tt86')">c_LwM2M_stepName_sendNotificationForObservedResources</a></td><td class=SDescription>Charstring constant for the LWM2M send notification for observed resources test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" >c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Integer constant for the LWM2M set firmware update state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" id=link94 onMouseOver="ShowTip(event, 'tt87', 'link94')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Charstring constant for the LWM2M set firmware update state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link95 onMouseOver="ShowTip(event, 'tt88', 'link95')" onMouseOut="HideTip('tt88')">c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td><td class=SDescription>Integer constant for the LWM2M set firmware update result test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" >c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Charstring constant for the LWM2M set furmware update result test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBootstrapState" id=link96 onMouseOver="ShowTip(event, 'tt89', 'link96')" onMouseOut="HideTip('tt89')">c_LwM2M_stepIdx_setBootstrapState</a></td><td class=SDescription>Integer constant for the  LWM2M set bootstrap state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBootstrapState" id=link97 onMouseOver="ShowTip(event, 'tt90', 'link97')" onMouseOut="HideTip('tt90')">c_LwM2M_stepName_setBootstrapState</a></td><td class=SDescription>Charstring constant for the LWM2M set bootstrap state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setNotRegisteredState" id=link98 onMouseOver="ShowTip(event, 'tt91', 'link98')" onMouseOut="HideTip('tt91')">c_LwM2M_stepIdx_setNotRegisteredState</a></td><td class=SDescription>Integer constant for the  LWM2M set not registered state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBootstrapState" >c_LwM2M_stepName_setBootstrapState</a></td><td class=SDescription>Charstring constant for the LWM2M set not registered state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link99 onMouseOver="ShowTip(event, 'tt92', 'link99')" onMouseOut="HideTip('tt92')">c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td><td class=SDescription>Integer constant for the  LWM2M set block1 handling stateless test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBlock1Handling_stateless" id=link100 onMouseOver="ShowTip(event, 'tt93', 'link100')" onMouseOut="HideTip('tt93')">c_LwM2M_stepName_setBlock1Handling_stateless</a></td><td class=SDescription>Charstring constant for the LWM2M set block1 handling stateless test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link101 onMouseOver="ShowTip(event, 'tt94', 'link101')" onMouseOut="HideTip('tt94')">c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td><td class=SDescription>Integer constant for the  LWM2M set block1 handling atomic test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBlock1Handling_atomic" id=link102 onMouseOver="ShowTip(event, 'tt95', 'link102')" onMouseOut="HideTip('tt95')">c_LwM2M_stepName_setBlock1Handling_atomic</a></td><td class=SDescription>Charstring constant for the LWM2M set block1 handling atomic test step</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_LGen_Definitions"></a>EPTF_LwM2M_LGen_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the definitions for the LWM2M load generator component</p><h4 class=CHeading>Module depends on</h4><ul><li><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=LFile id=link106 onMouseOver="ShowTip(event, 'tt99', 'link106')" onMouseOut="HideTip('tt99')">EPTF_LwM2M_Object_Definitions</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=LFile id=link107 onMouseOver="ShowTip(event, 'tt100', 'link107')" onMouseOut="HideTip('tt100')">EPTF_LwM2M_Transport_Definitions</a></li><li>&lt;EPTF_CLL_LGenBase_Definitions&gt;</li><li>&lt;EPTF_CLL_Logging_Definitions&gt;</li><li>&lt;EPTF_CLL_FBQ_Definitions&gt;</li><li><a href="LightweightM2M_Types-ttcn.html#LightweightM2M_Types" class=LFile id=link108 onMouseOver="ShowTip(event, 'tt101', 'link108')" onMouseOut="HideTip('tt101')">LightweightM2M_Types</a></li></ul><h4 class=CHeading>Module Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_log_error</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_log_error" class=LModuleParameter id=link109 onMouseOver="ShowTip(event, 'tt102', 'link109')" onMouseOut="HideTip('tt102')">tsp_EPTF_LwM2M_LGen_log_error</a> - <b>boolean</b> - Enabled/disable error logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_log_warning</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_log_warning" class=LModuleParameter id=link110 onMouseOver="ShowTip(event, 'tt103', 'link110')" onMouseOut="HideTip('tt103')">tsp_EPTF_LwM2M_LGen_log_warning</a> - <b>boolean</b> - Enabled/disable warning logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_debug</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_debug" class=LModuleParameter id=link111 onMouseOver="ShowTip(event, 'tt104', 'link111')" onMouseOut="HideTip('tt104')">tsp_EPTF_LwM2M_LGen_debug</a> - <b>boolean</b> - Enabled/disable debug logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_debugVerbose</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_debugVerbose" class=LModuleParameter id=link112 onMouseOver="ShowTip(event, 'tt105', 'link112')" onMouseOut="HideTip('tt105')">tsp_EPTF_LwM2M_LGen_debugVerbose</a> - <b>boolean</b> - Enabled/disable verbose debug logging</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_templates</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link113 onMouseOver="ShowTip(event, 'tt106', 'link113')" onMouseOut="HideTip('tt106')">tsp_EPTF_LwM2M_LGen_templates</a> - <a href="#LwM2M_Template_List" class=LType id=link114 onMouseOver="ShowTip(event, 'tt10', 'link114')" onMouseOut="HideTip('tt10')">LwM2M_Template_List</a> - LWM2M template definitions for sending</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_objectSpecifications</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=LModuleParameter id=link115 onMouseOver="ShowTip(event, 'tt107', 'link115')" onMouseOut="HideTip('tt107')">tsp_EPTF_LwM2M_LGen_objectSpecifications</a> - <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=LType id=link116 onMouseOver="ShowTip(event, 'tt108', 'link116')" onMouseOut="HideTip('tt108')">LwM2M_ObjectSpecification_List</a> - Additional smart object specifications to be loaded</td></tr><tr><td class=CDLEntry>tsp_EPTF_LwM2M_LGen_defaultContentFormat</td><td class=CDLDescription><a href="#tsp_EPTF_LwM2M_LGen_defaultContentFormat" class=LModuleParameter id=link117 onMouseOver="ShowTip(event, 'tt109', 'link117')" onMouseOut="HideTip('tt109')">tsp_EPTF_LwM2M_LGen_defaultContentFormat</a> - <b>integer</b> - default LwM@M payload content format</td></tr></table><h4 class=CHeading>Events</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>LWM2M Register request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Register" class=LConstant id=link118 onMouseOver="ShowTip(event, 'tt16', 'link118')" onMouseOut="HideTip('tt16')">c_LwM2M_eventIdx_Register</a>, <a href="#c_LwM2M_eventName_Register" class=LConstant id=link119 onMouseOver="ShowTip(event, 'tt17', 'link119')" onMouseOut="HideTip('tt17')">c_LwM2M_eventName_Register</a></td></tr><tr><td class=CDLEntry>LWM2M Update request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Update" class=LConstant id=link120 onMouseOver="ShowTip(event, 'tt18', 'link120')" onMouseOut="HideTip('tt18')">c_LwM2M_eventIdx_Update</a>, <a href="#c_LwM2M_eventName_Update" class=LConstant id=link121 onMouseOver="ShowTip(event, 'tt19', 'link121')" onMouseOut="HideTip('tt19')">c_LwM2M_eventName_Update</a></td></tr><tr><td class=CDLEntry>LWM2M Deregister request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Deregister" class=LConstant id=link122 onMouseOver="ShowTip(event, 'tt20', 'link122')" onMouseOut="HideTip('tt20')">c_LwM2M_eventIdx_Deregister</a>, <a href="#c_LwM2M_eventName_Deregister" class=LConstant id=link123 onMouseOver="ShowTip(event, 'tt21', 'link123')" onMouseOut="HideTip('tt21')">c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=CDLEntry>LWM2M Read request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Read" class=LConstant id=link124 onMouseOver="ShowTip(event, 'tt22', 'link124')" onMouseOut="HideTip('tt22')">c_LwM2M_eventIdx_Read</a>, <a href="#c_LwM2M_eventName_Read" class=LConstant id=link125 onMouseOver="ShowTip(event, 'tt23', 'link125')" onMouseOut="HideTip('tt23')">c_LwM2M_eventName_Read</a></td></tr><tr><td class=CDLEntry>LWM2M Write request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Write" class=LConstant id=link126 onMouseOver="ShowTip(event, 'tt24', 'link126')" onMouseOut="HideTip('tt24')">c_LwM2M_eventIdx_Write</a>, <a href="#c_LwM2M_eventName_Write" class=LConstant id=link127 onMouseOver="ShowTip(event, 'tt25', 'link127')" onMouseOut="HideTip('tt25')">c_LwM2M_eventName_Write</a></td></tr><tr><td class=CDLEntry>LWM2M Execute request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Execute" class=LConstant id=link128 onMouseOver="ShowTip(event, 'tt26', 'link128')" onMouseOut="HideTip('tt26')">c_LwM2M_eventIdx_Execute</a>, <a href="#c_LwM2M_eventName_Execute" class=LConstant id=link129 onMouseOver="ShowTip(event, 'tt27', 'link129')" onMouseOut="HideTip('tt27')">c_LwM2M_eventName_Execute</a></td></tr><tr><td class=CDLEntry>LWM2M Create request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Create" class=LConstant id=link130 onMouseOver="ShowTip(event, 'tt28', 'link130')" onMouseOut="HideTip('tt28')">c_LwM2M_eventIdx_Create</a>, <a href="#c_LwM2M_eventName_Create" class=LConstant id=link131 onMouseOver="ShowTip(event, 'tt29', 'link131')" onMouseOut="HideTip('tt29')">c_LwM2M_eventName_Create</a></td></tr><tr><td class=CDLEntry>LWM2M Delete request</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_Delete" class=LConstant id=link132 onMouseOver="ShowTip(event, 'tt30', 'link132')" onMouseOut="HideTip('tt30')">c_LwM2M_eventIdx_Delete</a>, <a href="#c_LwM2M_eventName_Delete" class=LConstant id=link133 onMouseOver="ShowTip(event, 'tt31', 'link133')" onMouseOut="HideTip('tt31')">c_LwM2M_eventName_Delete</a></td></tr><tr><td class=CDLEntry>LWM2M 1xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_1xx" class=LConstant id=link134 onMouseOver="ShowTip(event, 'tt46', 'link134')" onMouseOut="HideTip('tt46')">c_LwM2M_eventIdx_1xx</a>, <a href="#c_LwM2M_eventName_1xx" class=LConstant id=link135 onMouseOver="ShowTip(event, 'tt47', 'link135')" onMouseOut="HideTip('tt47')">c_LwM2M_eventName_1xx</a></td></tr><tr><td class=CDLEntry>LWM2M 2xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_2xx" class=LConstant id=link136 onMouseOver="ShowTip(event, 'tt48', 'link136')" onMouseOut="HideTip('tt48')">c_LwM2M_eventIdx_2xx</a>, <a href="#c_LwM2M_eventName_2xx" class=LConstant id=link137 onMouseOver="ShowTip(event, 'tt49', 'link137')" onMouseOut="HideTip('tt49')">c_LwM2M_eventName_2xx</a></td></tr><tr><td class=CDLEntry>LWM2M 3xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_3xx" class=LConstant id=link138 onMouseOver="ShowTip(event, 'tt50', 'link138')" onMouseOut="HideTip('tt50')">c_LwM2M_eventIdx_3xx</a>, <a href="#c_LwM2M_eventName_3xx" class=LConstant id=link139 onMouseOver="ShowTip(event, 'tt51', 'link139')" onMouseOut="HideTip('tt51')">c_LwM2M_eventName_3xx</a></td></tr><tr><td class=CDLEntry>LWM2M 4xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_4xx" class=LConstant id=link140 onMouseOver="ShowTip(event, 'tt52', 'link140')" onMouseOut="HideTip('tt52')">c_LwM2M_eventIdx_4xx</a>, <a href="#c_LwM2M_eventName_4xx" class=LConstant id=link141 onMouseOver="ShowTip(event, 'tt53', 'link141')" onMouseOut="HideTip('tt53')">c_LwM2M_eventName_4xx</a></td></tr><tr><td class=CDLEntry>LWM2M 5xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_5xx" class=LConstant id=link142 onMouseOver="ShowTip(event, 'tt54', 'link142')" onMouseOut="HideTip('tt54')">c_LwM2M_eventIdx_5xx</a>, <a href="#c_LwM2M_eventName_5xx" class=LConstant id=link143 onMouseOver="ShowTip(event, 'tt55', 'link143')" onMouseOut="HideTip('tt55')">c_LwM2M_eventName_5xx</a></td></tr><tr><td class=CDLEntry>LWM2M 6xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_6xx" class=LConstant id=link144 onMouseOver="ShowTip(event, 'tt56', 'link144')" onMouseOut="HideTip('tt56')">c_LwM2M_eventIdx_6xx</a>, <a href="#c_LwM2M_eventName_6xx" class=LConstant id=link145 onMouseOver="ShowTip(event, 'tt57', 'link145')" onMouseOut="HideTip('tt57')">c_LwM2M_eventName_6xx</a></td></tr><tr><td class=CDLEntry>LWM2M 3xxto6xx response</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_3xxto6xx" class=LConstant id=link146 onMouseOver="ShowTip(event, 'tt58', 'link146')" onMouseOut="HideTip('tt58')">c_LwM2M_eventIdx_3xxto6xx</a>, <a href="#c_LwM2M_eventName_3xxto6xx" class=LConstant id=link147 onMouseOver="ShowTip(event, 'tt59', 'link147')" onMouseOut="HideTip('tt59')">c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=CDLEntry>LWM2M resource not observed any more indication</td><td class=CDLDescription><a href="#c_LwM2M_eventIdx_resourceNotObservedIndication" class=LConstant id=link148 onMouseOver="ShowTip(event, 'tt60', 'link148')" onMouseOut="HideTip('tt60')">c_LwM2M_eventIdx_resourceNotObservedIndication</a>, <a href="#c_LwM2M_eventName_resourceNotObservedIndication" class=LConstant id=link149 onMouseOver="ShowTip(event, 'tt61', 'link149')" onMouseOut="HideTip('tt61')">c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr></table><h4 class=CHeading>TestSteps</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>LWM2M load template</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link150 onMouseOver="ShowTip(event, 'tt110', 'link150')" onMouseOut="HideTip('tt110')">f_LwM2M_step_loadTemplate_byIntIdx</a>, <a href="#c_LwM2M_stepName_loadTemplate_byIntIdx" class=LConstant id=link151 onMouseOver="ShowTip(event, 'tt65', 'link151')" onMouseOut="HideTip('tt65')">c_LwM2M_stepName_loadTemplate_byIntIdx</a>, <a href="#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=LConstant id=link152 onMouseOver="ShowTip(event, 'tt64', 'link152')" onMouseOut="HideTip('tt64')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a> <a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link153 onMouseOver="ShowTip(event, 'tt111', 'link153')" onMouseOut="HideTip('tt111')">f_LwM2M_step_loadTemplate_byStringId</a>, <a href="#c_LwM2M_stepName_send" class=LConstant id=link154 onMouseOver="ShowTip(event, 'tt67', 'link154')" onMouseOut="HideTip('tt67')">c_LwM2M_stepName_send</a>, <a href="#c_LwM2M_stepIdx_loadTemplate_byStringId" class=LConstant id=link155 onMouseOver="ShowTip(event, 'tt84', 'link155')" onMouseOut="HideTip('tt84')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=CDLEntry>LWM2M send</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link156 onMouseOver="ShowTip(event, 'tt112', 'link156')" onMouseOut="HideTip('tt112')">f_LwM2M_step_send</a>, <a href="#c_LwM2M_stepName_send" class=LConstant id=link157 onMouseOver="ShowTip(event, 'tt67', 'link157')" onMouseOut="HideTip('tt67')">c_LwM2M_stepName_send</a>, <a href="#c_LwM2M_stepIdx_send" class=LConstant id=link158 onMouseOver="ShowTip(event, 'tt66', 'link158')" onMouseOut="HideTip('tt66')">c_LwM2M_stepIdx_send</a></td></tr><tr><td class=CDLEntry>LWM2M create device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link159 onMouseOver="ShowTip(event, 'tt113', 'link159')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createDevice</a>, <a href="#c_LwM2M_stepName_createDevice" class=LConstant id=link160 onMouseOver="ShowTip(event, 'tt69', 'link160')" onMouseOut="HideTip('tt69')">c_LwM2M_stepName_createDevice</a>, <a href="#c_LwM2M_stepIdx_createDevice" class=LConstant id=link161 onMouseOver="ShowTip(event, 'tt68', 'link161')" onMouseOut="HideTip('tt68')">c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=CDLEntry>LWM2M clean up device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link162 onMouseOver="ShowTip(event, 'tt114', 'link162')" onMouseOut="HideTip('tt114')">f_LwM2M_step_cleanupDevice</a>, <a href="#c_LwM2M_stepName_cleanupDevice" class=LConstant id=link163 onMouseOver="ShowTip(event, 'tt71', 'link163')" onMouseOut="HideTip('tt71')">c_LwM2M_stepName_cleanupDevice</a>, <a href="#c_LwM2M_stepIdx_cleanupDevice" class=LConstant id=link164 onMouseOver="ShowTip(event, 'tt70', 'link164')" onMouseOut="HideTip('tt70')">c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=CDLEntry>LWM2M log device</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link165 onMouseOver="ShowTip(event, 'tt115', 'link165')" onMouseOut="HideTip('tt115')">f_LwM2M_step_logDevice</a>, <a href="#c_LwM2M_stepName_logDevice" class=LConstant id=link166 onMouseOver="ShowTip(event, 'tt73', 'link166')" onMouseOut="HideTip('tt73')">c_LwM2M_stepName_logDevice</a>, <a href="#c_LwM2M_stepIdx_logDevice" class=LConstant id=link167 onMouseOver="ShowTip(event, 'tt72', 'link167')" onMouseOut="HideTip('tt72')">c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=CDLEntry>LWM2M create object</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link168 onMouseOver="ShowTip(event, 'tt116', 'link168')" onMouseOut="HideTip('tt116')">f_LwM2M_step_createObject</a>, <a href="#c_LwM2M_stepName_createObject" class=LConstant id=link169 onMouseOver="ShowTip(event, 'tt75', 'link169')" onMouseOut="HideTip('tt75')">c_LwM2M_stepName_createObject</a>, <a href="#c_LwM2M_stepIdx_createObject" class=LConstant id=link170 onMouseOver="ShowTip(event, 'tt74', 'link170')" onMouseOut="HideTip('tt74')">c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=CDLEntry>LWM2M create object instance</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link171 onMouseOver="ShowTip(event, 'tt117', 'link171')" onMouseOut="HideTip('tt117')">f_LwM2M_step_createObjectInstance</a>, <a href="#c_LwM2M_stepName_createObjectInstance" class=LConstant id=link172 onMouseOver="ShowTip(event, 'tt77', 'link172')" onMouseOut="HideTip('tt77')">c_LwM2M_stepName_createObjectInstance</a>, <a href="#c_LwM2M_stepIdx_createObjectInstance" class=LConstant id=link173 onMouseOver="ShowTip(event, 'tt76', 'link173')" onMouseOut="HideTip('tt76')">c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=CDLEntry>LWM2M handle READ request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link174 onMouseOver="ShowTip(event, 'tt118', 'link174')" onMouseOut="HideTip('tt118')">f_LwM2M_step_handleReadRequest</a>, <a href="#c_LwM2M_stepName_handleReadRequest" class=LConstant id=link175 onMouseOver="ShowTip(event, 'tt79', 'link175')" onMouseOut="HideTip('tt79')">c_LwM2M_stepName_handleReadRequest</a>, <a href="#c_LwM2M_stepIdx_handleReadRequest" class=LConstant id=link176 onMouseOver="ShowTip(event, 'tt78', 'link176')" onMouseOut="HideTip('tt78')">c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=CDLEntry>LWM2M handle WRITE request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link177 onMouseOver="ShowTip(event, 'tt119', 'link177')" onMouseOut="HideTip('tt119')">f_LwM2M_step_handleWriteRequest</a>, <a href="#c_LwM2M_stepName_handleWriteRequest" class=LConstant id=link178 onMouseOver="ShowTip(event, 'tt81', 'link178')" onMouseOut="HideTip('tt81')">c_LwM2M_stepName_handleWriteRequest</a>, <a href="#c_LwM2M_stepIdx_handleWriteRequest" class=LConstant id=link179 onMouseOver="ShowTip(event, 'tt80', 'link179')" onMouseOut="HideTip('tt80')">c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=CDLEntry>LWM2M handle EXECUTE request</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link180 onMouseOver="ShowTip(event, 'tt120', 'link180')" onMouseOut="HideTip('tt120')">f_LwM2M_step_handleExecuteRequest</a>, <a href="#c_LwM2M_stepName_handleExecuteRequest" class=LConstant id=link181 onMouseOver="ShowTip(event, 'tt83', 'link181')" onMouseOut="HideTip('tt83')">c_LwM2M_stepName_handleExecuteRequest</a>, <a href="#c_LwM2M_stepIdx_handleExecuteRequest" class=LConstant id=link182 onMouseOver="ShowTip(event, 'tt82', 'link182')" onMouseOut="HideTip('tt82')">c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=CDLEntry>LWM2M send NOTIFICATION</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=LFunction id=link183 onMouseOver="ShowTip(event, 'tt121', 'link183')" onMouseOut="HideTip('tt121')">f_LwM2M_step_sendNotificationForObservedResources</a>, <a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link184 onMouseOver="ShowTip(event, 'tt87', 'link184')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_sendNotificationForObservedResources</a>, <a href="#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=LConstant id=link185 onMouseOver="ShowTip(event, 'tt86', 'link185')" onMouseOut="HideTip('tt86')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr><tr><td class=CDLEntry>LWM2M set firmware update state</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" class=LFunction id=link186 onMouseOver="ShowTip(event, 'tt122', 'link186')" onMouseOut="HideTip('tt122')">f_LwM2M_step_setFirmwareUpdateState</a>, <a href="#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link187 onMouseOver="ShowTip(event, 'tt88', 'link187')" onMouseOut="HideTip('tt88')">c_LwM2M_stepName_setFirmwareUpdateState</a>, &lt;c_LwM2M_stepIdx_setFirmwareUpdateState&gt;</td></tr><tr><td class=CDLEntry>LWM2M set firmware update results</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" class=LFunction id=link188 onMouseOver="ShowTip(event, 'tt123', 'link188')" onMouseOut="HideTip('tt123')">f_LwM2M_step_setFirmwareUpdateResult</a>, &lt;c_LwM2M_stepName_setFirmwareUpdateResult&gt;, <a href="#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=LConstant id=link189 onMouseOver="ShowTip(event, 'tt89', 'link189')" onMouseOut="HideTip('tt89')">c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td></tr><tr><td class=CDLEntry>LWM2M set bootstrap state</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=LFunction id=link190 onMouseOver="ShowTip(event, 'tt124', 'link190')" onMouseOut="HideTip('tt124')">f_LwM2M_step_setBootstrapState</a>, <a href="#c_LwM2M_stepName_setBootstrapState" class=LConstant id=link191 onMouseOver="ShowTip(event, 'tt91', 'link191')" onMouseOut="HideTip('tt91')">c_LwM2M_stepName_setBootstrapState</a>, <a href="#c_LwM2M_stepIdx_setBootstrapState" class=LConstant id=link192 onMouseOver="ShowTip(event, 'tt90', 'link192')" onMouseOut="HideTip('tt90')">c_LwM2M_stepIdx_setBootstrapState</a></td></tr><tr><td class=CDLEntry>LWM2M set not_registered state</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=LFunction id=link193 onMouseOver="ShowTip(event, 'tt125', 'link193')" onMouseOut="HideTip('tt125')">f_LwM2M_step_setNotRegisteredState</a>, &lt;c_LwM2M_stepName_setNotRegisteredState&gt;, <a href="#c_LwM2M_stepIdx_setNotRegisteredState" class=LConstant id=link194 onMouseOver="ShowTip(event, 'tt92', 'link194')" onMouseOut="HideTip('tt92')">c_LwM2M_stepIdx_setNotRegisteredState</a></td></tr><tr><td class=CDLEntry>LWM2M set block1 handling stateless</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=LFunction id=link195 onMouseOver="ShowTip(event, 'tt126', 'link195')" onMouseOut="HideTip('tt126')">f_LwM2M_step_setBlock1Handling_stateless</a>, <a href="#c_LwM2M_stepName_setBlock1Handling_stateless" class=LConstant id=link196 onMouseOver="ShowTip(event, 'tt94', 'link196')" onMouseOut="HideTip('tt94')">c_LwM2M_stepName_setBlock1Handling_stateless</a>, <a href="#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=LConstant id=link197 onMouseOver="ShowTip(event, 'tt93', 'link197')" onMouseOut="HideTip('tt93')">c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td></tr><tr><td class=CDLEntry>LWM2M set block1 handling atomic</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=LFunction id=link198 onMouseOver="ShowTip(event, 'tt127', 'link198')" onMouseOut="HideTip('tt127')">f_LwM2M_step_setBlock1Handling_atomic</a>, <a href="#c_LwM2M_stepName_setBlock1Handling_atomic" class=LConstant id=link199 onMouseOver="ShowTip(event, 'tt96', 'link199')" onMouseOut="HideTip('tt96')">c_LwM2M_stepName_setBlock1Handling_atomic</a>, <a href="#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=LConstant id=link200 onMouseOver="ShowTip(event, 'tt95', 'link200')" onMouseOut="HideTip('tt95')">c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td></tr><tr><td class=CDLEntry>LWM2M set content formats</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" class=LFunction id=link201 onMouseOver="ShowTip(event, 'tt128', 'link201')" onMouseOut="HideTip('tt128')">f_LwM2M_step_setContentFormats</a>, <a href="#c_LwM2M_stepName_setContentFormats" class=LConstant id=link202 onMouseOver="ShowTip(event, 'tt98', 'link202')" onMouseOut="HideTip('tt98')">c_LwM2M_stepName_setContentFormats</a>, <a href="#c_LwM2M_stepIdx_setContentFormats" class=LConstant id=link203 onMouseOver="ShowTip(event, 'tt97', 'link203')" onMouseOut="HideTip('tt97')">c_LwM2M_stepIdx_setContentFormats</a></td></tr></table><h4 class=CHeading>Class Diagram</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.classes.jpg"><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Definitions" >EPTF_LwM2M_LGen_Definitions</a></td><td class=SDescription>This module contains the definitions for the LWM2M load generator component</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_log_error" >tsp_EPTF_LwM2M_LGen_log_error</a></td><td class=SDescription>Enabled/disable error logging</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_log_warning" >tsp_EPTF_LwM2M_LGen_log_warning</a></td><td class=SDescription>Enabled/disable warning logging</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_debug" >tsp_EPTF_LwM2M_LGen_debug</a></td><td class=SDescription>Enabled/disable debug logging</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_debugVerbose" >tsp_EPTF_LwM2M_LGen_debugVerbose</a></td><td class=SDescription>Enabled/disable verbose debug logging</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_templates" >tsp_EPTF_LwM2M_LGen_templates</a></td><td class=SDescription>List of LWM2M messages for sending</td></tr><tr class="SModuleParameter"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_objectSpecifications" >tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td><td class=SDescription>List of smart object specifications (needed for creating smart object instances)</td></tr><tr class="SModuleParameter SMarked"><td class=SEntry><a href="#tsp_EPTF_LwM2M_LGen_defaultContentFormat" >tsp_EPTF_LwM2M_LGen_defaultContentFormat</a></td><td class=SDescription>Setting the default content format code for encoding LwM2M payload</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">c_LwM2M_behaviorType</a></td><td class=SDescription>Constant for LWM2M behaviour name</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_EntityCtx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td><td class=SDescription>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_EntityCtx_List" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">LwM2M_EntityCtx_List</a></td><td class=SDescription>List of <a href="#LwM2M_EntityCtx" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_EntityCtx_DB" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">LwM2M_EntityCtx_DB</a></td><td class=SDescription>Storing LWM2M entity contexts</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Device" id=link6 onMouseOver="ShowTip(event, 'tt5', 'link6')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></td><td class=SDescription>Storing the state and smart object of a simulated LWM2M device</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Format_List" id=link7 onMouseOver="ShowTip(event, 'tt6', 'link7')" onMouseOut="HideTip('tt6')">LwM2M_Format_List</a></td><td class=SDescription>List of <b>integer</b></td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_Device_State" >LwM2M_Device_State</a></td><td class=SDescription>States of a <a href="#LwM2M_Device" class=LType id=link8 onMouseOver="ShowTip(event, 'tt5', 'link8')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</td></tr><tr class="SEnumeration SMarked"><td class=SEntry><a href="#LwM2M_Block1_Handling" >LwM2M_Block1_Handling</a></td><td class=SDescription>Block1 handling strategy of a <a href="#LwM2M_Device" class=LType id=link9 onMouseOver="ShowTip(event, 'tt5', 'link9')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Device_List" id=link10 onMouseOver="ShowTip(event, 'tt7', 'link10')" onMouseOut="HideTip('tt7')">LwM2M_Device_List</a></td><td class=SDescription>List of <a href="#LwM2M_Device" class=LType id=link11 onMouseOver="ShowTip(event, 'tt5', 'link11')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Device_DB" id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">LwM2M_Device_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_Device" class=LType id=link13 onMouseOver="ShowTip(event, 'tt5', 'link13')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Template" id=link14 onMouseOver="ShowTip(event, 'tt9', 'link14')" onMouseOut="HideTip('tt9')">LwM2M_Template</a></td><td class=SDescription>Grouping a &lt;LWM2M_PDU&gt; with an id so that the message can be loaded from an FSM later by using the id</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Template_List" id=link15 onMouseOver="ShowTip(event, 'tt10', 'link15')" onMouseOut="HideTip('tt10')">LwM2M_Template_List</a></td><td class=SDescription>List of <a href="#LwM2M_Template" class=LType id=link16 onMouseOver="ShowTip(event, 'tt9', 'link16')" onMouseOut="HideTip('tt9')">LwM2M_Template</a></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Template_DB" id=link17 onMouseOver="ShowTip(event, 'tt11', 'link17')" onMouseOut="HideTip('tt11')">LwM2M_Template_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_Template" class=LType id=link18 onMouseOver="ShowTip(event, 'tt9', 'link18')" onMouseOut="HideTip('tt9')">LwM2M_Template</a> instances</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_StepCtx" id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a></td><td class=SDescription>Stores the most important pointers that are used from a test steps</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_LGen_CT" id=link20 onMouseOver="ShowTip(event, 'tt13', 'link20')" onMouseOut="HideTip('tt13')">EPTF_LwM2M_LGen_CT</a></td><td class=SDescription>LWM2M load generator component</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Statistics" id=link21 onMouseOver="ShowTip(event, 'tt14', 'link21')" onMouseOut="HideTip('tt14')">EPTF_LwM2M_LGen_Statistics</a></td><td class=SDescription>Storing counters for load generator related statistics</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_Message_Statistics" id=link22 onMouseOver="ShowTip(event, 'tt15', 'link22')" onMouseOut="HideTip('tt15')">EPTF_LwM2M_Message_Statistics</a></td><td class=SDescription>Storing counters for message related statistics</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Register" id=link23 onMouseOver="ShowTip(event, 'tt16', 'link23')" onMouseOut="HideTip('tt16')">c_LwM2M_eventIdx_Register</a></td><td class=SDescription>Integer constant for the LWM2M Register request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Register" id=link24 onMouseOver="ShowTip(event, 'tt17', 'link24')" onMouseOut="HideTip('tt17')">c_LwM2M_eventName_Register</a></td><td class=SDescription>Charstring constant for the LWM2M Register request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Update" id=link25 onMouseOver="ShowTip(event, 'tt18', 'link25')" onMouseOut="HideTip('tt18')">c_LwM2M_eventIdx_Update</a></td><td class=SDescription>Integer constant for the LWM2M Update request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Update" id=link26 onMouseOver="ShowTip(event, 'tt19', 'link26')" onMouseOut="HideTip('tt19')">c_LwM2M_eventName_Update</a></td><td class=SDescription>Charstring constant for the LWM2M Update request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Deregister" id=link27 onMouseOver="ShowTip(event, 'tt20', 'link27')" onMouseOut="HideTip('tt20')">c_LwM2M_eventIdx_Deregister</a></td><td class=SDescription>Integer constant for the LWM2M Deregister request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Deregister" id=link28 onMouseOver="ShowTip(event, 'tt21', 'link28')" onMouseOut="HideTip('tt21')">c_LwM2M_eventName_Deregister</a></td><td class=SDescription>Charstring constant for the LWM2M Deregister request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Read" id=link29 onMouseOver="ShowTip(event, 'tt22', 'link29')" onMouseOut="HideTip('tt22')">c_LwM2M_eventIdx_Read</a></td><td class=SDescription>Integer constant for the LWM2M Read request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Read" id=link30 onMouseOver="ShowTip(event, 'tt23', 'link30')" onMouseOut="HideTip('tt23')">c_LwM2M_eventName_Read</a></td><td class=SDescription>Charstring constant for the LWM2M Read request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Write" id=link31 onMouseOver="ShowTip(event, 'tt24', 'link31')" onMouseOut="HideTip('tt24')">c_LwM2M_eventIdx_Write</a></td><td class=SDescription>Integer constant for the LWM2M Write request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Write" id=link32 onMouseOver="ShowTip(event, 'tt25', 'link32')" onMouseOut="HideTip('tt25')">c_LwM2M_eventName_Write</a></td><td class=SDescription>Charstring constant for the LWM2M Write request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Execute" id=link33 onMouseOver="ShowTip(event, 'tt26', 'link33')" onMouseOut="HideTip('tt26')">c_LwM2M_eventIdx_Execute</a></td><td class=SDescription>Integer constant for the LWM2M Execute request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Execute" id=link34 onMouseOver="ShowTip(event, 'tt27', 'link34')" onMouseOut="HideTip('tt27')">c_LwM2M_eventName_Execute</a></td><td class=SDescription>Charstring constant for the LWM2M Execute request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Create" id=link35 onMouseOver="ShowTip(event, 'tt28', 'link35')" onMouseOut="HideTip('tt28')">c_LwM2M_eventIdx_Create</a></td><td class=SDescription>Integer constant for the LWM2M Create request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Create" id=link36 onMouseOver="ShowTip(event, 'tt29', 'link36')" onMouseOut="HideTip('tt29')">c_LwM2M_eventName_Create</a></td><td class=SDescription>Charstring constant for the LWM2M Create request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Delete" id=link37 onMouseOver="ShowTip(event, 'tt30', 'link37')" onMouseOut="HideTip('tt30')">c_LwM2M_eventIdx_Delete</a></td><td class=SDescription>Integer constant for the LWM2M Delete request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Delete" id=link38 onMouseOver="ShowTip(event, 'tt31', 'link38')" onMouseOut="HideTip('tt31')">c_LwM2M_eventName_Delete</a></td><td class=SDescription>Charstring constant for the LWM2M Delete request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_Observe" id=link39 onMouseOver="ShowTip(event, 'tt32', 'link39')" onMouseOut="HideTip('tt32')">c_LwM2M_eventIdx_Observe</a></td><td class=SDescription>Integer constant for the LWM2M Observe request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_Observe" id=link40 onMouseOver="ShowTip(event, 'tt33', 'link40')" onMouseOut="HideTip('tt33')">c_LwM2M_eventName_Observe</a></td><td class=SDescription>Charstring constant for the LWM2M Observe request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_WriteFWUri" id=link41 onMouseOver="ShowTip(event, 'tt34', 'link41')" onMouseOut="HideTip('tt34')">c_LwM2M_eventIdx_WriteFWUri</a></td><td class=SDescription>Integer constant for the LWM2M WriteFWUri request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_WriteFWUri" id=link42 onMouseOver="ShowTip(event, 'tt35', 'link42')" onMouseOut="HideTip('tt35')">c_LwM2M_eventName_WriteFWUri</a></td><td class=SDescription>Charstring constant for the LWM2M WriteFWUri request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_WriteFWPackage" id=link43 onMouseOver="ShowTip(event, 'tt36', 'link43')" onMouseOut="HideTip('tt36')">c_LwM2M_eventIdx_WriteFWPackage</a></td><td class=SDescription>Integer constant for the LWM2M WriteFWPackage request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_WriteFWPackage" id=link44 onMouseOver="ShowTip(event, 'tt37', 'link44')" onMouseOut="HideTip('tt37')">c_LwM2M_eventName_WriteFWPackage</a></td><td class=SDescription>Charstring constant for the LWM2M WriteFWPackage request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link45 onMouseOver="ShowTip(event, 'tt38', 'link45')" onMouseOut="HideTip('tt38')">c_LwM2M_eventIdx_ExecuteFWUpdate</a></td><td class=SDescription>Integer constant for the LWM2M ExecuteFWUpdate request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_ExecuteFWUpdate" id=link46 onMouseOver="ShowTip(event, 'tt39', 'link46')" onMouseOut="HideTip('tt39')">c_LwM2M_eventName_ExecuteFWUpdate</a></td><td class=SDescription>Charstring constant for the LWM2M ExecuteFWUpdate request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Delete" id=link47 onMouseOver="ShowTip(event, 'tt40', 'link47')" onMouseOut="HideTip('tt40')">c_LwM2M_eventIdx_BS_Delete</a></td><td class=SDescription>Integer constant for the LWM2M BS_Delete request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Delete" id=link48 onMouseOver="ShowTip(event, 'tt41', 'link48')" onMouseOut="HideTip('tt41')">c_LwM2M_eventName_BS_Delete</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Delete request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Finish" id=link49 onMouseOver="ShowTip(event, 'tt42', 'link49')" onMouseOut="HideTip('tt42')">c_LwM2M_eventIdx_BS_Finish</a></td><td class=SDescription>Integer constant for the LWM2M BS_Finish request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Finish" id=link50 onMouseOver="ShowTip(event, 'tt43', 'link50')" onMouseOut="HideTip('tt43')">c_LwM2M_eventName_BS_Finish</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Finish request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_BS_Discover" id=link51 onMouseOver="ShowTip(event, 'tt44', 'link51')" onMouseOut="HideTip('tt44')">c_LwM2M_eventIdx_BS_Discover</a></td><td class=SDescription>Integer constant for the LWM2M BS_Discover request event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_BS_Discover" id=link52 onMouseOver="ShowTip(event, 'tt45', 'link52')" onMouseOut="HideTip('tt45')">c_LwM2M_eventName_BS_Discover</a></td><td class=SDescription>Charstring constant for the LWM2M BS_Discover request event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_1xx" id=link53 onMouseOver="ShowTip(event, 'tt46', 'link53')" onMouseOut="HideTip('tt46')">c_LwM2M_eventIdx_1xx</a></td><td class=SDescription>Integer constant for the LWM2M 1xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_1xx" id=link54 onMouseOver="ShowTip(event, 'tt47', 'link54')" onMouseOut="HideTip('tt47')">c_LwM2M_eventName_1xx</a></td><td class=SDescription>Charstring constant for the LWM2M 1xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_2xx" id=link55 onMouseOver="ShowTip(event, 'tt48', 'link55')" onMouseOut="HideTip('tt48')">c_LwM2M_eventIdx_2xx</a></td><td class=SDescription>Integer constant for the LWM2M 2xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_2xx" id=link56 onMouseOver="ShowTip(event, 'tt49', 'link56')" onMouseOut="HideTip('tt49')">c_LwM2M_eventName_2xx</a></td><td class=SDescription>Charstring constant for the LWM2M 2xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_3xx" id=link57 onMouseOver="ShowTip(event, 'tt50', 'link57')" onMouseOut="HideTip('tt50')">c_LwM2M_eventIdx_3xx</a></td><td class=SDescription>Integer constant for the LWM2M 3xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_3xx" id=link58 onMouseOver="ShowTip(event, 'tt51', 'link58')" onMouseOut="HideTip('tt51')">c_LwM2M_eventName_3xx</a></td><td class=SDescription>Charstring constant for the LWM2M 3xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_4xx" id=link59 onMouseOver="ShowTip(event, 'tt52', 'link59')" onMouseOut="HideTip('tt52')">c_LwM2M_eventIdx_4xx</a></td><td class=SDescription>Integer constant for the LWM2M 4xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_4xx" id=link60 onMouseOver="ShowTip(event, 'tt53', 'link60')" onMouseOut="HideTip('tt53')">c_LwM2M_eventName_4xx</a></td><td class=SDescription>Charstring constant for the LWM2M 4xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_5xx" id=link61 onMouseOver="ShowTip(event, 'tt54', 'link61')" onMouseOut="HideTip('tt54')">c_LwM2M_eventIdx_5xx</a></td><td class=SDescription>Integer constant for the LWM2M 5xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_5xx" id=link62 onMouseOver="ShowTip(event, 'tt55', 'link62')" onMouseOut="HideTip('tt55')">c_LwM2M_eventName_5xx</a></td><td class=SDescription>Charstring constant for the LWM2M 5xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_6xx" id=link63 onMouseOver="ShowTip(event, 'tt56', 'link63')" onMouseOut="HideTip('tt56')">c_LwM2M_eventIdx_6xx</a></td><td class=SDescription>Integer constant for the LWM2M 6xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_6xx" id=link64 onMouseOver="ShowTip(event, 'tt57', 'link64')" onMouseOut="HideTip('tt57')">c_LwM2M_eventName_6xx</a></td><td class=SDescription>Charstring constant for the LWM2M 6xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_3xxto6xx" id=link65 onMouseOver="ShowTip(event, 'tt58', 'link65')" onMouseOut="HideTip('tt58')">c_LwM2M_eventIdx_3xxto6xx</a></td><td class=SDescription>Integer constant for the LWM2M 6xx reponse event</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_3xxto6xx" id=link66 onMouseOver="ShowTip(event, 'tt59', 'link66')" onMouseOut="HideTip('tt59')">c_LwM2M_eventName_3xxto6xx</a></td><td class=SDescription>Charstring constant for the LWM2M 6xx response event</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link67 onMouseOver="ShowTip(event, 'tt60', 'link67')" onMouseOut="HideTip('tt60')">c_LwM2M_eventIdx_resourceNotObservedIndication</a></td><td class=SDescription>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_resourceNotObservedIndication" id=link68 onMouseOver="ShowTip(event, 'tt61', 'link68')" onMouseOut="HideTip('tt61')">c_LwM2M_eventName_resourceNotObservedIndication</a></td><td class=SDescription>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_eventIdx_atomicBlock1Finished" id=link69 onMouseOver="ShowTip(event, 'tt62', 'link69')" onMouseOut="HideTip('tt62')">c_LwM2M_eventIdx_atomicBlock1Finished</a></td><td class=SDescription>Integer constant for indicating that a block1 transfer was finished</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_eventName_atomicBlock1Finished" id=link70 onMouseOver="ShowTip(event, 'tt63', 'link70')" onMouseOut="HideTip('tt63')">c_LwM2M_eventName_atomicBlock1Finished</a></td><td class=SDescription>Charstring constant for indicating that a block1 transfer was finished</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link71 onMouseOver="ShowTip(event, 'tt64', 'link71')" onMouseOut="HideTip('tt64')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td><td class=SDescription>Integer constant for the LWM2M loadTemplate (param: integer index) test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link72 onMouseOver="ShowTip(event, 'tt65', 'link72')" onMouseOut="HideTip('tt65')">c_LwM2M_stepName_loadTemplate_byIntIdx</a></td><td class=SDescription>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_send" id=link73 onMouseOver="ShowTip(event, 'tt66', 'link73')" onMouseOut="HideTip('tt66')">c_LwM2M_stepIdx_send</a></td><td class=SDescription>Integer constant for the LWM2M send test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_send" id=link74 onMouseOver="ShowTip(event, 'tt67', 'link74')" onMouseOut="HideTip('tt67')">c_LwM2M_stepName_send</a></td><td class=SDescription>Charstring constant for the LWM2M send test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createDevice" id=link75 onMouseOver="ShowTip(event, 'tt68', 'link75')" onMouseOut="HideTip('tt68')">c_LwM2M_stepIdx_createDevice</a></td><td class=SDescription>Integer constant for the LWM2M create device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createDevice" id=link76 onMouseOver="ShowTip(event, 'tt69', 'link76')" onMouseOut="HideTip('tt69')">c_LwM2M_stepName_createDevice</a></td><td class=SDescription>Charstring constant for the LWM2M create device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_cleanupDevice" id=link77 onMouseOver="ShowTip(event, 'tt70', 'link77')" onMouseOut="HideTip('tt70')">c_LwM2M_stepIdx_cleanupDevice</a></td><td class=SDescription>Integer constant for the LWM2M clean up device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_cleanupDevice" id=link78 onMouseOver="ShowTip(event, 'tt71', 'link78')" onMouseOut="HideTip('tt71')">c_LwM2M_stepName_cleanupDevice</a></td><td class=SDescription>Charstring constant for the LWM2M clean up device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_logDevice" id=link79 onMouseOver="ShowTip(event, 'tt72', 'link79')" onMouseOut="HideTip('tt72')">c_LwM2M_stepIdx_logDevice</a></td><td class=SDescription>Integer constant for the LWM2M log device test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_logDevice" id=link80 onMouseOver="ShowTip(event, 'tt73', 'link80')" onMouseOut="HideTip('tt73')">c_LwM2M_stepName_logDevice</a></td><td class=SDescription>Charstring constant for the LWM2M log device test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createObject" id=link81 onMouseOver="ShowTip(event, 'tt74', 'link81')" onMouseOut="HideTip('tt74')">c_LwM2M_stepIdx_createObject</a></td><td class=SDescription>Integer constant for the LWM2M create object test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createObject" id=link82 onMouseOver="ShowTip(event, 'tt75', 'link82')" onMouseOut="HideTip('tt75')">c_LwM2M_stepName_createObject</a></td><td class=SDescription>Charstring constant for the LWM2M create object test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_createObjectInstance" id=link83 onMouseOver="ShowTip(event, 'tt76', 'link83')" onMouseOut="HideTip('tt76')">c_LwM2M_stepIdx_createObjectInstance</a></td><td class=SDescription>Integer constant for the LWM2M create object instance test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_createObjectInstance" id=link84 onMouseOver="ShowTip(event, 'tt77', 'link84')" onMouseOut="HideTip('tt77')">c_LwM2M_stepName_createObjectInstance</a></td><td class=SDescription>Charstring constant for the LWM2M create object instance test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleReadRequest" id=link85 onMouseOver="ShowTip(event, 'tt78', 'link85')" onMouseOut="HideTip('tt78')">c_LwM2M_stepIdx_handleReadRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle READ request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleReadRequest" id=link86 onMouseOver="ShowTip(event, 'tt79', 'link86')" onMouseOut="HideTip('tt79')">c_LwM2M_stepName_handleReadRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle READ request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleWriteRequest" id=link87 onMouseOver="ShowTip(event, 'tt80', 'link87')" onMouseOut="HideTip('tt80')">c_LwM2M_stepIdx_handleWriteRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle WRITE request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleWriteRequest" id=link88 onMouseOver="ShowTip(event, 'tt81', 'link88')" onMouseOut="HideTip('tt81')">c_LwM2M_stepName_handleWriteRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle WRITE request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_handleExecuteRequest" id=link89 onMouseOver="ShowTip(event, 'tt82', 'link89')" onMouseOut="HideTip('tt82')">c_LwM2M_stepIdx_handleExecuteRequest</a></td><td class=SDescription>Integer constant for the LWM2M handle EXECUTE request test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_handleExecuteRequest" id=link90 onMouseOver="ShowTip(event, 'tt83', 'link90')" onMouseOut="HideTip('tt83')">c_LwM2M_stepName_handleExecuteRequest</a></td><td class=SDescription>Charstring constant for the LWM2M handle EXECUTE request test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link91 onMouseOver="ShowTip(event, 'tt84', 'link91')" onMouseOut="HideTip('tt84')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></td><td class=SDescription>Integer constant for the LWM2M load template (param: string id of the template) test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_loadTemplate_byStringId" id=link92 onMouseOver="ShowTip(event, 'tt85', 'link92')" onMouseOut="HideTip('tt85')">c_LwM2M_stepName_loadTemplate_byStringId</a></td><td class=SDescription>Charstring constant for the LWM2M load template (param: string id of the template) test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link93 onMouseOver="ShowTip(event, 'tt86', 'link93')" onMouseOut="HideTip('tt86')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td><td class=SDescription>Integer constant for the LWM2M send notification for observed resources test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" id=link94 onMouseOver="ShowTip(event, 'tt87', 'link94')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_sendNotificationForObservedResources</a></td><td class=SDescription>Charstring constant for the LWM2M send notification for observed resources test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" >c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Integer constant for the LWM2M set firmware update state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" id=link95 onMouseOver="ShowTip(event, 'tt88', 'link95')" onMouseOut="HideTip('tt88')">c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Charstring constant for the LWM2M set firmware update state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link96 onMouseOver="ShowTip(event, 'tt89', 'link96')" onMouseOut="HideTip('tt89')">c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td><td class=SDescription>Integer constant for the LWM2M set firmware update result test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setFirmwareUpdateState" >c_LwM2M_stepName_setFirmwareUpdateState</a></td><td class=SDescription>Charstring constant for the LWM2M set furmware update result test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBootstrapState" id=link97 onMouseOver="ShowTip(event, 'tt90', 'link97')" onMouseOut="HideTip('tt90')">c_LwM2M_stepIdx_setBootstrapState</a></td><td class=SDescription>Integer constant for the  LWM2M set bootstrap state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBootstrapState" id=link98 onMouseOver="ShowTip(event, 'tt91', 'link98')" onMouseOut="HideTip('tt91')">c_LwM2M_stepName_setBootstrapState</a></td><td class=SDescription>Charstring constant for the LWM2M set bootstrap state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setNotRegisteredState" id=link99 onMouseOver="ShowTip(event, 'tt92', 'link99')" onMouseOut="HideTip('tt92')">c_LwM2M_stepIdx_setNotRegisteredState</a></td><td class=SDescription>Integer constant for the  LWM2M set not registered state test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBootstrapState" >c_LwM2M_stepName_setBootstrapState</a></td><td class=SDescription>Charstring constant for the LWM2M set not registered state test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link100 onMouseOver="ShowTip(event, 'tt93', 'link100')" onMouseOut="HideTip('tt93')">c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td><td class=SDescription>Integer constant for the  LWM2M set block1 handling stateless test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBlock1Handling_stateless" id=link101 onMouseOver="ShowTip(event, 'tt94', 'link101')" onMouseOut="HideTip('tt94')">c_LwM2M_stepName_setBlock1Handling_stateless</a></td><td class=SDescription>Charstring constant for the LWM2M set block1 handling stateless test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link102 onMouseOver="ShowTip(event, 'tt95', 'link102')" onMouseOut="HideTip('tt95')">c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td><td class=SDescription>Integer constant for the  LWM2M set block1 handling atomic test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setBlock1Handling_atomic" id=link103 onMouseOver="ShowTip(event, 'tt96', 'link103')" onMouseOut="HideTip('tt96')">c_LwM2M_stepName_setBlock1Handling_atomic</a></td><td class=SDescription>Charstring constant for the LWM2M set block1 handling atomic test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_LwM2M_stepIdx_setContentFormats" id=link104 onMouseOver="ShowTip(event, 'tt97', 'link104')" onMouseOut="HideTip('tt97')">c_LwM2M_stepIdx_setContentFormats</a></td><td class=SDescription>Integer constant for setting the preferred content formats</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_LwM2M_stepName_setContentFormats" id=link105 onMouseOver="ShowTip(event, 'tt98', 'link105')" onMouseOut="HideTip('tt98')">c_LwM2M_stepName_setContentFormats</a></td><td class=SDescription>Charstring constant for setting the preferred content format</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
 
 <div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_log_error"></a>tsp_EPTF_LwM2M_LGen_log_error</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Enabled/disable error logging</p><h4 class=CHeading>Type</h4><p><b>boolean</b></p><h4 class=CHeading>Default value</h4><p><b>true</b></p></div></div></div>
 
@@ -19,37 +19,41 @@
 
 <div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_debugVerbose"></a>tsp_EPTF_LwM2M_LGen_debugVerbose</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Enabled/disable verbose debug logging</p><h4 class=CHeading>Type</h4><p><b>boolean</b></p><h4 class=CHeading>Default value</h4><p><b>false</b></p></div></div></div>
 
-<div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_templates"></a>tsp_EPTF_LwM2M_LGen_templates</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>List of LWM2M messages for sending</p><h4 class=CHeading>Type</h4><p><a href="#LwM2M_Template_List" class=LType id=link182 onMouseOver="ShowTip(event, 'tt9', 'link182')" onMouseOut="HideTip('tt9')">LwM2M_Template_List</a></p><h4 class=CHeading>Default value</h4><p>Empty list: {}</p></div></div></div>
+<div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_templates"></a>tsp_EPTF_LwM2M_LGen_templates</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>List of LWM2M messages for sending</p><h4 class=CHeading>Type</h4><p><a href="#LwM2M_Template_List" class=LType id=link204 onMouseOver="ShowTip(event, 'tt10', 'link204')" onMouseOut="HideTip('tt10')">LwM2M_Template_List</a></p><h4 class=CHeading>Default value</h4><p>Empty list: {}</p></div></div></div>
 
-<div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_objectSpecifications"></a>tsp_EPTF_LwM2M_LGen_objectSpecifications</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>List of smart object specifications (needed for creating smart object instances)</p><h4 class=CHeading>Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=LType id=link183 onMouseOver="ShowTip(event, 'tt105', 'link183')" onMouseOut="HideTip('tt105')">LwM2M_ObjectSpecification_List</a></p><h4 class=CHeading>Default value</h4><p>Empty list: {}</p></div></div></div>
+<div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_objectSpecifications"></a>tsp_EPTF_LwM2M_LGen_objectSpecifications</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>List of smart object specifications (needed for creating smart object instances)</p><h4 class=CHeading>Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=LType id=link205 onMouseOver="ShowTip(event, 'tt108', 'link205')" onMouseOut="HideTip('tt108')">LwM2M_ObjectSpecification_List</a></p><h4 class=CHeading>Default value</h4><p>Empty list: {}</p></div></div></div>
+
+<div class="CModuleParameter"><div class=CTopic><h3 class=CTitle><a name="tsp_EPTF_LwM2M_LGen_defaultContentFormat"></a>tsp_EPTF_LwM2M_LGen_defaultContentFormat</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Setting the default content format code for encoding LwM2M payload</p><h4 class=CHeading>Type</h4><p><b>integer</b></p><h4 class=CHeading>Default value</h4><p>11543</p></div></div></div>
 
 <div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_behaviorType"></a>c_LwM2M_behaviorType</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Constant for LWM2M behaviour name</p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx"></a>LwM2M_EntityCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - pointer to the entity itself</td></tr><tr><td class=CDLEntry>currentDevice</td><td class=CDLDescription><b>integer</b> - pointer to the simulated <a href="#LwM2M_Device" class=LType id=link184 onMouseOver="ShowTip(event, 'tt5', 'link184')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> in <b>v_LwM2M_DeviceDB</b></td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link185 onMouseOver="ShowTip(event, 'tt109', 'link185')" onMouseOut="HideTip('tt109')">f_LwM2M_step_createDevice</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link186 onMouseOver="ShowTip(event, 'tt110', 'link186')" onMouseOut="HideTip('tt110')">f_LwM2M_step_cleanupDevice</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx"></a>LwM2M_EntityCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - pointer to the entity itself</td></tr><tr><td class=CDLEntry>currentDevice</td><td class=CDLDescription><b>integer</b> - pointer to the simulated <a href="#LwM2M_Device" class=LType id=link206 onMouseOver="ShowTip(event, 'tt5', 'link206')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> in <b>v_LwM2M_DeviceDB</b></td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link207 onMouseOver="ShowTip(event, 'tt113', 'link207')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createDevice</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link208 onMouseOver="ShowTip(event, 'tt114', 'link208')" onMouseOut="HideTip('tt114')">f_LwM2M_step_cleanupDevice</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr)</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx_List"></a>LwM2M_EntityCtx_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_EntityCtx" class=LType id=link187 onMouseOver="ShowTip(event, 'tt2', 'link187')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></p></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx_List"></a>LwM2M_EntityCtx_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_EntityCtx" class=LType id=link209 onMouseOver="ShowTip(event, 'tt2', 'link209')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx_DB"></a>LwM2M_EntityCtx_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing LWM2M entity contexts</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>queue</td><td class=CDLDescription>&lt;EPTF_FreeBusyQueue&gt; - FBQ for the stored elements</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_EntityCtx_List" class=LType id=link188 onMouseOver="ShowTip(event, 'tt3', 'link188')" onMouseOut="HideTip('tt3')">LwM2M_EntityCtx_List</a> - elements</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=LFunction id=link189 onMouseOver="ShowTip(event, 'tt118', 'link189')" onMouseOut="HideTip('tt118')">f_EPTF_LwM2M_EntityCtxDB_init</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=LFunction id=link190 onMouseOver="ShowTip(event, 'tt119', 'link190')" onMouseOut="HideTip('tt119')">f_EPTF_LwM2M_EntityCtxDB_cleanUp</a> ()</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_EntityCtx_DB"></a>LwM2M_EntityCtx_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing LWM2M entity contexts</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>queue</td><td class=CDLDescription>&lt;EPTF_FreeBusyQueue&gt; - FBQ for the stored elements</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_EntityCtx_List" class=LType id=link210 onMouseOver="ShowTip(event, 'tt3', 'link210')" onMouseOut="HideTip('tt3')">LwM2M_EntityCtx_List</a> - elements</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=LFunction id=link211 onMouseOver="ShowTip(event, 'tt129', 'link211')" onMouseOut="HideTip('tt129')">f_EPTF_LwM2M_EntityCtxDB_init</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=LFunction id=link212 onMouseOver="ShowTip(event, 'tt130', 'link212')" onMouseOut="HideTip('tt130')">f_EPTF_LwM2M_EntityCtxDB_cleanUp</a> ()</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device"></a>LwM2M_Device</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing the state and smart object of a simulated LWM2M device</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>registeredLocation</td><td class=CDLDescription>&lt;Location&gt; - id acquired during registration</td></tr><tr><td class=CDLEntry>objects</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link191 onMouseOver="ShowTip(event, 'tt120', 'link191')" onMouseOut="HideTip('tt120')">LwM2M_ObjectDB</a> - smart objects and their instances</td></tr><tr><td class=CDLEntry>state</td><td class=CDLDescription><a href="#LwM2M_Device_State" class=LType id=link192 onMouseOver="ShowTip(event, 'tt121', 'link192')" onMouseOut="HideTip('tt121')">LwM2M_Device_State</a> - tracking the state of the device</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=LFunction id=link193 onMouseOver="ShowTip(event, 'tt122', 'link193')" onMouseOut="HideTip('tt122')">f_EPTF_LwM2M_sendNotificationForResource</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr, <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link194 onMouseOver="ShowTip(event, 'tt123', 'link194')" onMouseOut="HideTip('tt123')">LwM2M_Resource</a> v_res)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device"></a>LwM2M_Device</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing the state and smart object of a simulated LWM2M device</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>registeredLocation</td><td class=CDLDescription>&lt;Location&gt; - id acquired during registration</td></tr><tr><td class=CDLEntry>objects</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link213 onMouseOver="ShowTip(event, 'tt131', 'link213')" onMouseOut="HideTip('tt131')">LwM2M_ObjectDB</a> - smart objects and their instances</td></tr><tr><td class=CDLEntry>block1Handling</td><td class=CDLDescription><a href="#LwM2M_Block1_Handling" class=LType id=link214 onMouseOver="ShowTip(event, 'tt132', 'link214')" onMouseOut="HideTip('tt132')">LwM2M_Block1_Handling</a> - block1 handling (atomic/stateless)</td></tr><tr><td class=CDLEntry>contentFormats</td><td class=CDLDescription>&lt;EPTF_IntegerList&gt; - preferred content formats for encoding payload</td></tr><tr><td class=CDLEntry>state</td><td class=CDLDescription><a href="#LwM2M_Device_State" class=LType id=link215 onMouseOver="ShowTip(event, 'tt133', 'link215')" onMouseOut="HideTip('tt133')">LwM2M_Device_State</a> - tracking the state of the device</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=LFunction id=link216 onMouseOver="ShowTip(event, 'tt134', 'link216')" onMouseOut="HideTip('tt134')">f_EPTF_LwM2M_sendNotificationForResource</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr, <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link217 onMouseOver="ShowTip(event, 'tt135', 'link217')" onMouseOut="HideTip('tt135')">LwM2M_Resource</a> v_res)</li></ul></div></div></div>
 
-<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_State"></a>LwM2M_Device_State</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>States of a <a href="#LwM2M_Device" class=LType id=link195 onMouseOver="ShowTip(event, 'tt5', 'link195')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</p><h4 class=CHeading>Elements</h4><ul><li>NOT_REGISTERED</li><li>REGISTERED</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Format_List"></a>LwM2M_Format_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_Format_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <b>integer</b></p></div></div></div>
 
-<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Block1_Handling"></a>LwM2M_Block1_Handling</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Block1 handling strategy of a <a href="#LwM2M_Device" class=LType id=link196 onMouseOver="ShowTip(event, 'tt5', 'link196')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</p><h4 class=CHeading>Elements</h4><ul><li>STATELESS</li><li>ATOMIC</li></ul></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_State"></a>LwM2M_Device_State</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>States of a <a href="#LwM2M_Device" class=LType id=link218 onMouseOver="ShowTip(event, 'tt5', 'link218')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</p><h4 class=CHeading>Elements</h4><ul><li>NOT_REGISTERED</li><li>REGISTERED</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_List"></a>LwM2M_Device_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_Device" class=LType id=link197 onMouseOver="ShowTip(event, 'tt5', 'link197')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></p></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Block1_Handling"></a>LwM2M_Block1_Handling</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Block1 handling strategy of a <a href="#LwM2M_Device" class=LType id=link219 onMouseOver="ShowTip(event, 'tt5', 'link219')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> simulated LWM2M device</p><h4 class=CHeading>Elements</h4><ul><li>STATELESS</li><li>ATOMIC</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_DB"></a>LwM2M_Device_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Device" class=LType id=link198 onMouseOver="ShowTip(event, 'tt5', 'link198')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>queue</td><td class=CDLDescription>&lt;EPTF_FreeBusyQueue&gt; - FBQ for the stored elements</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_Device_List" class=LType id=link199 onMouseOver="ShowTip(event, 'tt6', 'link199')" onMouseOut="HideTip('tt6')">LwM2M_Device_List</a> - elements</td></tr><tr><td class=CDLEntry>hashFref</td><td class=CDLDescription><b>integer</b> - hashmap id used for looking up devices</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=LFunction id=link200 onMouseOver="ShowTip(event, 'tt124', 'link200')" onMouseOut="HideTip('tt124')">f_EPTF_LwM2M_DeviceDB_init</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=LFunction id=link201 onMouseOver="ShowTip(event, 'tt125', 'link201')" onMouseOut="HideTip('tt125')">f_EPTF_LwM2M_DeviceDB_add</a> (in <a href="#LwM2M_Device" class=LType id=link202 onMouseOver="ShowTip(event, 'tt5', 'link202')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> p_device)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=LFunction id=link203 onMouseOver="ShowTip(event, 'tt126', 'link203')" onMouseOut="HideTip('tt126')">f_EPTF_LwM2M_DeviceDB_remove</a> (in <b>integer</b> p_idx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=LFunction id=link204 onMouseOver="ShowTip(event, 'tt127', 'link204')" onMouseOut="HideTip('tt127')">f_EPTF_LwM2M_DeviceDB_setLocationKey</a> (in &lt;Location&gt; p_location, in <b>integer</b> p_idx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=LFunction id=link205 onMouseOver="ShowTip(event, 'tt128', 'link205')" onMouseOut="HideTip('tt128')">f_EPTF_LwM2M_DeviceDB_locationHash</a> (in &lt;Location&gt; p_location)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=LFunction id=link206 onMouseOver="ShowTip(event, 'tt129', 'link206')" onMouseOut="HideTip('tt129')">f_EPTF_LwM2M_DeviceDB_cleanUp</a> ()</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_List"></a>LwM2M_Device_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_Device" class=LType id=link220 onMouseOver="ShowTip(event, 'tt5', 'link220')" onMouseOut="HideTip('tt5')">LwM2M_Device</a></p></div></div></div>
+
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Device_DB"></a>LwM2M_Device_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Device" class=LType id=link221 onMouseOver="ShowTip(event, 'tt5', 'link221')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>queue</td><td class=CDLDescription>&lt;EPTF_FreeBusyQueue&gt; - FBQ for the stored elements</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_Device_List" class=LType id=link222 onMouseOver="ShowTip(event, 'tt7', 'link222')" onMouseOut="HideTip('tt7')">LwM2M_Device_List</a> - elements</td></tr><tr><td class=CDLEntry>hashFref</td><td class=CDLDescription><b>integer</b> - hashmap id used for looking up devices</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=LFunction id=link223 onMouseOver="ShowTip(event, 'tt136', 'link223')" onMouseOut="HideTip('tt136')">f_EPTF_LwM2M_DeviceDB_init</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=LFunction id=link224 onMouseOver="ShowTip(event, 'tt137', 'link224')" onMouseOut="HideTip('tt137')">f_EPTF_LwM2M_DeviceDB_add</a> (in <a href="#LwM2M_Device" class=LType id=link225 onMouseOver="ShowTip(event, 'tt5', 'link225')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> p_device)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=LFunction id=link226 onMouseOver="ShowTip(event, 'tt138', 'link226')" onMouseOut="HideTip('tt138')">f_EPTF_LwM2M_DeviceDB_remove</a> (in <b>integer</b> p_idx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=LFunction id=link227 onMouseOver="ShowTip(event, 'tt139', 'link227')" onMouseOut="HideTip('tt139')">f_EPTF_LwM2M_DeviceDB_setLocationKey</a> (in &lt;Location&gt; p_location, in <b>integer</b> p_idx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=LFunction id=link228 onMouseOver="ShowTip(event, 'tt140', 'link228')" onMouseOut="HideTip('tt140')">f_EPTF_LwM2M_DeviceDB_locationHash</a> (in &lt;Location&gt; p_location)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=LFunction id=link229 onMouseOver="ShowTip(event, 'tt141', 'link229')" onMouseOut="HideTip('tt141')">f_EPTF_LwM2M_DeviceDB_cleanUp</a> ()</li></ul></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Template"></a>LwM2M_Template</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Grouping a &lt;LWM2M_PDU&gt; with an id so that the message can be loaded from an FSM later by using the id</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>charstring</b> - identifier</td></tr><tr><td class=CDLEntry>msg</td><td class=CDLDescription>&lt;LWM2M_PDU&gt; - LWM2M PDU</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Template_List"></a>LwM2M_Template_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_Template" class=LType id=link207 onMouseOver="ShowTip(event, 'tt8', 'link207')" onMouseOut="HideTip('tt8')">LwM2M_Template</a></p></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Template_List"></a>LwM2M_Template_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_Template" class=LType id=link230 onMouseOver="ShowTip(event, 'tt9', 'link230')" onMouseOut="HideTip('tt9')">LwM2M_Template</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Template_DB"></a>LwM2M_Template_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Template" class=LType id=link208 onMouseOver="ShowTip(event, 'tt8', 'link208')" onMouseOut="HideTip('tt8')">LwM2M_Template</a> instances</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_Template_List" class=LType id=link209 onMouseOver="ShowTip(event, 'tt9', 'link209')" onMouseOut="HideTip('tt9')">LwM2M_Template_List</a> - elements</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li>&lt;f_EPTF_LwM2M_templateDB_init&gt; ()</li><li>&lt;f_EPTF_LwM2M_templateDB_add&gt; (in <a href="#LwM2M_Template" class=LType id=link210 onMouseOver="ShowTip(event, 'tt8', 'link210')" onMouseOut="HideTip('tt8')">LwM2M_Template</a> p_template)</li><li>&lt;f_EPTF_LwM2M_templateDB_lookUp&gt; (in <b>charstring</b> p_id)</li><li>&lt;f_EPTF_LwM2M_templateDB_get&gt; (in <b>integer</b> p_idx, inout &lt;LWM2M_PDU&gt; p_pdu)</li><li>&lt;f_EPTF_LwM2M_templateDB_cleanUp&gt; ()</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Template_DB"></a>LwM2M_Template_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Template" class=LType id=link231 onMouseOver="ShowTip(event, 'tt9', 'link231')" onMouseOut="HideTip('tt9')">LwM2M_Template</a> instances</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_Template_List" class=LType id=link232 onMouseOver="ShowTip(event, 'tt10', 'link232')" onMouseOut="HideTip('tt10')">LwM2M_Template_List</a> - elements</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li>&lt;f_EPTF_LwM2M_templateDB_init&gt; ()</li><li>&lt;f_EPTF_LwM2M_templateDB_add&gt; (in <a href="#LwM2M_Template" class=LType id=link233 onMouseOver="ShowTip(event, 'tt9', 'link233')" onMouseOut="HideTip('tt9')">LwM2M_Template</a> p_template)</li><li>&lt;f_EPTF_LwM2M_templateDB_lookUp&gt; (in <b>charstring</b> p_id)</li><li>&lt;f_EPTF_LwM2M_templateDB_get&gt; (in <b>integer</b> p_idx, inout &lt;LWM2M_PDU&gt; p_pdu)</li><li>&lt;f_EPTF_LwM2M_templateDB_cleanUp&gt; ()</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_StepCtx"></a>LwM2M_StepCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Stores the most important pointers that are used from a test steps</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - entity index</td></tr><tr><td class=CDLEntry>fsmIdx</td><td class=CDLDescription><b>integer</b> - fsm index</td></tr><tr><td class=CDLEntry>eCtxIdx</td><td class=CDLDescription><b>integer</b> - entity context index <a href="#LwM2M_EntityCtx" class=LType id=link211 onMouseOver="ShowTip(event, 'tt2', 'link211')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b></td></tr><tr><td class=CDLEntry>deviceIdx</td><td class=CDLDescription><b>integer</b> - device instance index <a href="#LwM2M_Device" class=LType id=link212 onMouseOver="ShowTip(event, 'tt5', 'link212')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> in <b>v_LwM2M_DeviceDB</b></td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_StepCtx"></a>LwM2M_StepCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Stores the most important pointers that are used from a test steps</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - entity index</td></tr><tr><td class=CDLEntry>fsmIdx</td><td class=CDLDescription><b>integer</b> - fsm index</td></tr><tr><td class=CDLEntry>eCtxIdx</td><td class=CDLDescription><b>integer</b> - entity context index <a href="#LwM2M_EntityCtx" class=LType id=link234 onMouseOver="ShowTip(event, 'tt2', 'link234')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b></td></tr><tr><td class=CDLEntry>deviceIdx</td><td class=CDLDescription><b>integer</b> - device instance index <a href="#LwM2M_Device" class=LType id=link235 onMouseOver="ShowTip(event, 'tt5', 'link235')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> in <b>v_LwM2M_DeviceDB</b></td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_LGen_CT"></a>EPTF_LwM2M_LGen_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>LWM2M load generator component</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg)</p><h4 class=CHeading>Extensions</h4><ul><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link213 onMouseOver="ShowTip(event, 'tt130', 'link213')" onMouseOut="HideTip('tt130')">EPTF_LwM2M_Transport_User_CT</a></li><li>&lt;EPTF_LGenBase_CT&gt;</li><li>&lt;EPTF_Logging_CT&gt;</li></ul><h4 class=CHeading>Ports</h4><p>-</p><h4 class=CHeading>Timers</h4><p>-</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_LwM2M_initialized</td><td class=CDLDescription><b>boolean</b> - Flag to indicate that if init function was already called</td></tr><tr><td class=CDLEntry>v_LwM2M_bIdx</td><td class=CDLDescription><b>integer</b> - Name of the LWM2M LGen component</td></tr><tr><td class=CDLEntry>v_LwM2M_loggingMaskId</td><td class=CDLDescription><b>integer</b> - logging mask id</td></tr><tr><td class=CDLEntry>v_LwM2M_ctx</td><td class=CDLDescription><a href="#LwM2M_StepCtx" class=LType id=link214 onMouseOver="ShowTip(event, 'tt11', 'link214')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a> - collection of the most important pointers</td></tr><tr><td class=CDLEntry>v_LwM2M_msgToProcess</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link215 onMouseOver="ShowTip(event, 'tt131', 'link215')" onMouseOut="HideTip('tt131')">EPTF_LwM2M_PDU</a> - message from the transport layer to process</td></tr><tr><td class=CDLEntry>v_LwM2M_msgToSend</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link216 onMouseOver="ShowTip(event, 'tt131', 'link216')" onMouseOut="HideTip('tt131')">EPTF_LwM2M_PDU</a> - message to send to the transport layer</td></tr><tr><td class=CDLEntry>v_LwM2M_eventToProcess</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link217 onMouseOver="ShowTip(event, 'tt132', 'link217')" onMouseOut="HideTip('tt132')">EPTF_LwM2M_Event</a> - incoming event from the transport layer to process</td></tr></table><h4 class=CHeading>Instance databases</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_LwM2M_templateDB</td><td class=CDLDescription><a href="#LwM2M_Template_DB" class=LType id=link218 onMouseOver="ShowTip(event, 'tt10', 'link218')" onMouseOut="HideTip('tt10')">LwM2M_Template_DB</a> - template database <a href="#LwM2M_Template" class=LType id=link219 onMouseOver="ShowTip(event, 'tt8', 'link219')" onMouseOut="HideTip('tt8')">LwM2M_Template</a></td></tr><tr><td class=CDLEntry>v_LwM2M_EntityCtxDB</td><td class=CDLDescription><a href="#LwM2M_EntityCtx_DB" class=LType id=link220 onMouseOver="ShowTip(event, 'tt4', 'link220')" onMouseOut="HideTip('tt4')">LwM2M_EntityCtx_DB</a> - database of entity contexts <a href="#LwM2M_EntityCtx" class=LType id=link221 onMouseOver="ShowTip(event, 'tt2', 'link221')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td></tr><tr><td class=CDLEntry>v_LwM2M_DeviceDB</td><td class=CDLDescription><a href="#LwM2M_Device_DB" class=LType id=link222 onMouseOver="ShowTip(event, 'tt7', 'link222')" onMouseOut="HideTip('tt7')">LwM2M_Device_DB</a> - database of <a href="#LwM2M_Device" class=LType id=link223 onMouseOver="ShowTip(event, 'tt5', 'link223')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</td></tr><tr><td class=CDLEntry>v_LwM2M_ObjectSpecificationDB</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link224 onMouseOver="ShowTip(event, 'tt133', 'link224')" onMouseOut="HideTip('tt133')">LwM2M_ObjectSpecificationDB</a> - object specification database <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link225 onMouseOver="ShowTip(event, 'tt134', 'link225')" onMouseOut="HideTip('tt134')">LwM2M_ObjectSpecification</a></td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=LFunction id=link226 onMouseOver="ShowTip(event, 'tt135', 'link226')" onMouseOut="HideTip('tt135')">f_EPTF_LwM2M_LGen_init</a> (in <b>charstring</b> pl_name)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=LFunction id=link227 onMouseOver="ShowTip(event, 'tt136', 'link227')" onMouseOut="HideTip('tt136')">f_LwM2M_cleanUp</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=LFunction id=link228 onMouseOver="ShowTip(event, 'tt137', 'link228')" onMouseOut="HideTip('tt137')">f_LwM2M_eCtxBind</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=LFunction id=link229 onMouseOver="ShowTip(event, 'tt138', 'link229')" onMouseOut="HideTip('tt138')">f_LwM2M_eCtxUnbind</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=LFunction id=link230 onMouseOver="ShowTip(event, 'tt139', 'link230')" onMouseOut="HideTip('tt139')">f_LwM2M_eCtxReset</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=LFunction id=link231 onMouseOver="ShowTip(event, 'tt140', 'link231')" onMouseOut="HideTip('tt140')">f_EPTF_LwM2M_Logging_VERBOSE</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=LFunction id=link232 onMouseOver="ShowTip(event, 'tt141', 'link232')" onMouseOut="HideTip('tt141')">f_EPTF_LwM2M_Logging_DEBUG</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=LFunction id=link233 onMouseOver="ShowTip(event, 'tt142', 'link233')" onMouseOut="HideTip('tt142')">f_EPTF_LwM2M_Logging_WARNING</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=LFunction id=link234 onMouseOver="ShowTip(event, 'tt143', 'link234')" onMouseOut="HideTip('tt143')">f_EPTF_LwM2M_Logging_ERROR</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=LFunction id=link235 onMouseOver="ShowTip(event, 'tt144', 'link235')" onMouseOut="HideTip('tt144')">f_EPTF_LwM2M_LGen_receiveMessage</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link236 onMouseOver="ShowTip(event, 'tt131', 'link236')" onMouseOut="HideTip('tt131')">EPTF_LwM2M_PDU</a> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=LFunction id=link237 onMouseOver="ShowTip(event, 'tt145', 'link237')" onMouseOut="HideTip('tt145')">f_EPTF_LwM2M_LGen_receiveEvent</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link238 onMouseOver="ShowTip(event, 'tt132', 'link238')" onMouseOut="HideTip('tt132')">EPTF_LwM2M_Event</a> pl_event)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=LFunction id=link239 onMouseOver="ShowTip(event, 'tt146', 'link239')" onMouseOut="HideTip('tt146')">f_EPTF_LwM2M_declareEvents</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=LFunction id=link240 onMouseOver="ShowTip(event, 'tt147', 'link240')" onMouseOut="HideTip('tt147')">f_EPTF_LwM2M_declareSteps</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=LFunction id=link241 onMouseOver="ShowTip(event, 'tt148', 'link241')" onMouseOut="HideTip('tt148')">f_EPTF_LwM2M_setStepCtx</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr, inout <a href="#LwM2M_StepCtx" class=LType id=link242 onMouseOver="ShowTip(event, 'tt11', 'link242')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=LFunction id=link243 onMouseOver="ShowTip(event, 'tt149', 'link243')" onMouseOut="HideTip('tt149')">f_EPTF_LwM2M_setCtx</a> (in <b>integer</b> p_eIdx, in <b>integer</b> p_fsmIdx, inout <a href="#LwM2M_StepCtx" class=LType id=link244 onMouseOver="ShowTip(event, 'tt11', 'link244')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=LFunction id=link245 onMouseOver="ShowTip(event, 'tt150', 'link245')" onMouseOut="HideTip('tt150')">f_EPTF_LwM2M_hasDevice</a> (in <a href="#LwM2M_StepCtx" class=LType id=link246 onMouseOver="ShowTip(event, 'tt11', 'link246')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=LFunction id=link247 onMouseOver="ShowTip(event, 'tt151', 'link247')" onMouseOut="HideTip('tt151')">f_EPTF_LwM2M_stack_fromApp</a> (inout <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link248 onMouseOver="ShowTip(event, 'tt131', 'link248')" onMouseOut="HideTip('tt131')">EPTF_LwM2M_PDU</a> p_pdu, in <a href="#LwM2M_StepCtx" class=LType id=link249 onMouseOver="ShowTip(event, 'tt11', 'link249')" onMouseOut="HideTip('tt11')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=LFunction id=link250 onMouseOver="ShowTip(event, 'tt152', 'link250')" onMouseOut="HideTip('tt152')">f_EPTF_LwM2M_stack_fromEnv</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link251 onMouseOver="ShowTip(event, 'tt131', 'link251')" onMouseOut="HideTip('tt131')">EPTF_LwM2M_PDU</a> p_pdu)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=LFunction id=link252 onMouseOver="ShowTip(event, 'tt153', 'link252')" onMouseOut="HideTip('tt153')">f_EPTF_LwM2M_dispatchEventsForPDU</a> (in &lt;LWM2M_PDU&gt; pl_pdu, in <b>integer</b> pl_eIdx, in <b>integer</b> pl_fsmCtx, in &lt;EPTF_IntegerList&gt; pl_reportedArgs)</li><li>&lt;f_EPTF_LwM2M_dispatchEvent&gt;(in <b>integer</b> pl_eventIdx, in <b>integer</b> pl_eIdx, in <b>integer</b> pl_fsmCtx, in &lt;EPTF_IntegerList&gt; pl_reportedArgs)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_LGen_CT"></a>EPTF_LwM2M_LGen_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>LWM2M load generator component</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg"><h4 class=CHeading>Extensions</h4><ul><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link236 onMouseOver="ShowTip(event, 'tt142', 'link236')" onMouseOut="HideTip('tt142')">EPTF_LwM2M_Transport_User_CT</a></li><li>&lt;EPTF_LGenBase_CT&gt;</li><li>&lt;EPTF_Logging_CT&gt;</li></ul><h4 class=CHeading>Ports</h4><p>-</p><h4 class=CHeading>Timers</h4><p>-</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_LwM2M_initialized</td><td class=CDLDescription><b>boolean</b> - Flag to indicate that if init function was already called</td></tr><tr><td class=CDLEntry>v_LwM2M_bIdx</td><td class=CDLDescription><b>integer</b> - Name of the LWM2M LGen component</td></tr><tr><td class=CDLEntry>v_LwM2M_loggingMaskId</td><td class=CDLDescription><b>integer</b> - logging mask id</td></tr><tr><td class=CDLEntry>v_LwM2M_ctx</td><td class=CDLDescription><a href="#LwM2M_StepCtx" class=LType id=link237 onMouseOver="ShowTip(event, 'tt12', 'link237')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a> - collection of the most important pointers</td></tr><tr><td class=CDLEntry>v_LwM2M_msgToProcess</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link238 onMouseOver="ShowTip(event, 'tt143', 'link238')" onMouseOut="HideTip('tt143')">EPTF_LwM2M_PDU</a> - message from the transport layer to process</td></tr><tr><td class=CDLEntry>v_LwM2M_msgToSend</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link239 onMouseOver="ShowTip(event, 'tt143', 'link239')" onMouseOut="HideTip('tt143')">EPTF_LwM2M_PDU</a> - message to send to the transport layer</td></tr><tr><td class=CDLEntry>v_LwM2M_eventToProcess</td><td class=CDLDescription><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link240 onMouseOver="ShowTip(event, 'tt144', 'link240')" onMouseOut="HideTip('tt144')">EPTF_LwM2M_Event</a> - incoming event from the transport layer to process</td></tr></table><h4 class=CHeading>Instance databases</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>v_LwM2M_templateDB</td><td class=CDLDescription><a href="#LwM2M_Template_DB" class=LType id=link241 onMouseOver="ShowTip(event, 'tt11', 'link241')" onMouseOut="HideTip('tt11')">LwM2M_Template_DB</a> - template database <a href="#LwM2M_Template" class=LType id=link242 onMouseOver="ShowTip(event, 'tt9', 'link242')" onMouseOut="HideTip('tt9')">LwM2M_Template</a></td></tr><tr><td class=CDLEntry>v_LwM2M_EntityCtxDB</td><td class=CDLDescription><a href="#LwM2M_EntityCtx_DB" class=LType id=link243 onMouseOver="ShowTip(event, 'tt4', 'link243')" onMouseOut="HideTip('tt4')">LwM2M_EntityCtx_DB</a> - database of entity contexts <a href="#LwM2M_EntityCtx" class=LType id=link244 onMouseOver="ShowTip(event, 'tt2', 'link244')" onMouseOut="HideTip('tt2')">LwM2M_EntityCtx</a></td></tr><tr><td class=CDLEntry>v_LwM2M_DeviceDB</td><td class=CDLDescription><a href="#LwM2M_Device_DB" class=LType id=link245 onMouseOver="ShowTip(event, 'tt8', 'link245')" onMouseOut="HideTip('tt8')">LwM2M_Device_DB</a> - database of <a href="#LwM2M_Device" class=LType id=link246 onMouseOver="ShowTip(event, 'tt5', 'link246')" onMouseOut="HideTip('tt5')">LwM2M_Device</a> instances</td></tr><tr><td class=CDLEntry>v_LwM2M_ObjectSpecificationDB</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link247 onMouseOver="ShowTip(event, 'tt145', 'link247')" onMouseOut="HideTip('tt145')">LwM2M_ObjectSpecificationDB</a> - object specification database <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link248 onMouseOver="ShowTip(event, 'tt146', 'link248')" onMouseOut="HideTip('tt146')">LwM2M_ObjectSpecification</a></td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=LFunction id=link249 onMouseOver="ShowTip(event, 'tt147', 'link249')" onMouseOut="HideTip('tt147')">f_EPTF_LwM2M_LGen_init</a> (in <b>charstring</b> pl_name)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=LFunction id=link250 onMouseOver="ShowTip(event, 'tt148', 'link250')" onMouseOut="HideTip('tt148')">f_LwM2M_cleanUp</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=LFunction id=link251 onMouseOver="ShowTip(event, 'tt149', 'link251')" onMouseOut="HideTip('tt149')">f_LwM2M_eCtxBind</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=LFunction id=link252 onMouseOver="ShowTip(event, 'tt150', 'link252')" onMouseOut="HideTip('tt150')">f_LwM2M_eCtxUnbind</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=LFunction id=link253 onMouseOver="ShowTip(event, 'tt151', 'link253')" onMouseOut="HideTip('tt151')">f_LwM2M_eCtxReset</a> (in <b>integer</b> pl_eIdx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=LFunction id=link254 onMouseOver="ShowTip(event, 'tt152', 'link254')" onMouseOut="HideTip('tt152')">f_EPTF_LwM2M_Logging_VERBOSE</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=LFunction id=link255 onMouseOver="ShowTip(event, 'tt153', 'link255')" onMouseOut="HideTip('tt153')">f_EPTF_LwM2M_Logging_DEBUG</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=LFunction id=link256 onMouseOver="ShowTip(event, 'tt154', 'link256')" onMouseOut="HideTip('tt154')">f_EPTF_LwM2M_Logging_WARNING</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=LFunction id=link257 onMouseOver="ShowTip(event, 'tt155', 'link257')" onMouseOut="HideTip('tt155')">f_EPTF_LwM2M_Logging_ERROR</a> (in @lazy <b>charstring</b> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=LFunction id=link258 onMouseOver="ShowTip(event, 'tt156', 'link258')" onMouseOut="HideTip('tt156')">f_EPTF_LwM2M_LGen_receiveMessage</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link259 onMouseOver="ShowTip(event, 'tt143', 'link259')" onMouseOut="HideTip('tt143')">EPTF_LwM2M_PDU</a> pl_message)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=LFunction id=link260 onMouseOver="ShowTip(event, 'tt157', 'link260')" onMouseOut="HideTip('tt157')">f_EPTF_LwM2M_LGen_receiveEvent</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link261 onMouseOver="ShowTip(event, 'tt144', 'link261')" onMouseOut="HideTip('tt144')">EPTF_LwM2M_Event</a> pl_event)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=LFunction id=link262 onMouseOver="ShowTip(event, 'tt158', 'link262')" onMouseOut="HideTip('tt158')">f_EPTF_LwM2M_declareEvents</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=LFunction id=link263 onMouseOver="ShowTip(event, 'tt159', 'link263')" onMouseOut="HideTip('tt159')">f_EPTF_LwM2M_declareSteps</a> ()</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=LFunction id=link264 onMouseOver="ShowTip(event, 'tt160', 'link264')" onMouseOut="HideTip('tt160')">f_EPTF_LwM2M_setStepCtx</a> (in &lt;EPTF_LGenBase_TestStepArgs&gt; pl_ptr, inout <a href="#LwM2M_StepCtx" class=LType id=link265 onMouseOver="ShowTip(event, 'tt12', 'link265')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=LFunction id=link266 onMouseOver="ShowTip(event, 'tt161', 'link266')" onMouseOut="HideTip('tt161')">f_EPTF_LwM2M_setCtx</a> (in <b>integer</b> p_eIdx, in <b>integer</b> p_fsmIdx, inout <a href="#LwM2M_StepCtx" class=LType id=link267 onMouseOver="ShowTip(event, 'tt12', 'link267')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=LFunction id=link268 onMouseOver="ShowTip(event, 'tt162', 'link268')" onMouseOut="HideTip('tt162')">f_EPTF_LwM2M_hasDevice</a> (in <a href="#LwM2M_StepCtx" class=LType id=link269 onMouseOver="ShowTip(event, 'tt12', 'link269')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=LFunction id=link270 onMouseOver="ShowTip(event, 'tt163', 'link270')" onMouseOut="HideTip('tt163')">f_EPTF_LwM2M_stack_fromApp</a> (inout <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link271 onMouseOver="ShowTip(event, 'tt143', 'link271')" onMouseOut="HideTip('tt143')">EPTF_LwM2M_PDU</a> p_pdu, in <a href="#LwM2M_StepCtx" class=LType id=link272 onMouseOver="ShowTip(event, 'tt12', 'link272')" onMouseOut="HideTip('tt12')">LwM2M_StepCtx</a> p_ctx)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=LFunction id=link273 onMouseOver="ShowTip(event, 'tt164', 'link273')" onMouseOut="HideTip('tt164')">f_EPTF_LwM2M_stack_fromEnv</a> (in <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link274 onMouseOver="ShowTip(event, 'tt143', 'link274')" onMouseOut="HideTip('tt143')">EPTF_LwM2M_PDU</a> p_pdu)</li><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=LFunction id=link275 onMouseOver="ShowTip(event, 'tt165', 'link275')" onMouseOut="HideTip('tt165')">f_EPTF_LwM2M_dispatchEventsForPDU</a> (in &lt;LWM2M_PDU&gt; pl_pdu, in <b>integer</b> pl_eIdx, in <b>integer</b> pl_fsmCtx, in &lt;EPTF_IntegerList&gt; pl_reportedArgs)</li><li>&lt;f_EPTF_LwM2M_dispatchEvent&gt;(in <b>integer</b> pl_eventIdx, in <b>integer</b> pl_eIdx, in <b>integer</b> pl_fsmCtx, in &lt;EPTF_IntegerList&gt; pl_reportedArgs)</li></ul></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_LGen_Statistics"></a>EPTF_LwM2M_LGen_Statistics</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing counters for load generator related statistics</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>incoming</td><td class=CDLDescription>&lt;EPTF_COAP_Message_Statistics&gt; - statistics of incoming messages</td></tr><tr><td class=CDLEntry>outgoing</td><td class=CDLDescription>&lt;EPTF_COAP_Message_Statistics&gt; - statistics of outgoing messages</td></tr></table></div></div></div>
 
@@ -151,84 +155,88 @@
 
 <div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_eventName_atomicBlock1Finished"></a>c_LwM2M_eventName_atomicBlock1Finished</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for indicating that a block1 transfer was finished</p></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_loadTemplate_byIntIdx"></a>c_LwM2M_stepIdx_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M loadTemplate (param: integer index) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link253 onMouseOver="ShowTip(event, 'tt106', 'link253')" onMouseOut="HideTip('tt106')">f_LwM2M_step_loadTemplate_byIntIdx</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_loadTemplate_byIntIdx"></a>c_LwM2M_stepIdx_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M loadTemplate (param: integer index) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link276 onMouseOver="ShowTip(event, 'tt110', 'link276')" onMouseOut="HideTip('tt110')">f_LwM2M_step_loadTemplate_byIntIdx</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_loadTemplate_byIntIdx"></a>c_LwM2M_stepName_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link254 onMouseOver="ShowTip(event, 'tt106', 'link254')" onMouseOut="HideTip('tt106')">f_LwM2M_step_loadTemplate_byIntIdx</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_loadTemplate_byIntIdx"></a>c_LwM2M_stepName_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link277 onMouseOver="ShowTip(event, 'tt110', 'link277')" onMouseOut="HideTip('tt110')">f_LwM2M_step_loadTemplate_byIntIdx</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_send"></a>c_LwM2M_stepIdx_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M send test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link255 onMouseOver="ShowTip(event, 'tt108', 'link255')" onMouseOut="HideTip('tt108')">f_LwM2M_step_send</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_send"></a>c_LwM2M_stepIdx_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M send test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link278 onMouseOver="ShowTip(event, 'tt112', 'link278')" onMouseOut="HideTip('tt112')">f_LwM2M_step_send</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_send"></a>c_LwM2M_stepName_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M send test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link256 onMouseOver="ShowTip(event, 'tt108', 'link256')" onMouseOut="HideTip('tt108')">f_LwM2M_step_send</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_send"></a>c_LwM2M_stepName_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M send test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=LFunction id=link279 onMouseOver="ShowTip(event, 'tt112', 'link279')" onMouseOut="HideTip('tt112')">f_LwM2M_step_send</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createDevice"></a>c_LwM2M_stepIdx_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link257 onMouseOver="ShowTip(event, 'tt109', 'link257')" onMouseOut="HideTip('tt109')">f_LwM2M_step_createDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createDevice"></a>c_LwM2M_stepIdx_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link280 onMouseOver="ShowTip(event, 'tt113', 'link280')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createDevice"></a>c_LwM2M_stepName_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link258 onMouseOver="ShowTip(event, 'tt109', 'link258')" onMouseOut="HideTip('tt109')">f_LwM2M_step_createDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createDevice"></a>c_LwM2M_stepName_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=LFunction id=link281 onMouseOver="ShowTip(event, 'tt113', 'link281')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_cleanupDevice"></a>c_LwM2M_stepIdx_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M clean up device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link259 onMouseOver="ShowTip(event, 'tt110', 'link259')" onMouseOut="HideTip('tt110')">f_LwM2M_step_cleanupDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_cleanupDevice"></a>c_LwM2M_stepIdx_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M clean up device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link282 onMouseOver="ShowTip(event, 'tt114', 'link282')" onMouseOut="HideTip('tt114')">f_LwM2M_step_cleanupDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_cleanupDevice"></a>c_LwM2M_stepName_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M clean up device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link260 onMouseOver="ShowTip(event, 'tt110', 'link260')" onMouseOut="HideTip('tt110')">f_LwM2M_step_cleanupDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_cleanupDevice"></a>c_LwM2M_stepName_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M clean up device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=LFunction id=link283 onMouseOver="ShowTip(event, 'tt114', 'link283')" onMouseOut="HideTip('tt114')">f_LwM2M_step_cleanupDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_logDevice"></a>c_LwM2M_stepIdx_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M log device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link261 onMouseOver="ShowTip(event, 'tt111', 'link261')" onMouseOut="HideTip('tt111')">f_LwM2M_step_logDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_logDevice"></a>c_LwM2M_stepIdx_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M log device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link284 onMouseOver="ShowTip(event, 'tt115', 'link284')" onMouseOut="HideTip('tt115')">f_LwM2M_step_logDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_logDevice"></a>c_LwM2M_stepName_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M log device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link262 onMouseOver="ShowTip(event, 'tt111', 'link262')" onMouseOut="HideTip('tt111')">f_LwM2M_step_logDevice</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_logDevice"></a>c_LwM2M_stepName_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M log device test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=LFunction id=link285 onMouseOver="ShowTip(event, 'tt115', 'link285')" onMouseOut="HideTip('tt115')">f_LwM2M_step_logDevice</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createObject"></a>c_LwM2M_stepIdx_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create object test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link263 onMouseOver="ShowTip(event, 'tt112', 'link263')" onMouseOut="HideTip('tt112')">f_LwM2M_step_createObject</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createObject"></a>c_LwM2M_stepIdx_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create object test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link286 onMouseOver="ShowTip(event, 'tt116', 'link286')" onMouseOut="HideTip('tt116')">f_LwM2M_step_createObject</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createObject"></a>c_LwM2M_stepName_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create object test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link264 onMouseOver="ShowTip(event, 'tt112', 'link264')" onMouseOut="HideTip('tt112')">f_LwM2M_step_createObject</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createObject"></a>c_LwM2M_stepName_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create object test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=LFunction id=link287 onMouseOver="ShowTip(event, 'tt116', 'link287')" onMouseOut="HideTip('tt116')">f_LwM2M_step_createObject</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createObjectInstance"></a>c_LwM2M_stepIdx_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create object instance test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link265 onMouseOver="ShowTip(event, 'tt113', 'link265')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createObjectInstance</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_createObjectInstance"></a>c_LwM2M_stepIdx_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M create object instance test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link288 onMouseOver="ShowTip(event, 'tt117', 'link288')" onMouseOut="HideTip('tt117')">f_LwM2M_step_createObjectInstance</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createObjectInstance"></a>c_LwM2M_stepName_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create object instance test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link266 onMouseOver="ShowTip(event, 'tt113', 'link266')" onMouseOut="HideTip('tt113')">f_LwM2M_step_createObjectInstance</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_createObjectInstance"></a>c_LwM2M_stepName_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M create object instance test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=LFunction id=link289 onMouseOver="ShowTip(event, 'tt117', 'link289')" onMouseOut="HideTip('tt117')">f_LwM2M_step_createObjectInstance</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleReadRequest"></a>c_LwM2M_stepIdx_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle READ request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link267 onMouseOver="ShowTip(event, 'tt114', 'link267')" onMouseOut="HideTip('tt114')">f_LwM2M_step_handleReadRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleReadRequest"></a>c_LwM2M_stepIdx_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle READ request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link290 onMouseOver="ShowTip(event, 'tt118', 'link290')" onMouseOut="HideTip('tt118')">f_LwM2M_step_handleReadRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleReadRequest"></a>c_LwM2M_stepName_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle READ request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link268 onMouseOver="ShowTip(event, 'tt114', 'link268')" onMouseOut="HideTip('tt114')">f_LwM2M_step_handleReadRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleReadRequest"></a>c_LwM2M_stepName_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle READ request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=LFunction id=link291 onMouseOver="ShowTip(event, 'tt118', 'link291')" onMouseOut="HideTip('tt118')">f_LwM2M_step_handleReadRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleWriteRequest"></a>c_LwM2M_stepIdx_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle WRITE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link269 onMouseOver="ShowTip(event, 'tt115', 'link269')" onMouseOut="HideTip('tt115')">f_LwM2M_step_handleWriteRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleWriteRequest"></a>c_LwM2M_stepIdx_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle WRITE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link292 onMouseOver="ShowTip(event, 'tt119', 'link292')" onMouseOut="HideTip('tt119')">f_LwM2M_step_handleWriteRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleWriteRequest"></a>c_LwM2M_stepName_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle WRITE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link270 onMouseOver="ShowTip(event, 'tt115', 'link270')" onMouseOut="HideTip('tt115')">f_LwM2M_step_handleWriteRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleWriteRequest"></a>c_LwM2M_stepName_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle WRITE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=LFunction id=link293 onMouseOver="ShowTip(event, 'tt119', 'link293')" onMouseOut="HideTip('tt119')">f_LwM2M_step_handleWriteRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleExecuteRequest"></a>c_LwM2M_stepIdx_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle EXECUTE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link271 onMouseOver="ShowTip(event, 'tt116', 'link271')" onMouseOut="HideTip('tt116')">f_LwM2M_step_handleExecuteRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_handleExecuteRequest"></a>c_LwM2M_stepIdx_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M handle EXECUTE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link294 onMouseOver="ShowTip(event, 'tt120', 'link294')" onMouseOut="HideTip('tt120')">f_LwM2M_step_handleExecuteRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleExecuteRequest"></a>c_LwM2M_stepName_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle EXECUTE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link272 onMouseOver="ShowTip(event, 'tt116', 'link272')" onMouseOut="HideTip('tt116')">f_LwM2M_step_handleExecuteRequest</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_handleExecuteRequest"></a>c_LwM2M_stepName_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M handle EXECUTE request test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=LFunction id=link295 onMouseOver="ShowTip(event, 'tt120', 'link295')" onMouseOut="HideTip('tt120')">f_LwM2M_step_handleExecuteRequest</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_loadTemplate_byStringId"></a>c_LwM2M_stepIdx_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M load template (param: string id of the template) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link273 onMouseOver="ShowTip(event, 'tt107', 'link273')" onMouseOut="HideTip('tt107')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_loadTemplate_byStringId"></a>c_LwM2M_stepIdx_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M load template (param: string id of the template) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link296 onMouseOver="ShowTip(event, 'tt111', 'link296')" onMouseOut="HideTip('tt111')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_loadTemplate_byStringId"></a>c_LwM2M_stepName_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M load template (param: string id of the template) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link274 onMouseOver="ShowTip(event, 'tt107', 'link274')" onMouseOut="HideTip('tt107')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_loadTemplate_byStringId"></a>c_LwM2M_stepName_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M load template (param: string id of the template) test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link297 onMouseOver="ShowTip(event, 'tt111', 'link297')" onMouseOut="HideTip('tt111')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_sendNotificationForObservedResources"></a>c_LwM2M_stepIdx_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M send notification for observed resources test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link275 onMouseOver="ShowTip(event, 'tt86', 'link275')" onMouseOut="HideTip('tt86')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_sendNotificationForObservedResources"></a>c_LwM2M_stepIdx_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M send notification for observed resources test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link298 onMouseOver="ShowTip(event, 'tt87', 'link298')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_sendNotificationForObservedResources"></a>c_LwM2M_stepName_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M send notification for observed resources test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link276 onMouseOver="ShowTip(event, 'tt86', 'link276')" onMouseOut="HideTip('tt86')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_sendNotificationForObservedResources"></a>c_LwM2M_stepName_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M send notification for observed resources test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link299 onMouseOver="ShowTip(event, 'tt87', 'link299')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setFirmwareUpdateState"></a>c_LwM2M_stepName_setFirmwareUpdateState</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M set firmware update state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link277 onMouseOver="ShowTip(event, 'tt87', 'link277')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setFirmwareUpdateState"></a>c_LwM2M_stepName_setFirmwareUpdateState</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M set firmware update state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link300 onMouseOver="ShowTip(event, 'tt88', 'link300')" onMouseOut="HideTip('tt88')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setFirmwareUpdateState"></a>c_LwM2M_stepName_setFirmwareUpdateState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setFirmwareUpdateState := &quot;LWM2M Applib: setFirmwareUpdateState&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set firmware update state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link278 onMouseOver="ShowTip(event, 'tt87', 'link278')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setFirmwareUpdateState"></a>c_LwM2M_stepName_setFirmwareUpdateState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setFirmwareUpdateState := &quot;LWM2M Applib: setFirmwareUpdateState&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set firmware update state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link301 onMouseOver="ShowTip(event, 'tt88', 'link301')" onMouseOut="HideTip('tt88')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
 
 <div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setFirmwareUpdateResult"></a>c_LwM2M_stepIdx_setFirmwareUpdateResult</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the LWM2M set firmware update result test step</p><h4 class=CHeading>Related Function</h4><ul><li>&lt;c_LwM2M_stepName_setFirmwareUpdateResult&gt;</li></ul></div></div></div>
 
 <div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setFirmwareUpdateState"></a>c_LwM2M_stepName_setFirmwareUpdateState</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set furmware update result test step</p><h4 class=CHeading>Related Function</h4><ul><li>&lt;c_LwM2M_stepName_setFirmwareUpdateResult&gt;</li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBootstrapState"></a>c_LwM2M_stepIdx_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set bootstrap state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=LFunction id=link279 onMouseOver="ShowTip(event, 'tt154', 'link279')" onMouseOut="HideTip('tt154')">f_LwM2M_step_setBootstrapState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBootstrapState"></a>c_LwM2M_stepIdx_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set bootstrap state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=LFunction id=link302 onMouseOver="ShowTip(event, 'tt124', 'link302')" onMouseOut="HideTip('tt124')">f_LwM2M_step_setBootstrapState</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBootstrapState"></a>c_LwM2M_stepName_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set bootstrap state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=LFunction id=link280 onMouseOver="ShowTip(event, 'tt154', 'link280')" onMouseOut="HideTip('tt154')">f_LwM2M_step_setBootstrapState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBootstrapState"></a>c_LwM2M_stepName_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set bootstrap state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=LFunction id=link303 onMouseOver="ShowTip(event, 'tt124', 'link303')" onMouseOut="HideTip('tt124')">f_LwM2M_step_setBootstrapState</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setNotRegisteredState"></a>c_LwM2M_stepIdx_setNotRegisteredState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set not registered state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=LFunction id=link281 onMouseOver="ShowTip(event, 'tt155', 'link281')" onMouseOut="HideTip('tt155')">f_LwM2M_step_setNotRegisteredState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setNotRegisteredState"></a>c_LwM2M_stepIdx_setNotRegisteredState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set not registered state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=LFunction id=link304 onMouseOver="ShowTip(event, 'tt125', 'link304')" onMouseOut="HideTip('tt125')">f_LwM2M_step_setNotRegisteredState</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBootstrapState"></a>c_LwM2M_stepName_setBootstrapState</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set not registered state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=LFunction id=link282 onMouseOver="ShowTip(event, 'tt155', 'link282')" onMouseOut="HideTip('tt155')">f_LwM2M_step_setNotRegisteredState</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBootstrapState"></a>c_LwM2M_stepName_setBootstrapState</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set not registered state test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=LFunction id=link305 onMouseOver="ShowTip(event, 'tt125', 'link305')" onMouseOut="HideTip('tt125')">f_LwM2M_step_setNotRegisteredState</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBlock1Handling_stateless"></a>c_LwM2M_stepIdx_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set block1 handling stateless test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=LFunction id=link283 onMouseOver="ShowTip(event, 'tt156', 'link283')" onMouseOut="HideTip('tt156')">f_LwM2M_step_setBlock1Handling_stateless</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBlock1Handling_stateless"></a>c_LwM2M_stepIdx_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set block1 handling stateless test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=LFunction id=link306 onMouseOver="ShowTip(event, 'tt126', 'link306')" onMouseOut="HideTip('tt126')">f_LwM2M_step_setBlock1Handling_stateless</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBlock1Handling_stateless"></a>c_LwM2M_stepName_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set block1 handling stateless test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=LFunction id=link284 onMouseOver="ShowTip(event, 'tt156', 'link284')" onMouseOut="HideTip('tt156')">f_LwM2M_step_setBlock1Handling_stateless</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBlock1Handling_stateless"></a>c_LwM2M_stepName_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set block1 handling stateless test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=LFunction id=link307 onMouseOver="ShowTip(event, 'tt126', 'link307')" onMouseOut="HideTip('tt126')">f_LwM2M_step_setBlock1Handling_stateless</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBlock1Handling_atomic"></a>c_LwM2M_stepIdx_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set block1 handling atomic test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=LFunction id=link285 onMouseOver="ShowTip(event, 'tt157', 'link285')" onMouseOut="HideTip('tt157')">f_LwM2M_step_setBlock1Handling_atomic</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setBlock1Handling_atomic"></a>c_LwM2M_stepIdx_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for the  LWM2M set block1 handling atomic test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=LFunction id=link308 onMouseOver="ShowTip(event, 'tt127', 'link308')" onMouseOut="HideTip('tt127')">f_LwM2M_step_setBlock1Handling_atomic</a></li></ul></div></div></div>
 
-<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBlock1Handling_atomic"></a>c_LwM2M_stepName_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set block1 handling atomic test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=LFunction id=link286 onMouseOver="ShowTip(event, 'tt157', 'link286')" onMouseOut="HideTip('tt157')">f_LwM2M_step_setBlock1Handling_atomic</a></li></ul></div></div></div>
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setBlock1Handling_atomic"></a>c_LwM2M_stepName_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the LWM2M set block1 handling atomic test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=LFunction id=link309 onMouseOver="ShowTip(event, 'tt127', 'link309')" onMouseOut="HideTip('tt127')">f_LwM2M_step_setBlock1Handling_atomic</a></li></ul></div></div></div>
+
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepIdx_setContentFormats"></a>c_LwM2M_stepIdx_setContentFormats</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setContentFormats := 18</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Integer constant for setting the preferred content formats</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" class=LFunction id=link310 onMouseOver="ShowTip(event, 'tt128', 'link310')" onMouseOut="HideTip('tt128')">f_LwM2M_step_setContentFormats</a></li></ul></div></div></div>
+
+<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_LwM2M_stepName_setContentFormats"></a>c_LwM2M_stepName_setContentFormats</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setContentFormats := &quot;LWM2M Applib: setContentFormats&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for setting the preferred content format</p><h4 class=CHeading>Related Function</h4><ul><li><a href="EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" class=LFunction id=link311 onMouseOver="ShowTip(event, 'tt128', 'link311')" onMouseOut="HideTip('tt128')">f_LwM2M_step_setContentFormats</a></li></ul></div></div></div>
 
 </div><!--Content-->
 
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><div class=CToolTip id="tt10"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt12"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote>Storing counters for load generator related statistics</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt84"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt85"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt86"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt87"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setFirmwareUpdateState := &quot;LWM2M Applib: setFirmwareUpdateState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set firmware update state test step</div></div><div class=CToolTip id="tt88"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt89"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt90"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt91"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt92"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt93"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt94"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt95"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt96"><div class=CFile>This module contains the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt97"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><div class=CToolTip id="tt98"><div class=CFile>This module contains type definitions for LWM2M PDUs</div></div><div class=CToolTip id="tt99"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt100"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt101"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt102"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt103"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><div class=CToolTip id="tt104"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt105"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt106"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt107"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt108"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt109"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt110"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt111"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt112"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt113"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt114"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt115"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt116"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt117"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt118"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt119"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt120"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt121"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt122"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt123"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt124"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt125"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt126"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt127"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt128"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt129"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt130"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt131"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt132"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt133"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt134"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt135"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt136"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt137"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt138"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt139"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt140"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt141"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt142"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt143"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt144"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt145"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt146"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt147"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt148"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt149"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt150"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt151"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt152"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt153"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt154"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt155"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt156"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt157"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_Format_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt10"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt12"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote>Storing counters for load generator related statistics</div></div><div class=CToolTip id="tt15"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt84"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt85"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt86"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt87"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt88"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setFirmwareUpdateState := &quot;LWM2M Applib: setFirmwareUpdateState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set firmware update state test step</div></div><div class=CToolTip id="tt89"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt90"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt91"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt92"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt93"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt94"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt95"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt96"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt97"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setContentFormats := 18</td></tr></table></blockquote>Integer constant for setting the preferred content formats</div></div><div class=CToolTip id="tt98"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setContentFormats := &quot;LWM2M Applib: setContentFormats&quot;</td></tr></table></blockquote>Charstring constant for setting the preferred content format</div></div><div class=CToolTip id="tt99"><div class=CFile>This module contains the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt100"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><div class=CToolTip id="tt101"><div class=CFile>This module contains type definitions for LWM2M PDUs</div></div><div class=CToolTip id="tt102"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt103"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt104"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt105"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt106"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><div class=CToolTip id="tt107"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt108"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt109"><div class=CModuleParameter>Setting the default content format code for encoding LwM2M payload</div></div><div class=CToolTip id="tt110"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt111"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt112"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt113"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt114"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt115"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt116"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt117"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt118"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt119"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt120"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt121"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt122"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt123"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt124"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt125"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to NOT_REGISTERED.</div></div><div class=CToolTip id="tt126"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt127"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt128"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setContentFormats(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the preferred encoding content format for a LwM2M_Device</div></div><div class=CToolTip id="tt129"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt130"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt131"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt132"><div class=CType>Block1 handling strategy of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt133"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt134"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt135"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt136"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt137"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt138"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt139"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt140"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt141"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt142"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt143"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt144"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt145"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt146"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt147"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt148"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt149"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt150"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt151"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt152"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt153"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt154"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt155"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt156"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt157"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt158"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt159"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt160"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt161"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt162"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt163"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt164"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt165"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><!--END_ND_TOOLTIPS-->
 
 <script language=JavaScript><!--
 if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/EPTF_LwM2M_LGen_Functions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_LGen_Functions-ttcn.html
index 291da64..a9e95e2 100644
--- a/apidoc/html/files/EPTF_LwM2M_LGen_Functions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_LGen_Functions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_LGen_Functions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_LGen_Functions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -9,128 +9,136 @@
 
 
 
-<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_LGen_Functions"></a>EPTF_LwM2M_LGen_Functions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the functions of the LWM2M load generator component</p><h4 class=CHeading>See also</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=LFile id=link112 onMouseOver="ShowTip(event, 'tt75', 'link112')" onMouseOut="HideTip('tt75')">EPTF_LwM2M_LGen_Definitions</a></p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Functions" >EPTF_LwM2M_LGen_Functions</a></td><td class=SDescription>This module contains the functions of the LWM2M load generator component</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_init" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">f_EPTF_LwM2M_LGen_init</a></td><td class=SDescription>The main initialization function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_initLogging" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">f_EPTF_LwM2M_LGen_initLogging</a></td><td class=SDescription>Initializing CLL&rsquo;s logging feature on the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_cleanUp" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">f_LwM2M_cleanUp</a></td><td class=SDescription>The main clean up function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link6 onMouseOver="ShowTip(event, 'tt2', 'link6')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_eCtxBind" id=link7 onMouseOver="ShowTip(event, 'tt5', 'link7')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a></td><td class=SDescription>This function is called by the CLL for each entity instance created on a particular instace of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link8 onMouseOver="ShowTip(event, 'tt2', 'link8')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> The function will allocate and initialize an instance of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link9 onMouseOver="ShowTip(event, 'tt6', 'link9')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link10 onMouseOver="ShowTip(event, 'tt7', 'link10')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_eCtxUnbind" id=link11 onMouseOver="ShowTip(event, 'tt8', 'link11')" onMouseOut="HideTip('tt8')">f_LwM2M_eCtxUnbind</a></td><td class=SDescription>The reverse operation of <a href="#f_LwM2M_eCtxBind" class=LFunction id=link12 onMouseOver="ShowTip(event, 'tt5', 'link12')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_eCtxReset" id=link13 onMouseOver="ShowTip(event, 'tt9', 'link13')" onMouseOut="HideTip('tt9')">f_LwM2M_eCtxReset</a></td><td class=SDescription>The resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link14 onMouseOver="ShowTip(event, 'tt5', 'link14')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a> are reinitalized (reset). </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_EntityCtxDB_init" id=link15 onMouseOver="ShowTip(event, 'tt10', 'link15')" onMouseOut="HideTip('tt10')">f_EPTF_LwM2M_EntityCtxDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link16 onMouseOver="ShowTip(event, 'tt7', 'link16')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link17 onMouseOver="ShowTip(event, 'tt11', 'link17')" onMouseOut="HideTip('tt11')">f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link18 onMouseOver="ShowTip(event, 'tt7', 'link18')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_init" id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">f_EPTF_LwM2M_DeviceDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link20 onMouseOver="ShowTip(event, 'tt13', 'link20')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_add" id=link21 onMouseOver="ShowTip(event, 'tt14', 'link21')" onMouseOut="HideTip('tt14')">f_EPTF_LwM2M_DeviceDB_add</a></td><td class=SDescription>Adds a new element to the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link22 onMouseOver="ShowTip(event, 'tt13', 'link22')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_remove" id=link23 onMouseOver="ShowTip(event, 'tt15', 'link23')" onMouseOut="HideTip('tt15')">f_EPTF_LwM2M_DeviceDB_remove</a></td><td class=SDescription>Removes an element from the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link24 onMouseOver="ShowTip(event, 'tt13', 'link24')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database and frees up its reserved resources</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link25 onMouseOver="ShowTip(event, 'tt16', 'link25')" onMouseOut="HideTip('tt16')">f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td><td class=SDescription>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link26 onMouseOver="ShowTip(event, 'tt13', 'link26')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_locationHash" id=link27 onMouseOver="ShowTip(event, 'tt17', 'link27')" onMouseOut="HideTip('tt17')">f_EPTF_LwM2M_DeviceDB_locationHash</a></td><td class=SDescription>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link28 onMouseOver="ShowTip(event, 'tt13', 'link28')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link29 onMouseOver="ShowTip(event, 'tt18', 'link29')" onMouseOut="HideTip('tt18')">f_EPTF_LwM2M_DeviceDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link30 onMouseOver="ShowTip(event, 'tt13', 'link30')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_init" id=link31 onMouseOver="ShowTip(event, 'tt19', 'link31')" onMouseOut="HideTip('tt19')">f_EPTF_LwM2M_TemplateDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link32 onMouseOver="ShowTip(event, 'tt20', 'link32')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database by adding the templates given in <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link33 onMouseOver="ShowTip(event, 'tt21', 'link33')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_add" id=link34 onMouseOver="ShowTip(event, 'tt22', 'link34')" onMouseOut="HideTip('tt22')">f_EPTF_LwM2M_TemplateDB_add</a></td><td class=SDescription>Adds a new element to the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link35 onMouseOver="ShowTip(event, 'tt20', 'link35')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_lookUp" id=link36 onMouseOver="ShowTip(event, 'tt23', 'link36')" onMouseOut="HideTip('tt23')">f_EPTF_LwM2M_TemplateDB_lookUp</a></td><td class=SDescription>Gets the index of an <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link37 onMouseOver="ShowTip(event, 'tt24', 'link37')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> element in <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt20', 'link38')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_get" id=link39 onMouseOver="ShowTip(event, 'tt25', 'link39')" onMouseOut="HideTip('tt25')">f_EPTF_LwM2M_TemplateDB_get</a></td><td class=SDescription>Retrieves an element from the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link40 onMouseOver="ShowTip(event, 'tt20', 'link40')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link41 onMouseOver="ShowTip(event, 'tt26', 'link41')" onMouseOut="HideTip('tt26')">f_EPTF_LwM2M_TemplateDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link42 onMouseOver="ShowTip(event, 'tt20', 'link42')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_VERBOSE" id=link43 onMouseOver="ShowTip(event, 'tt27', 'link43')" onMouseOut="HideTip('tt27')">f_EPTF_LwM2M_Logging_VERBOSE</a></td><td class=SDescription>Logging functions for the VERBOSE log level</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_DEBUG" id=link44 onMouseOver="ShowTip(event, 'tt28', 'link44')" onMouseOut="HideTip('tt28')">f_EPTF_LwM2M_Logging_DEBUG</a></td><td class=SDescription>Logging functions for the DEBUG log level</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_WARNING" id=link45 onMouseOver="ShowTip(event, 'tt29', 'link45')" onMouseOut="HideTip('tt29')">f_EPTF_LwM2M_Logging_WARNING</a></td><td class=SDescription>Logging functions for the WARNING log level</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_ERROR" id=link46 onMouseOver="ShowTip(event, 'tt30', 'link46')" onMouseOut="HideTip('tt30')">f_EPTF_LwM2M_Logging_ERROR</a></td><td class=SDescription>Logging functions for the ERROR log level</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_receiveMessage" id=link47 onMouseOver="ShowTip(event, 'tt31', 'link47')" onMouseOut="HideTip('tt31')">f_EPTF_LwM2M_LGen_receiveMessage</a></td><td class=SDescription>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link48 onMouseOver="ShowTip(event, 'tt32', 'link48')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link49 onMouseOver="ShowTip(event, 'tt33', 'link49')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> message to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link50 onMouseOver="ShowTip(event, 'tt34', 'link50')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link51 onMouseOver="ShowTip(event, 'tt2', 'link51')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_receiveEvent" id=link52 onMouseOver="ShowTip(event, 'tt35', 'link52')" onMouseOut="HideTip('tt35')">f_EPTF_LwM2M_LGen_receiveEvent</a></td><td class=SDescription>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link53 onMouseOver="ShowTip(event, 'tt32', 'link53')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link54 onMouseOver="ShowTip(event, 'tt36', 'link54')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> events to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link55 onMouseOver="ShowTip(event, 'tt34', 'link55')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link56 onMouseOver="ShowTip(event, 'tt2', 'link56')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_isBootstrap" id=link57 onMouseOver="ShowTip(event, 'tt37', 'link57')" onMouseOut="HideTip('tt37')">f_EPTF_LwM2M_LGen_isBootstrap</a></td><td class=SDescription>Sets p_isBootstrap true if the device is in bootstrapping state.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_declareEvents" id=link58 onMouseOver="ShowTip(event, 'tt38', 'link58')" onMouseOut="HideTip('tt38')">f_EPTF_LwM2M_declareEvents</a></td><td class=SDescription>Declares the FSM events to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link59 onMouseOver="ShowTip(event, 'tt2', 'link59')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_declareSteps" id=link60 onMouseOver="ShowTip(event, 'tt39', 'link60')" onMouseOut="HideTip('tt39')">f_EPTF_LwM2M_declareSteps</a></td><td class=SDescription>Declares the FSM steps to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link61 onMouseOver="ShowTip(event, 'tt2', 'link61')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_loadTemplate_byIntIdx" id=link62 onMouseOver="ShowTip(event, 'tt40', 'link62')" onMouseOut="HideTip('tt40')">f_LwM2M_step_loadTemplate_byIntIdx</a></td><td class=SDescription>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link63 onMouseOver="ShowTip(event, 'tt24', 'link63')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link64 onMouseOver="ShowTip(event, 'tt21', 'link64')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_loadTemplate_byStringId" id=link65 onMouseOver="ShowTip(event, 'tt41', 'link65')" onMouseOut="HideTip('tt41')">f_LwM2M_step_loadTemplate_byStringId</a></td><td class=SDescription>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link66 onMouseOver="ShowTip(event, 'tt24', 'link66')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link67 onMouseOver="ShowTip(event, 'tt21', 'link67')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_send" id=link68 onMouseOver="ShowTip(event, 'tt42', 'link68')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></td><td class=SDescription>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_createDevice" id=link69 onMouseOver="ShowTip(event, 'tt43', 'link69')" onMouseOut="HideTip('tt43')">f_LwM2M_step_createDevice</a></td><td class=SDescription>Test Step to dynamically allocate and initialize a simulated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link70 onMouseOver="ShowTip(event, 'tt44', 'link70')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and associate it to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link71 onMouseOver="ShowTip(event, 'tt6', 'link71')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a>. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_cleanupDevice" id=link72 onMouseOver="ShowTip(event, 'tt45', 'link72')" onMouseOut="HideTip('tt45')">f_LwM2M_step_cleanupDevice</a></td><td class=SDescription>Test Step to free up the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link73 onMouseOver="ShowTip(event, 'tt6', 'link73')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> for the caller entity. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_logDevice" id=link74 onMouseOver="ShowTip(event, 'tt46', 'link74')" onMouseOut="HideTip('tt46')">f_LwM2M_step_logDevice</a></td><td class=SDescription>Test Step to log the contents of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link75 onMouseOver="ShowTip(event, 'tt44', 'link75')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> associated to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link76 onMouseOver="ShowTip(event, 'tt6', 'link76')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setBootstrapState" id=link77 onMouseOver="ShowTip(event, 'tt47', 'link77')" onMouseOut="HideTip('tt47')">f_LwM2M_step_setBootstrapState</a></td><td class=SDescription>Test Step to set the state of the device to BOOTSTRAPPING. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setBlock1Handling_stateless" id=link78 onMouseOver="ShowTip(event, 'tt48', 'link78')" onMouseOut="HideTip('tt48')">f_LwM2M_step_setBlock1Handling_stateless</a></td><td class=SDescription>Test Step to set the block1 handling strategy of the device to stateless</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setBlock1Handling_atomic" id=link79 onMouseOver="ShowTip(event, 'tt49', 'link79')" onMouseOut="HideTip('tt49')">f_LwM2M_step_setBlock1Handling_atomic</a></td><td class=SDescription>Test Step to set the block1 handling strategy of the device to atomic</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setNotRegisteredState" id=link80 onMouseOver="ShowTip(event, 'tt50', 'link80')" onMouseOut="HideTip('tt50')">f_LwM2M_step_setNotRegisteredState</a></td><td class=SDescription>Test Step to set the state of the device to BOOTSTRAPPING. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_writeOrCreateObject_BS" id=link81 onMouseOver="ShowTip(event, 'tt51', 'link81')" onMouseOut="HideTip('tt51')">f_LwM2M_step_writeOrCreateObject_BS</a></td><td class=SDescription>Test Step to handling the bootstrap write messge.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_createObject" id=link82 onMouseOver="ShowTip(event, 'tt52', 'link82')" onMouseOut="HideTip('tt52')">f_LwM2M_step_createObject</a></td><td class=SDescription>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link83 onMouseOver="ShowTip(event, 'tt53', 'link83')" onMouseOut="HideTip('tt53')">LwM2M_Object</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link84 onMouseOver="ShowTip(event, 'tt44', 'link84')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_createObjectInstance" id=link85 onMouseOver="ShowTip(event, 'tt54', 'link85')" onMouseOut="HideTip('tt54')">f_LwM2M_step_createObjectInstance</a></td><td class=SDescription>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link86 onMouseOver="ShowTip(event, 'tt55', 'link86')" onMouseOut="HideTip('tt55')">LwM2M_ObjectInstance</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link87 onMouseOver="ShowTip(event, 'tt44', 'link87')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> the instance will also created the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link88 onMouseOver="ShowTip(event, 'tt56', 'link88')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> instances according to the object instance&rsquo;s <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link89 onMouseOver="ShowTip(event, 'tt57', 'link89')" onMouseOut="HideTip('tt57')">LwM2M_ObjectSpecification</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_handleReadRequest" id=link90 onMouseOver="ShowTip(event, 'tt58', 'link90')" onMouseOut="HideTip('tt58')">f_LwM2M_step_handleReadRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M READ request. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_handleWriteRequest" id=link91 onMouseOver="ShowTip(event, 'tt59', 'link91')" onMouseOut="HideTip('tt59')">f_LwM2M_step_handleWriteRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_handleExecuteRequest" id=link92 onMouseOver="ShowTip(event, 'tt60', 'link92')" onMouseOut="HideTip('tt60')">f_LwM2M_step_handleExecuteRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_sendNotificationForObservedResources" id=link93 onMouseOver="ShowTip(event, 'tt61', 'link93')" onMouseOut="HideTip('tt61')">f_LwM2M_step_sendNotificationForObservedResources</a></td><td class=SDescription>The test step will iterate through the observed resources of the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link94 onMouseOver="ShowTip(event, 'tt44', 'link94')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and creates and sends a NOTIFICATION for each.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setFirmwareUpdateState" id=link95 onMouseOver="ShowTip(event, 'tt62', 'link95')" onMouseOut="HideTip('tt62')">f_LwM2M_step_setFirmwareUpdateState</a></td><td class=SDescription>The test step will set the firmware update state resource value.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setFirmwareUpdateResult" id=link96 onMouseOver="ShowTip(event, 'tt63', 'link96')" onMouseOut="HideTip('tt63')">f_LwM2M_step_setFirmwareUpdateResult</a></td><td class=SDescription>The test step will set the firmware update result resource value.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_setStepCtx" id=link97 onMouseOver="ShowTip(event, 'tt64', 'link97')" onMouseOut="HideTip('tt64')">f_EPTF_LwM2M_setStepCtx</a></td><td class=SDescription>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link98 onMouseOver="ShowTip(event, 'tt65', 'link98')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_setCtx" id=link99 onMouseOver="ShowTip(event, 'tt66', 'link99')" onMouseOut="HideTip('tt66')">f_EPTF_LwM2M_setCtx</a></td><td class=SDescription>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link100 onMouseOver="ShowTip(event, 'tt65', 'link100')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_hasDevice" id=link101 onMouseOver="ShowTip(event, 'tt67', 'link101')" onMouseOut="HideTip('tt67')">f_EPTF_LwM2M_hasDevice</a></td><td class=SDescription>Checks if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link102 onMouseOver="ShowTip(event, 'tt6', 'link102')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> instance of the actual entity has an associated device or not</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_stack_fromApp" id=link103 onMouseOver="ShowTip(event, 'tt68', 'link103')" onMouseOut="HideTip('tt68')">f_EPTF_LwM2M_stack_fromApp</a></td><td class=SDescription>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link104 onMouseOver="ShowTip(event, 'tt2', 'link104')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the application layer (e.g. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_stack_fromEnv" id=link105 onMouseOver="ShowTip(event, 'tt69', 'link105')" onMouseOut="HideTip('tt69')">f_EPTF_LwM2M_stack_fromEnv</a></td><td class=SDescription>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link106 onMouseOver="ShowTip(event, 'tt2', 'link106')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the environment layer (e.g. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_dispatchEventsForPDU" id=link107 onMouseOver="ShowTip(event, 'tt70', 'link107')" onMouseOut="HideTip('tt70')">f_EPTF_LwM2M_dispatchEventsForPDU</a></td><td class=SDescription>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_sendNotificationForResource" id=link108 onMouseOver="ShowTip(event, 'tt71', 'link108')" onMouseOut="HideTip('tt71')">f_EPTF_LwM2M_sendNotificationForResource</a></td><td class=SDescription>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_PduToEventIdx" id=link109 onMouseOver="ShowTip(event, 'tt72', 'link109')" onMouseOut="HideTip('tt72')">f_EPTF_LwM2M_PduToEventIdx</a></td><td class=SDescription>Maps a &lt;LWM2M_PDU&gt; to an event id (integer number) that represents the PDU&rsquo;s type</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_dispatchEvent" id=link110 onMouseOver="ShowTip(event, 'tt73', 'link110')" onMouseOut="HideTip('tt73')">f_EPTF_LwM2M_dispatchEvent</a></td><td class=SDescription>Wrapper for CLL&rsquo;s &lt;f_EPTF_LGenBase_postEvent&gt; to handle multi level event (generic, entity, FSM) reporting</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_getIntValue" id=link111 onMouseOver="ShowTip(event, 'tt74', 'link111')" onMouseOut="HideTip('tt74')">f_EPTF_LwM2M_getIntValue</a></td><td class=SDescription>Retreives an element of an &lt;EPTF_IntegerList&gt; if it exists</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_LGen_Functions"></a>EPTF_LwM2M_LGen_Functions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the functions of the LWM2M load generator component</p><h4 class=CHeading>See also</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=LFile id=link117 onMouseOver="ShowTip(event, 'tt79', 'link117')" onMouseOut="HideTip('tt79')">EPTF_LwM2M_LGen_Definitions</a></p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_LGen_Functions" >EPTF_LwM2M_LGen_Functions</a></td><td class=SDescription>This module contains the functions of the LWM2M load generator component</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_init" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">f_EPTF_LwM2M_LGen_init</a></td><td class=SDescription>The main initialization function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_initLogging" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">f_EPTF_LwM2M_LGen_initLogging</a></td><td class=SDescription>Initializing CLL&rsquo;s logging feature on the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_cleanUp" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">f_LwM2M_cleanUp</a></td><td class=SDescription>The main clean up function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link6 onMouseOver="ShowTip(event, 'tt2', 'link6')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_eCtxBind" id=link7 onMouseOver="ShowTip(event, 'tt5', 'link7')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a></td><td class=SDescription>This function is called by the CLL for each entity instance created on a particular instace of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link8 onMouseOver="ShowTip(event, 'tt2', 'link8')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> The function will allocate and initialize an instance of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link9 onMouseOver="ShowTip(event, 'tt6', 'link9')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link10 onMouseOver="ShowTip(event, 'tt7', 'link10')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_eCtxUnbind" id=link11 onMouseOver="ShowTip(event, 'tt8', 'link11')" onMouseOut="HideTip('tt8')">f_LwM2M_eCtxUnbind</a></td><td class=SDescription>The reverse operation of <a href="#f_LwM2M_eCtxBind" class=LFunction id=link12 onMouseOver="ShowTip(event, 'tt5', 'link12')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_eCtxReset" id=link13 onMouseOver="ShowTip(event, 'tt9', 'link13')" onMouseOut="HideTip('tt9')">f_LwM2M_eCtxReset</a></td><td class=SDescription>The resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link14 onMouseOver="ShowTip(event, 'tt5', 'link14')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a> are reinitalized (reset). </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_EntityCtxDB_init" id=link15 onMouseOver="ShowTip(event, 'tt10', 'link15')" onMouseOut="HideTip('tt10')">f_EPTF_LwM2M_EntityCtxDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link16 onMouseOver="ShowTip(event, 'tt7', 'link16')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link17 onMouseOver="ShowTip(event, 'tt11', 'link17')" onMouseOut="HideTip('tt11')">f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link18 onMouseOver="ShowTip(event, 'tt7', 'link18')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_init" id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">f_EPTF_LwM2M_DeviceDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link20 onMouseOver="ShowTip(event, 'tt13', 'link20')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_add" id=link21 onMouseOver="ShowTip(event, 'tt14', 'link21')" onMouseOut="HideTip('tt14')">f_EPTF_LwM2M_DeviceDB_add</a></td><td class=SDescription>Adds a new element to the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link22 onMouseOver="ShowTip(event, 'tt13', 'link22')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_remove" id=link23 onMouseOver="ShowTip(event, 'tt15', 'link23')" onMouseOut="HideTip('tt15')">f_EPTF_LwM2M_DeviceDB_remove</a></td><td class=SDescription>Removes an element from the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link24 onMouseOver="ShowTip(event, 'tt13', 'link24')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database and frees up its reserved resources</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link25 onMouseOver="ShowTip(event, 'tt16', 'link25')" onMouseOut="HideTip('tt16')">f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td><td class=SDescription>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link26 onMouseOver="ShowTip(event, 'tt13', 'link26')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_locationHash" id=link27 onMouseOver="ShowTip(event, 'tt17', 'link27')" onMouseOut="HideTip('tt17')">f_EPTF_LwM2M_DeviceDB_locationHash</a></td><td class=SDescription>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link28 onMouseOver="ShowTip(event, 'tt13', 'link28')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link29 onMouseOver="ShowTip(event, 'tt18', 'link29')" onMouseOut="HideTip('tt18')">f_EPTF_LwM2M_DeviceDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link30 onMouseOver="ShowTip(event, 'tt13', 'link30')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_init" id=link31 onMouseOver="ShowTip(event, 'tt19', 'link31')" onMouseOut="HideTip('tt19')">f_EPTF_LwM2M_TemplateDB_init</a></td><td class=SDescription>Initializes the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link32 onMouseOver="ShowTip(event, 'tt20', 'link32')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database by adding the templates given in <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link33 onMouseOver="ShowTip(event, 'tt21', 'link33')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_add" id=link34 onMouseOver="ShowTip(event, 'tt22', 'link34')" onMouseOut="HideTip('tt22')">f_EPTF_LwM2M_TemplateDB_add</a></td><td class=SDescription>Adds a new element to the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link35 onMouseOver="ShowTip(event, 'tt20', 'link35')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_lookUp" id=link36 onMouseOver="ShowTip(event, 'tt23', 'link36')" onMouseOut="HideTip('tt23')">f_EPTF_LwM2M_TemplateDB_lookUp</a></td><td class=SDescription>Gets the index of an <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link37 onMouseOver="ShowTip(event, 'tt24', 'link37')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> element in <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt20', 'link38')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_get" id=link39 onMouseOver="ShowTip(event, 'tt25', 'link39')" onMouseOut="HideTip('tt25')">f_EPTF_LwM2M_TemplateDB_get</a></td><td class=SDescription>Retrieves an element from the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link40 onMouseOver="ShowTip(event, 'tt20', 'link40')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link41 onMouseOver="ShowTip(event, 'tt26', 'link41')" onMouseOut="HideTip('tt26')">f_EPTF_LwM2M_TemplateDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link42 onMouseOver="ShowTip(event, 'tt20', 'link42')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_VERBOSE" id=link43 onMouseOver="ShowTip(event, 'tt27', 'link43')" onMouseOut="HideTip('tt27')">f_EPTF_LwM2M_Logging_VERBOSE</a></td><td class=SDescription>Logging functions for the VERBOSE log level</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_DEBUG" id=link44 onMouseOver="ShowTip(event, 'tt28', 'link44')" onMouseOut="HideTip('tt28')">f_EPTF_LwM2M_Logging_DEBUG</a></td><td class=SDescription>Logging functions for the DEBUG log level</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_WARNING" id=link45 onMouseOver="ShowTip(event, 'tt29', 'link45')" onMouseOut="HideTip('tt29')">f_EPTF_LwM2M_Logging_WARNING</a></td><td class=SDescription>Logging functions for the WARNING log level</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_Logging_ERROR" id=link46 onMouseOver="ShowTip(event, 'tt30', 'link46')" onMouseOut="HideTip('tt30')">f_EPTF_LwM2M_Logging_ERROR</a></td><td class=SDescription>Logging functions for the ERROR log level</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_receiveMessage" id=link47 onMouseOver="ShowTip(event, 'tt31', 'link47')" onMouseOut="HideTip('tt31')">f_EPTF_LwM2M_LGen_receiveMessage</a></td><td class=SDescription>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link48 onMouseOver="ShowTip(event, 'tt32', 'link48')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link49 onMouseOver="ShowTip(event, 'tt33', 'link49')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> message to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link50 onMouseOver="ShowTip(event, 'tt34', 'link50')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link51 onMouseOver="ShowTip(event, 'tt2', 'link51')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_receiveEvent" id=link52 onMouseOver="ShowTip(event, 'tt35', 'link52')" onMouseOut="HideTip('tt35')">f_EPTF_LwM2M_LGen_receiveEvent</a></td><td class=SDescription>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link53 onMouseOver="ShowTip(event, 'tt32', 'link53')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link54 onMouseOver="ShowTip(event, 'tt36', 'link54')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> events to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link55 onMouseOver="ShowTip(event, 'tt34', 'link55')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link56 onMouseOver="ShowTip(event, 'tt2', 'link56')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_LGen_isBootstrap" id=link57 onMouseOver="ShowTip(event, 'tt37', 'link57')" onMouseOut="HideTip('tt37')">f_EPTF_LwM2M_LGen_isBootstrap</a></td><td class=SDescription>Sets p_isBootstrap true if the device is in bootstrapping state.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_declareEvents" id=link58 onMouseOver="ShowTip(event, 'tt38', 'link58')" onMouseOut="HideTip('tt38')">f_EPTF_LwM2M_declareEvents</a></td><td class=SDescription>Declares the FSM events to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link59 onMouseOver="ShowTip(event, 'tt2', 'link59')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_declareSteps" id=link60 onMouseOver="ShowTip(event, 'tt39', 'link60')" onMouseOut="HideTip('tt39')">f_EPTF_LwM2M_declareSteps</a></td><td class=SDescription>Declares the FSM steps to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link61 onMouseOver="ShowTip(event, 'tt2', 'link61')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_loadTemplate_byIntIdx" id=link62 onMouseOver="ShowTip(event, 'tt40', 'link62')" onMouseOut="HideTip('tt40')">f_LwM2M_step_loadTemplate_byIntIdx</a></td><td class=SDescription>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link63 onMouseOver="ShowTip(event, 'tt24', 'link63')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link64 onMouseOver="ShowTip(event, 'tt21', 'link64')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_loadTemplate_byStringId" id=link65 onMouseOver="ShowTip(event, 'tt41', 'link65')" onMouseOut="HideTip('tt41')">f_LwM2M_step_loadTemplate_byStringId</a></td><td class=SDescription>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link66 onMouseOver="ShowTip(event, 'tt24', 'link66')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link67 onMouseOver="ShowTip(event, 'tt21', 'link67')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_send" id=link68 onMouseOver="ShowTip(event, 'tt42', 'link68')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></td><td class=SDescription>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_createDevice" id=link69 onMouseOver="ShowTip(event, 'tt43', 'link69')" onMouseOut="HideTip('tt43')">f_LwM2M_step_createDevice</a></td><td class=SDescription>Test Step to dynamically allocate and initialize a simulated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link70 onMouseOver="ShowTip(event, 'tt44', 'link70')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and associate it to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link71 onMouseOver="ShowTip(event, 'tt6', 'link71')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a>. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_cleanupDevice" id=link72 onMouseOver="ShowTip(event, 'tt45', 'link72')" onMouseOut="HideTip('tt45')">f_LwM2M_step_cleanupDevice</a></td><td class=SDescription>Test Step to free up the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link73 onMouseOver="ShowTip(event, 'tt6', 'link73')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> for the caller entity. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_logDevice" id=link74 onMouseOver="ShowTip(event, 'tt46', 'link74')" onMouseOut="HideTip('tt46')">f_LwM2M_step_logDevice</a></td><td class=SDescription>Test Step to log the contents of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link75 onMouseOver="ShowTip(event, 'tt44', 'link75')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> associated to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link76 onMouseOver="ShowTip(event, 'tt6', 'link76')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setBootstrapState" id=link77 onMouseOver="ShowTip(event, 'tt47', 'link77')" onMouseOut="HideTip('tt47')">f_LwM2M_step_setBootstrapState</a></td><td class=SDescription>Test Step to set the state of the device to BOOTSTRAPPING. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setBlock1Handling_stateless" id=link78 onMouseOver="ShowTip(event, 'tt48', 'link78')" onMouseOut="HideTip('tt48')">f_LwM2M_step_setBlock1Handling_stateless</a></td><td class=SDescription>Test Step to set the block1 handling strategy of the device to stateless</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setBlock1Handling_atomic" id=link79 onMouseOver="ShowTip(event, 'tt49', 'link79')" onMouseOut="HideTip('tt49')">f_LwM2M_step_setBlock1Handling_atomic</a></td><td class=SDescription>Test Step to set the block1 handling strategy of the device to atomic</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setNotRegisteredState" id=link80 onMouseOver="ShowTip(event, 'tt50', 'link80')" onMouseOut="HideTip('tt50')">f_LwM2M_step_setNotRegisteredState</a></td><td class=SDescription>Test Step to set the state of the device to NOT_REGISTERED.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_writeOrCreateObject_BS" id=link81 onMouseOver="ShowTip(event, 'tt51', 'link81')" onMouseOut="HideTip('tt51')">f_LwM2M_step_writeOrCreateObject_BS</a></td><td class=SDescription>Test Step to handling the bootstrap write messge.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_createObject" id=link82 onMouseOver="ShowTip(event, 'tt52', 'link82')" onMouseOut="HideTip('tt52')">f_LwM2M_step_createObject</a></td><td class=SDescription>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link83 onMouseOver="ShowTip(event, 'tt53', 'link83')" onMouseOut="HideTip('tt53')">LwM2M_Object</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link84 onMouseOver="ShowTip(event, 'tt44', 'link84')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_createObjectInstance" id=link85 onMouseOver="ShowTip(event, 'tt54', 'link85')" onMouseOut="HideTip('tt54')">f_LwM2M_step_createObjectInstance</a></td><td class=SDescription>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link86 onMouseOver="ShowTip(event, 'tt55', 'link86')" onMouseOut="HideTip('tt55')">LwM2M_ObjectInstance</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link87 onMouseOver="ShowTip(event, 'tt44', 'link87')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> the instance will also created the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link88 onMouseOver="ShowTip(event, 'tt56', 'link88')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> instances according to the object instance&rsquo;s <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link89 onMouseOver="ShowTip(event, 'tt57', 'link89')" onMouseOut="HideTip('tt57')">LwM2M_ObjectSpecification</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_handleReadRequest" id=link90 onMouseOver="ShowTip(event, 'tt58', 'link90')" onMouseOut="HideTip('tt58')">f_LwM2M_step_handleReadRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M READ request. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_handleWriteRequest" id=link91 onMouseOver="ShowTip(event, 'tt59', 'link91')" onMouseOut="HideTip('tt59')">f_LwM2M_step_handleWriteRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_handleExecuteRequest" id=link92 onMouseOver="ShowTip(event, 'tt60', 'link92')" onMouseOut="HideTip('tt60')">f_LwM2M_step_handleExecuteRequest</a></td><td class=SDescription>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_sendNotificationForObservedResources" id=link93 onMouseOver="ShowTip(event, 'tt61', 'link93')" onMouseOut="HideTip('tt61')">f_LwM2M_step_sendNotificationForObservedResources</a></td><td class=SDescription>The test step will iterate through the observed resources of the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link94 onMouseOver="ShowTip(event, 'tt44', 'link94')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and creates and sends a NOTIFICATION for each.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setFirmwareUpdateState" id=link95 onMouseOver="ShowTip(event, 'tt62', 'link95')" onMouseOut="HideTip('tt62')">f_LwM2M_step_setFirmwareUpdateState</a></td><td class=SDescription>The test step will set the firmware update state resource value.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_step_setFirmwareUpdateResult" id=link96 onMouseOver="ShowTip(event, 'tt63', 'link96')" onMouseOut="HideTip('tt63')">f_LwM2M_step_setFirmwareUpdateResult</a></td><td class=SDescription>The test step will set the firmware update result resource value.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_step_setContentFormats" id=link97 onMouseOver="ShowTip(event, 'tt64', 'link97')" onMouseOut="HideTip('tt64')">f_LwM2M_step_setContentFormats</a></td><td class=SDescription>Test Step to set the preferred encoding content format for a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link98 onMouseOver="ShowTip(event, 'tt44', 'link98')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_setStepCtx" id=link99 onMouseOver="ShowTip(event, 'tt65', 'link99')" onMouseOut="HideTip('tt65')">f_EPTF_LwM2M_setStepCtx</a></td><td class=SDescription>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link100 onMouseOver="ShowTip(event, 'tt66', 'link100')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_setCtx" id=link101 onMouseOver="ShowTip(event, 'tt67', 'link101')" onMouseOut="HideTip('tt67')">f_EPTF_LwM2M_setCtx</a></td><td class=SDescription>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link102 onMouseOver="ShowTip(event, 'tt66', 'link102')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_hasDevice" id=link103 onMouseOver="ShowTip(event, 'tt68', 'link103')" onMouseOut="HideTip('tt68')">f_EPTF_LwM2M_hasDevice</a></td><td class=SDescription>Checks if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link104 onMouseOver="ShowTip(event, 'tt6', 'link104')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> instance of the actual entity has an associated device or not</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_stack_fromApp" id=link105 onMouseOver="ShowTip(event, 'tt69', 'link105')" onMouseOut="HideTip('tt69')">f_EPTF_LwM2M_stack_fromApp</a></td><td class=SDescription>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link106 onMouseOver="ShowTip(event, 'tt2', 'link106')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the application layer (e.g. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_stack_fromEnv" id=link107 onMouseOver="ShowTip(event, 'tt70', 'link107')" onMouseOut="HideTip('tt70')">f_EPTF_LwM2M_stack_fromEnv</a></td><td class=SDescription>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link108 onMouseOver="ShowTip(event, 'tt2', 'link108')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the environment layer (e.g. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_dispatchEventsForPDU" id=link109 onMouseOver="ShowTip(event, 'tt71', 'link109')" onMouseOut="HideTip('tt71')">f_EPTF_LwM2M_dispatchEventsForPDU</a></td><td class=SDescription>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_sendNotificationForResource" id=link110 onMouseOver="ShowTip(event, 'tt72', 'link110')" onMouseOut="HideTip('tt72')">f_EPTF_LwM2M_sendNotificationForResource</a></td><td class=SDescription>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_PduToEventIdx" id=link111 onMouseOver="ShowTip(event, 'tt73', 'link111')" onMouseOut="HideTip('tt73')">f_EPTF_LwM2M_PduToEventIdx</a></td><td class=SDescription>Maps a &lt;LWM2M_PDU&gt; to an event id (integer number) that represents the PDU&rsquo;s type</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_dispatchEvent" id=link112 onMouseOver="ShowTip(event, 'tt74', 'link112')" onMouseOut="HideTip('tt74')">f_EPTF_LwM2M_dispatchEvent</a></td><td class=SDescription>Wrapper for CLL&rsquo;s &lt;f_EPTF_LGenBase_postEvent&gt; to handle multi level event (generic, entity, FSM) reporting</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_getIntValue" id=link113 onMouseOver="ShowTip(event, 'tt75', 'link113')" onMouseOut="HideTip('tt75')">f_EPTF_LwM2M_getIntValue</a></td><td class=SDescription>Retreives an element of an &lt;EPTF_IntegerList&gt; if it exists</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_updateMessageStatistics" id=link114 onMouseOver="ShowTip(event, 'tt76', 'link114')" onMouseOut="HideTip('tt76')">f_EPTF_LwM2M_updateMessageStatistics</a></td><td class=SDescription>Updates the message statistics based on the incoming PDU</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_EPTF_LwM2M_getEncodingContentFormat" id=link115 onMouseOver="ShowTip(event, 'tt77', 'link115')" onMouseOut="HideTip('tt77')">f_EPTF_LwM2M_getEncodingContentFormat</a></td><td class=SDescription>Negotiates an encoding format based on this side&rsquo;s preferred, the other side&rsquo;s accepted and the list of resources to be encoded</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_EPTF_LwM2M_canEncode" id=link116 onMouseOver="ShowTip(event, 'tt78', 'link116')" onMouseOut="HideTip('tt78')">f_EPTF_LwM2M_canEncode</a></td><td class=SDescription>Finds out if a list of resources can be encoded with a certain content format</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_init"></a>f_EPTF_LwM2M_LGen_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The main initialization function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link113 onMouseOver="ShowTip(event, 'tt2', 'link113')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_name</td><td class=CDLDescription><b>in</b> <b>charstring</b> - the name for the component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link114 onMouseOver="ShowTip(event, 'tt2', 'link114')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_init"></a>f_EPTF_LwM2M_LGen_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The main initialization function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link118 onMouseOver="ShowTip(event, 'tt2', 'link118')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_name</td><td class=CDLDescription><b>in</b> <b>charstring</b> - the name for the component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link119 onMouseOver="ShowTip(event, 'tt2', 'link119')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_initLogging"></a>f_EPTF_LwM2M_LGen_initLogging</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializing CLL&rsquo;s logging feature on the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link115 onMouseOver="ShowTip(event, 'tt2', 'link115')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link116 onMouseOver="ShowTip(event, 'tt2', 'link116')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_initLogging"></a>f_EPTF_LwM2M_LGen_initLogging</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializing CLL&rsquo;s logging feature on the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link120 onMouseOver="ShowTip(event, 'tt2', 'link120')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link121 onMouseOver="ShowTip(event, 'tt2', 'link121')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_cleanUp"></a>f_LwM2M_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The main clean up function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link117 onMouseOver="ShowTip(event, 'tt2', 'link117')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link118 onMouseOver="ShowTip(event, 'tt2', 'link118')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_cleanUp"></a>f_LwM2M_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The main clean up function for the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link122 onMouseOver="ShowTip(event, 'tt2', 'link122')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component type</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link123 onMouseOver="ShowTip(event, 'tt2', 'link123')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxBind"></a>f_LwM2M_eCtxBind</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This function is called by the CLL for each entity instance created on a particular instace of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link119 onMouseOver="ShowTip(event, 'tt2', 'link119')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> The function will allocate and initialize an instance of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link120 onMouseOver="ShowTip(event, 'tt6', 'link120')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link121 onMouseOver="ShowTip(event, 'tt7', 'link121')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;EPTF_IntegerList&gt;</td><td class=CDLDescription>The list will contain the index of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link122 onMouseOver="ShowTip(event, 'tt7', 'link122')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> instance in the <b>v_LwM2M_EntityCtxDB</b></td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link123 onMouseOver="ShowTip(event, 'tt2', 'link123')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxBind"></a>f_LwM2M_eCtxBind</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This function is called by the CLL for each entity instance created on a particular instace of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link124 onMouseOver="ShowTip(event, 'tt2', 'link124')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> The function will allocate and initialize an instance of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link125 onMouseOver="ShowTip(event, 'tt6', 'link125')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> in <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link126 onMouseOver="ShowTip(event, 'tt7', 'link126')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;EPTF_IntegerList&gt;</td><td class=CDLDescription>The list will contain the index of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link127 onMouseOver="ShowTip(event, 'tt7', 'link127')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> instance in the <b>v_LwM2M_EntityCtxDB</b></td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link128 onMouseOver="ShowTip(event, 'tt2', 'link128')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxUnbind"></a>f_LwM2M_eCtxUnbind</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The reverse operation of <a href="#f_LwM2M_eCtxBind" class=LFunction id=link124 onMouseOver="ShowTip(event, 'tt5', 'link124')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>.&nbsp; Cleans up resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link125 onMouseOver="ShowTip(event, 'tt5', 'link125')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>.&nbsp; Called by the CLL.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link126 onMouseOver="ShowTip(event, 'tt2', 'link126')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxUnbind"></a>f_LwM2M_eCtxUnbind</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The reverse operation of <a href="#f_LwM2M_eCtxBind" class=LFunction id=link129 onMouseOver="ShowTip(event, 'tt5', 'link129')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>.&nbsp; Cleans up resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link130 onMouseOver="ShowTip(event, 'tt5', 'link130')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a>.&nbsp; Called by the CLL.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link131 onMouseOver="ShowTip(event, 'tt2', 'link131')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxReset"></a>f_LwM2M_eCtxReset</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link127 onMouseOver="ShowTip(event, 'tt5', 'link127')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a> are reinitalized (reset).&nbsp; Called by the CLL.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link128 onMouseOver="ShowTip(event, 'tt2', 'link128')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_eCtxReset"></a>f_LwM2M_eCtxReset</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The resources reserved during <a href="#f_LwM2M_eCtxBind" class=LFunction id=link132 onMouseOver="ShowTip(event, 'tt5', 'link132')" onMouseOut="HideTip('tt5')">f_LwM2M_eCtxBind</a> are reinitalized (reset).&nbsp; Called by the CLL.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity instance on this load generator component instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link133 onMouseOver="ShowTip(event, 'tt2', 'link133')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_EntityCtxDB_init"></a>f_EPTF_LwM2M_EntityCtxDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link129 onMouseOver="ShowTip(event, 'tt7', 'link129')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link130 onMouseOver="ShowTip(event, 'tt7', 'link130')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_EntityCtxDB_init"></a>f_EPTF_LwM2M_EntityCtxDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link134 onMouseOver="ShowTip(event, 'tt7', 'link134')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link135 onMouseOver="ShowTip(event, 'tt7', 'link135')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_EntityCtxDB_cleanUp"></a>f_EPTF_LwM2M_EntityCtxDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link131 onMouseOver="ShowTip(event, 'tt7', 'link131')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link132 onMouseOver="ShowTip(event, 'tt7', 'link132')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_EntityCtxDB_cleanUp"></a>f_EPTF_LwM2M_EntityCtxDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link136 onMouseOver="ShowTip(event, 'tt7', 'link136')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=LType id=link137 onMouseOver="ShowTip(event, 'tt7', 'link137')" onMouseOut="HideTip('tt7')">LwM2M_EntityCtx_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_init"></a>f_EPTF_LwM2M_DeviceDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link133 onMouseOver="ShowTip(event, 'tt13', 'link133')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link134 onMouseOver="ShowTip(event, 'tt13', 'link134')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_init"></a>f_EPTF_LwM2M_DeviceDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link138 onMouseOver="ShowTip(event, 'tt13', 'link138')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link139 onMouseOver="ShowTip(event, 'tt13', 'link139')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_add"></a>f_EPTF_LwM2M_DeviceDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new element to the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link135 onMouseOver="ShowTip(event, 'tt13', 'link135')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_device</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link136 onMouseOver="ShowTip(event, 'tt44', 'link136')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> - the element to be added</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>out</b> <b>integer</b> - the index of the added element in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link137 onMouseOver="ShowTip(event, 'tt13', 'link137')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_add"></a>f_EPTF_LwM2M_DeviceDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new element to the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link140 onMouseOver="ShowTip(event, 'tt13', 'link140')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_device</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link141 onMouseOver="ShowTip(event, 'tt44', 'link141')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> - the element to be added</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>out</b> <b>integer</b> - the index of the added element in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link142 onMouseOver="ShowTip(event, 'tt13', 'link142')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_remove"></a>f_EPTF_LwM2M_DeviceDB_remove</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Removes an element from the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link138 onMouseOver="ShowTip(event, 'tt13', 'link138')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database and frees up its reserved resources</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the element to be removed</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link139 onMouseOver="ShowTip(event, 'tt13', 'link139')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_remove"></a>f_EPTF_LwM2M_DeviceDB_remove</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Removes an element from the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link143 onMouseOver="ShowTip(event, 'tt13', 'link143')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database and frees up its reserved resources</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the element to be removed</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link144 onMouseOver="ShowTip(event, 'tt13', 'link144')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_setLocationKey"></a>f_EPTF_LwM2M_DeviceDB_setLocationKey</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link140 onMouseOver="ShowTip(event, 'tt13', 'link140')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_location</td><td class=CDLDescription><b>in</b> &lt;Location&gt; - the location (of a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link141 onMouseOver="ShowTip(event, 'tt44', 'link141')" onMouseOut="HideTip('tt44')">LwM2M_Device</a>)</td></tr><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link142 onMouseOver="ShowTip(event, 'tt44', 'link142')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> in the <b>v_LwM2M_DeviceDB</b> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link143 onMouseOver="ShowTip(event, 'tt13', 'link143')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_setLocationKey"></a>f_EPTF_LwM2M_DeviceDB_setLocationKey</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link145 onMouseOver="ShowTip(event, 'tt13', 'link145')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_location</td><td class=CDLDescription><b>in</b> &lt;Location&gt; - the location (of a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link146 onMouseOver="ShowTip(event, 'tt44', 'link146')" onMouseOut="HideTip('tt44')">LwM2M_Device</a>)</td></tr><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link147 onMouseOver="ShowTip(event, 'tt44', 'link147')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> in the <b>v_LwM2M_DeviceDB</b> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link148 onMouseOver="ShowTip(event, 'tt13', 'link148')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_locationHash"></a>f_EPTF_LwM2M_DeviceDB_locationHash</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link144 onMouseOver="ShowTip(event, 'tt13', 'link144')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_location</td><td class=CDLDescription><b>in</b> &lt;Location&gt; - the location (of a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link145 onMouseOver="ShowTip(event, 'tt44', 'link145')" onMouseOut="HideTip('tt44')">LwM2M_Device</a>)</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*charstring*</td><td class=CDLDescription>string hash unique for the &lt;Location&gt; parameter</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link146 onMouseOver="ShowTip(event, 'tt13', 'link146')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_locationHash"></a>f_EPTF_LwM2M_DeviceDB_locationHash</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link149 onMouseOver="ShowTip(event, 'tt13', 'link149')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_location</td><td class=CDLDescription><b>in</b> &lt;Location&gt; - the location (of a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link150 onMouseOver="ShowTip(event, 'tt44', 'link150')" onMouseOut="HideTip('tt44')">LwM2M_Device</a>)</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*charstring*</td><td class=CDLDescription>string hash unique for the &lt;Location&gt; parameter</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link151 onMouseOver="ShowTip(event, 'tt13', 'link151')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_cleanUp"></a>f_EPTF_LwM2M_DeviceDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link147 onMouseOver="ShowTip(event, 'tt13', 'link147')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link148 onMouseOver="ShowTip(event, 'tt13', 'link148')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_DeviceDB_cleanUp"></a>f_EPTF_LwM2M_DeviceDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link152 onMouseOver="ShowTip(event, 'tt13', 'link152')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=LType id=link153 onMouseOver="ShowTip(event, 'tt13', 'link153')" onMouseOut="HideTip('tt13')">LwM2M_Device_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_init"></a>f_EPTF_LwM2M_TemplateDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link149 onMouseOver="ShowTip(event, 'tt20', 'link149')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database by adding the templates given in <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link150 onMouseOver="ShowTip(event, 'tt21', 'link150')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a></p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link151 onMouseOver="ShowTip(event, 'tt20', 'link151')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_init"></a>f_EPTF_LwM2M_TemplateDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link154 onMouseOver="ShowTip(event, 'tt20', 'link154')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database by adding the templates given in <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link155 onMouseOver="ShowTip(event, 'tt21', 'link155')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a></p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link156 onMouseOver="ShowTip(event, 'tt20', 'link156')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_add"></a>f_EPTF_LwM2M_TemplateDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new element to the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link152 onMouseOver="ShowTip(event, 'tt20', 'link152')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_template</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link153 onMouseOver="ShowTip(event, 'tt24', 'link153')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> - the element to be added</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the added element in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link154 onMouseOver="ShowTip(event, 'tt20', 'link154')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_add"></a>f_EPTF_LwM2M_TemplateDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new element to the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link157 onMouseOver="ShowTip(event, 'tt20', 'link157')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_template</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link158 onMouseOver="ShowTip(event, 'tt24', 'link158')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> - the element to be added</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the added element in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link159 onMouseOver="ShowTip(event, 'tt20', 'link159')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_lookUp"></a>f_EPTF_LwM2M_TemplateDB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Gets the index of an <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link155 onMouseOver="ShowTip(event, 'tt24', 'link155')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> element in <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link156 onMouseOver="ShowTip(event, 'tt20', 'link156')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in</b> <b>charstring</b> - the id of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link157 onMouseOver="ShowTip(event, 'tt24', 'link157')" onMouseOut="HideTip('tt24')">LwM2M_Template</a></td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the added element in the database, or -1 if not found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link158 onMouseOver="ShowTip(event, 'tt20', 'link158')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_lookUp"></a>f_EPTF_LwM2M_TemplateDB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Gets the index of an <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link160 onMouseOver="ShowTip(event, 'tt24', 'link160')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> element in <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link161 onMouseOver="ShowTip(event, 'tt20', 'link161')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in</b> <b>charstring</b> - the id of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link162 onMouseOver="ShowTip(event, 'tt24', 'link162')" onMouseOut="HideTip('tt24')">LwM2M_Template</a></td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the added element in the database, or -1 if not found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link163 onMouseOver="ShowTip(event, 'tt20', 'link163')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_get"></a>f_EPTF_LwM2M_TemplateDB_get</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an element from the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link159 onMouseOver="ShowTip(event, 'tt20', 'link159')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the element to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_or</td><td class=CDLDescription><b>inout</b> &lt;LWM2M_PDU&gt; - the retrieved element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link160 onMouseOver="ShowTip(event, 'tt20', 'link160')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_get"></a>f_EPTF_LwM2M_TemplateDB_get</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an element from the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link164 onMouseOver="ShowTip(event, 'tt20', 'link164')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the element to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_or</td><td class=CDLDescription><b>inout</b> &lt;LWM2M_PDU&gt; - the retrieved element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link165 onMouseOver="ShowTip(event, 'tt20', 'link165')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_cleanUp"></a>f_EPTF_LwM2M_TemplateDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link161 onMouseOver="ShowTip(event, 'tt20', 'link161')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link162 onMouseOver="ShowTip(event, 'tt20', 'link162')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_TemplateDB_cleanUp"></a>f_EPTF_LwM2M_TemplateDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link166 onMouseOver="ShowTip(event, 'tt20', 'link166')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a> database</p><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=LType id=link167 onMouseOver="ShowTip(event, 'tt20', 'link167')" onMouseOut="HideTip('tt20')">LwM2M_Template_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_VERBOSE"></a>f_EPTF_LwM2M_Logging_VERBOSE</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the VERBOSE log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link163 onMouseOver="ShowTip(event, 'tt2', 'link163')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_VERBOSE"></a>f_EPTF_LwM2M_Logging_VERBOSE</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the VERBOSE log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link168 onMouseOver="ShowTip(event, 'tt2', 'link168')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_DEBUG"></a>f_EPTF_LwM2M_Logging_DEBUG</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the DEBUG log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link164 onMouseOver="ShowTip(event, 'tt2', 'link164')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_DEBUG"></a>f_EPTF_LwM2M_Logging_DEBUG</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the DEBUG log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link169 onMouseOver="ShowTip(event, 'tt2', 'link169')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_WARNING"></a>f_EPTF_LwM2M_Logging_WARNING</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the WARNING log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link165 onMouseOver="ShowTip(event, 'tt2', 'link165')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_WARNING"></a>f_EPTF_LwM2M_Logging_WARNING</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the WARNING log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link170 onMouseOver="ShowTip(event, 'tt2', 'link170')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_ERROR"></a>f_EPTF_LwM2M_Logging_ERROR</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the ERROR log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link166 onMouseOver="ShowTip(event, 'tt2', 'link166')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_Logging_ERROR"></a>f_EPTF_LwM2M_Logging_ERROR</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Logging functions for the ERROR log level</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <b>charstring</b> - string to be logged</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link171 onMouseOver="ShowTip(event, 'tt2', 'link171')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_receiveMessage"></a>f_EPTF_LwM2M_LGen_receiveMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link167 onMouseOver="ShowTip(event, 'tt32', 'link167')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link168 onMouseOver="ShowTip(event, 'tt33', 'link168')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> message to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link169 onMouseOver="ShowTip(event, 'tt34', 'link169')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link170 onMouseOver="ShowTip(event, 'tt2', 'link170')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link171 onMouseOver="ShowTip(event, 'tt33', 'link171')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - received message</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link172 onMouseOver="ShowTip(event, 'tt2', 'link172')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" class=LType id=link173 onMouseOver="ShowTip(event, 'tt76', 'link173')" onMouseOut="HideTip('tt76')">fcb_EPTF_LwM2M_Transport_receiveMessage</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link174 onMouseOver="ShowTip(event, 'tt32', 'link174')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link175 onMouseOver="ShowTip(event, 'tt34', 'link175')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_receiveMessage"></a>f_EPTF_LwM2M_LGen_receiveMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link172 onMouseOver="ShowTip(event, 'tt32', 'link172')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link173 onMouseOver="ShowTip(event, 'tt33', 'link173')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> message to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link174 onMouseOver="ShowTip(event, 'tt34', 'link174')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link175 onMouseOver="ShowTip(event, 'tt2', 'link175')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link176 onMouseOver="ShowTip(event, 'tt33', 'link176')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - received message</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link177 onMouseOver="ShowTip(event, 'tt2', 'link177')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" class=LType id=link178 onMouseOver="ShowTip(event, 'tt80', 'link178')" onMouseOut="HideTip('tt80')">fcb_EPTF_LwM2M_Transport_receiveMessage</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link179 onMouseOver="ShowTip(event, 'tt32', 'link179')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link180 onMouseOver="ShowTip(event, 'tt34', 'link180')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_receiveEvent"></a>f_EPTF_LwM2M_LGen_receiveEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link176 onMouseOver="ShowTip(event, 'tt32', 'link176')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link177 onMouseOver="ShowTip(event, 'tt36', 'link177')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> events to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link178 onMouseOver="ShowTip(event, 'tt34', 'link178')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link179 onMouseOver="ShowTip(event, 'tt2', 'link179')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_event</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link180 onMouseOver="ShowTip(event, 'tt36', 'link180')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> - received event</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link181 onMouseOver="ShowTip(event, 'tt2', 'link181')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" class=LType id=link182 onMouseOver="ShowTip(event, 'tt77', 'link182')" onMouseOut="HideTip('tt77')">fcb_EPTF_LwM2M_Transport_receiveEvent</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link183 onMouseOver="ShowTip(event, 'tt32', 'link183')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link184 onMouseOver="ShowTip(event, 'tt34', 'link184')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_receiveEvent"></a>f_EPTF_LwM2M_LGen_receiveEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The transport layer implementation <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link181 onMouseOver="ShowTip(event, 'tt32', 'link181')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a> can report received <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link182 onMouseOver="ShowTip(event, 'tt36', 'link182')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> events to the load generator layer <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link183 onMouseOver="ShowTip(event, 'tt34', 'link183')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a> extended by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link184 onMouseOver="ShowTip(event, 'tt2', 'link184')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> using this function.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_event</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=LType id=link185 onMouseOver="ShowTip(event, 'tt36', 'link185')" onMouseOut="HideTip('tt36')">EPTF_LwM2M_Event</a> - received event</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link186 onMouseOver="ShowTip(event, 'tt2', 'link186')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" class=LType id=link187 onMouseOver="ShowTip(event, 'tt81', 'link187')" onMouseOut="HideTip('tt81')">fcb_EPTF_LwM2M_Transport_receiveEvent</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link188 onMouseOver="ShowTip(event, 'tt32', 'link188')" onMouseOut="HideTip('tt32')">EPTF_LwM2M_Transport_Provider_CT</a></li><li><a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=LType id=link189 onMouseOver="ShowTip(event, 'tt34', 'link189')" onMouseOut="HideTip('tt34')">EPTF_LwM2M_Transport_User_CT</a></li></ul></div></div></div>
 
 <div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_LGen_isBootstrap"></a>f_EPTF_LwM2M_LGen_isBootstrap</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets p_isBootstrap true if the device is in bootstrapping state.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> integer - device index</td></tr><tr><td class=CDLEntry>p_isBootstrap</td><td class=CDLDescription><b>inout</b> boolean - is the device bootsrapping</td></tr></table></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_declareEvents"></a>f_EPTF_LwM2M_declareEvents</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Declares the FSM events to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link185 onMouseOver="ShowTip(event, 'tt2', 'link185')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link186 onMouseOver="ShowTip(event, 'tt2', 'link186')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_declareEvents"></a>f_EPTF_LwM2M_declareEvents</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Declares the FSM events to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link190 onMouseOver="ShowTip(event, 'tt2', 'link190')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link191 onMouseOver="ShowTip(event, 'tt2', 'link191')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_declareSteps"></a>f_EPTF_LwM2M_declareSteps</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Declares the FSM steps to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link187 onMouseOver="ShowTip(event, 'tt2', 'link187')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link188 onMouseOver="ShowTip(event, 'tt2', 'link188')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_declareSteps"></a>f_EPTF_LwM2M_declareSteps</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Declares the FSM steps to the CLL framework implemented by <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link192 onMouseOver="ShowTip(event, 'tt2', 'link192')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link193 onMouseOver="ShowTip(event, 'tt2', 'link193')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_loadTemplate_byIntIdx"></a>f_LwM2M_step_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link189 onMouseOver="ShowTip(event, 'tt24', 'link189')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link190 onMouseOver="ShowTip(event, 'tt21', 'link190')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step).&nbsp; Integer parameter required.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>pl_ptr.refContext.fRefArgs[0]</td><td class=CDLDescription><b>integer</b> - Index of the template to load into <b>v_LwM2M_msgToSend</b></td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=LConstant id=link191 onMouseOver="ShowTip(event, 'tt78', 'link191')" onMouseOut="HideTip('tt78')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=LConstant id=link192 onMouseOver="ShowTip(event, 'tt79', 'link192')" onMouseOut="HideTip('tt79')">c_LwM2M_stepName_loadTemplate_byIntIdx</a></li></ul><h4 class=CHeading>Related Steps</h4><p><a href="#f_LwM2M_step_send" class=LFunction id=link193 onMouseOver="ShowTip(event, 'tt42', 'link193')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_loadTemplate_byIntIdx"></a>f_LwM2M_step_loadTemplate_byIntIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link194 onMouseOver="ShowTip(event, 'tt24', 'link194')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link195 onMouseOver="ShowTip(event, 'tt21', 'link195')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step).&nbsp; Integer parameter required.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>pl_ptr.refContext.fRefArgs[0]</td><td class=CDLDescription><b>integer</b> - Index of the template to load into <b>v_LwM2M_msgToSend</b></td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=LConstant id=link196 onMouseOver="ShowTip(event, 'tt82', 'link196')" onMouseOut="HideTip('tt82')">c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=LConstant id=link197 onMouseOver="ShowTip(event, 'tt83', 'link197')" onMouseOut="HideTip('tt83')">c_LwM2M_stepName_loadTemplate_byIntIdx</a></li></ul><h4 class=CHeading>Related Steps</h4><p><a href="#f_LwM2M_step_send" class=LFunction id=link198 onMouseOver="ShowTip(event, 'tt42', 'link198')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_loadTemplate_byStringId"></a>f_LwM2M_step_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link194 onMouseOver="ShowTip(event, 'tt24', 'link194')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link195 onMouseOver="ShowTip(event, 'tt21', 'link195')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step).&nbsp; String parameter required.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - ID the template to load into <b>v_LwM2M_msgToSend</b></td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=LConstant id=link196 onMouseOver="ShowTip(event, 'tt80', 'link196')" onMouseOut="HideTip('tt80')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=LConstant id=link197 onMouseOver="ShowTip(event, 'tt81', 'link197')" onMouseOut="HideTip('tt81')">c_LwM2M_stepName_loadTemplate_byStringId</a></li></ul><h4 class=CHeading>Related Steps</h4><p><a href="#f_LwM2M_step_send" class=LFunction id=link198 onMouseOver="ShowTip(event, 'tt42', 'link198')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_loadTemplate_byStringId"></a>f_LwM2M_step_loadTemplate_byStringId</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to load a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=LType id=link199 onMouseOver="ShowTip(event, 'tt24', 'link199')" onMouseOut="HideTip('tt24')">LwM2M_Template</a> from <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=LModuleParameter id=link200 onMouseOver="ShowTip(event, 'tt21', 'link200')" onMouseOut="HideTip('tt21')">tsp_EPTF_LwM2M_LGen_templates</a> into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step).&nbsp; String parameter required.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - ID the template to load into <b>v_LwM2M_msgToSend</b></td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=LConstant id=link201 onMouseOver="ShowTip(event, 'tt84', 'link201')" onMouseOut="HideTip('tt84')">c_LwM2M_stepIdx_loadTemplate_byStringId</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=LConstant id=link202 onMouseOver="ShowTip(event, 'tt85', 'link202')" onMouseOut="HideTip('tt85')">c_LwM2M_stepName_loadTemplate_byStringId</a></li></ul><h4 class=CHeading>Related Steps</h4><p><a href="#f_LwM2M_step_send" class=LFunction id=link203 onMouseOver="ShowTip(event, 'tt42', 'link203')" onMouseOut="HideTip('tt42')">f_LwM2M_step_send</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_send"></a>f_LwM2M_step_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>.&nbsp; The message will be processed by the Applib&rsquo;s LWM2M stack The step expects that a device was created for the entity</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=LConstant id=link199 onMouseOver="ShowTip(event, 'tt82', 'link199')" onMouseOut="HideTip('tt82')">c_LwM2M_stepIdx_send</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=LConstant id=link200 onMouseOver="ShowTip(event, 'tt83', 'link200')" onMouseOut="HideTip('tt83')">c_LwM2M_stepName_send</a></li></ul><h4 class=CHeading>Related Steps</h4><ul><li><a href="#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link201 onMouseOver="ShowTip(event, 'tt40', 'link201')" onMouseOut="HideTip('tt40')">f_LwM2M_step_loadTemplate_byIntIdx</a></li><li><a href="#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link202 onMouseOver="ShowTip(event, 'tt41', 'link202')" onMouseOut="HideTip('tt41')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul><h4 class=CHeading>Related functions</h4><p><a href="#f_EPTF_LwM2M_stack_fromApp" class=LFunction id=link203 onMouseOver="ShowTip(event, 'tt68', 'link203')" onMouseOut="HideTip('tt68')">f_EPTF_LwM2M_stack_fromApp</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_send"></a>f_LwM2M_step_send</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>.&nbsp; The message will be processed by the Applib&rsquo;s LWM2M stack The step expects that a device was created for the entity</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=LConstant id=link204 onMouseOver="ShowTip(event, 'tt86', 'link204')" onMouseOut="HideTip('tt86')">c_LwM2M_stepIdx_send</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=LConstant id=link205 onMouseOver="ShowTip(event, 'tt87', 'link205')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_send</a></li></ul><h4 class=CHeading>Related Steps</h4><ul><li><a href="#f_LwM2M_step_loadTemplate_byIntIdx" class=LFunction id=link206 onMouseOver="ShowTip(event, 'tt40', 'link206')" onMouseOut="HideTip('tt40')">f_LwM2M_step_loadTemplate_byIntIdx</a></li><li><a href="#f_LwM2M_step_loadTemplate_byStringId" class=LFunction id=link207 onMouseOver="ShowTip(event, 'tt41', 'link207')" onMouseOut="HideTip('tt41')">f_LwM2M_step_loadTemplate_byStringId</a></li></ul><h4 class=CHeading>Related functions</h4><p><a href="#f_EPTF_LwM2M_stack_fromApp" class=LFunction id=link208 onMouseOver="ShowTip(event, 'tt69', 'link208')" onMouseOut="HideTip('tt69')">f_EPTF_LwM2M_stack_fromApp</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createDevice"></a>f_LwM2M_step_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to dynamically allocate and initialize a simulated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link204 onMouseOver="ShowTip(event, 'tt44', 'link204')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and associate it to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link205 onMouseOver="ShowTip(event, 'tt6', 'link205')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a>.&nbsp; Prerequisite to call any other LWM2M test step.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=LConstant id=link206 onMouseOver="ShowTip(event, 'tt84', 'link206')" onMouseOut="HideTip('tt84')">c_LwM2M_stepIdx_createDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=LConstant id=link207 onMouseOver="ShowTip(event, 'tt85', 'link207')" onMouseOut="HideTip('tt85')">c_LwM2M_stepName_createDevice</a></li></ul><h4 class=CHeading>Related Functions</h4><ul><li><a href="#f_LwM2M_step_cleanupDevice" class=LFunction id=link208 onMouseOver="ShowTip(event, 'tt45', 'link208')" onMouseOut="HideTip('tt45')">f_LwM2M_step_cleanupDevice</a></li></ul><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link209 onMouseOver="ShowTip(event, 'tt44', 'link209')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createDevice"></a>f_LwM2M_step_createDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to dynamically allocate and initialize a simulated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link209 onMouseOver="ShowTip(event, 'tt44', 'link209')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and associate it to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link210 onMouseOver="ShowTip(event, 'tt6', 'link210')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a>.&nbsp; Prerequisite to call any other LWM2M test step.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=LConstant id=link211 onMouseOver="ShowTip(event, 'tt88', 'link211')" onMouseOut="HideTip('tt88')">c_LwM2M_stepIdx_createDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=LConstant id=link212 onMouseOver="ShowTip(event, 'tt89', 'link212')" onMouseOut="HideTip('tt89')">c_LwM2M_stepName_createDevice</a></li></ul><h4 class=CHeading>Related Functions</h4><ul><li><a href="#f_LwM2M_step_cleanupDevice" class=LFunction id=link213 onMouseOver="ShowTip(event, 'tt45', 'link213')" onMouseOut="HideTip('tt45')">f_LwM2M_step_cleanupDevice</a></li></ul><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link214 onMouseOver="ShowTip(event, 'tt44', 'link214')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_cleanupDevice"></a>f_LwM2M_step_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to free up the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link210 onMouseOver="ShowTip(event, 'tt6', 'link210')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> for the caller entity.&nbsp; Frees up all allocated instances that were used by this FSM instance.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="#f_LwM2M_step_createDevice" class=LFunction id=link211 onMouseOver="ShowTip(event, 'tt43', 'link211')" onMouseOut="HideTip('tt43')">f_LwM2M_step_createDevice</a></li></ul><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=LConstant id=link212 onMouseOver="ShowTip(event, 'tt86', 'link212')" onMouseOut="HideTip('tt86')">c_LwM2M_stepIdx_cleanupDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=LConstant id=link213 onMouseOver="ShowTip(event, 'tt87', 'link213')" onMouseOut="HideTip('tt87')">c_LwM2M_stepName_cleanupDevice</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_cleanupDevice"></a>f_LwM2M_step_cleanupDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to free up the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link215 onMouseOver="ShowTip(event, 'tt6', 'link215')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> for the caller entity.&nbsp; Frees up all allocated instances that were used by this FSM instance.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="#f_LwM2M_step_createDevice" class=LFunction id=link216 onMouseOver="ShowTip(event, 'tt43', 'link216')" onMouseOut="HideTip('tt43')">f_LwM2M_step_createDevice</a></li></ul><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=LConstant id=link217 onMouseOver="ShowTip(event, 'tt90', 'link217')" onMouseOut="HideTip('tt90')">c_LwM2M_stepIdx_cleanupDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=LConstant id=link218 onMouseOver="ShowTip(event, 'tt91', 'link218')" onMouseOut="HideTip('tt91')">c_LwM2M_stepName_cleanupDevice</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_logDevice"></a>f_LwM2M_step_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to log the contents of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link214 onMouseOver="ShowTip(event, 'tt44', 'link214')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> associated to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link215 onMouseOver="ShowTip(event, 'tt6', 'link215')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=LConstant id=link216 onMouseOver="ShowTip(event, 'tt88', 'link216')" onMouseOut="HideTip('tt88')">c_LwM2M_stepIdx_logDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=LConstant id=link217 onMouseOver="ShowTip(event, 'tt89', 'link217')" onMouseOut="HideTip('tt89')">c_LwM2M_stepName_logDevice</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_logDevice"></a>f_LwM2M_step_logDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to log the contents of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link219 onMouseOver="ShowTip(event, 'tt44', 'link219')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> associated to the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link220 onMouseOver="ShowTip(event, 'tt6', 'link220')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=LConstant id=link221 onMouseOver="ShowTip(event, 'tt92', 'link221')" onMouseOut="HideTip('tt92')">c_LwM2M_stepIdx_logDevice</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=LConstant id=link222 onMouseOver="ShowTip(event, 'tt93', 'link222')" onMouseOut="HideTip('tt93')">c_LwM2M_stepName_logDevice</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBootstrapState"></a>f_LwM2M_step_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the state of the device to BOOTSTRAPPING.&nbsp; Consequently, the bootstrap related LWM2M decoder functions will be used.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=LConstant id=link218 onMouseOver="ShowTip(event, 'tt90', 'link218')" onMouseOut="HideTip('tt90')">c_LwM2M_stepIdx_setBootstrapState</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=LConstant id=link219 onMouseOver="ShowTip(event, 'tt91', 'link219')" onMouseOut="HideTip('tt91')">c_LwM2M_stepName_setBootstrapState</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBootstrapState"></a>f_LwM2M_step_setBootstrapState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the state of the device to BOOTSTRAPPING.&nbsp; Consequently, the bootstrap related LWM2M decoder functions will be used.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=LConstant id=link223 onMouseOver="ShowTip(event, 'tt94', 'link223')" onMouseOut="HideTip('tt94')">c_LwM2M_stepIdx_setBootstrapState</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=LConstant id=link224 onMouseOver="ShowTip(event, 'tt95', 'link224')" onMouseOut="HideTip('tt95')">c_LwM2M_stepName_setBootstrapState</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBlock1Handling_stateless"></a>f_LwM2M_step_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the block1 handling strategy of the device to stateless</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=LConstant id=link220 onMouseOver="ShowTip(event, 'tt92', 'link220')" onMouseOut="HideTip('tt92')">c_LwM2M_stepIdx_setBlock1Handling_stateless</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=LConstant id=link221 onMouseOver="ShowTip(event, 'tt93', 'link221')" onMouseOut="HideTip('tt93')">c_LwM2M_stepName_setBlock1Handling_stateless</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBlock1Handling_stateless"></a>f_LwM2M_step_setBlock1Handling_stateless</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the block1 handling strategy of the device to stateless</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=LConstant id=link225 onMouseOver="ShowTip(event, 'tt96', 'link225')" onMouseOut="HideTip('tt96')">c_LwM2M_stepIdx_setBlock1Handling_stateless</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=LConstant id=link226 onMouseOver="ShowTip(event, 'tt97', 'link226')" onMouseOut="HideTip('tt97')">c_LwM2M_stepName_setBlock1Handling_stateless</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBlock1Handling_atomic"></a>f_LwM2M_step_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the block1 handling strategy of the device to atomic</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=LConstant id=link222 onMouseOver="ShowTip(event, 'tt94', 'link222')" onMouseOut="HideTip('tt94')">c_LwM2M_stepIdx_setBlock1Handling_atomic</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=LConstant id=link223 onMouseOver="ShowTip(event, 'tt95', 'link223')" onMouseOut="HideTip('tt95')">c_LwM2M_stepName_setBlock1Handling_atomic</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setBlock1Handling_atomic"></a>f_LwM2M_step_setBlock1Handling_atomic</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the block1 handling strategy of the device to atomic</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=LConstant id=link227 onMouseOver="ShowTip(event, 'tt98', 'link227')" onMouseOut="HideTip('tt98')">c_LwM2M_stepIdx_setBlock1Handling_atomic</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=LConstant id=link228 onMouseOver="ShowTip(event, 'tt99', 'link228')" onMouseOut="HideTip('tt99')">c_LwM2M_stepName_setBlock1Handling_atomic</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setNotRegisteredState"></a>f_LwM2M_step_setNotRegisteredState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the state of the device to BOOTSTRAPPING.&nbsp; Consequently, the bootstrap related LWM2M decoder functions will be used.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=LConstant id=link224 onMouseOver="ShowTip(event, 'tt96', 'link224')" onMouseOut="HideTip('tt96')">c_LwM2M_stepIdx_setNotRegisteredState</a></li><li>&lt;c_LwM2M_stepName_setNotRegisteredState&gt;</li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setNotRegisteredState"></a>f_LwM2M_step_setNotRegisteredState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the state of the device to NOT_REGISTERED.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=LConstant id=link229 onMouseOver="ShowTip(event, 'tt100', 'link229')" onMouseOut="HideTip('tt100')">c_LwM2M_stepIdx_setNotRegisteredState</a></li><li>&lt;c_LwM2M_stepName_setNotRegisteredState&gt;</li></ul></div></div></div>
 
 <div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_writeOrCreateObject_BS"></a>f_LwM2M_step_writeOrCreateObject_BS</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to handling the bootstrap write messge.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li>&lt;c_LwM2M_stepIdx_writeOrCreateObject_BS&gt;</li><li>&lt;c_LwM2M_stepName_writeOrCreateObject_BS&gt;</li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createObject"></a>f_LwM2M_step_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link225 onMouseOver="ShowTip(event, 'tt53', 'link225')" onMouseOut="HideTip('tt53')">LwM2M_Object</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link226 onMouseOver="ShowTip(event, 'tt44', 'link226')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=LConstant id=link227 onMouseOver="ShowTip(event, 'tt97', 'link227')" onMouseOut="HideTip('tt97')">c_LwM2M_stepIdx_createObject</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=LConstant id=link228 onMouseOver="ShowTip(event, 'tt98', 'link228')" onMouseOut="HideTip('tt98')">c_LwM2M_stepName_createObject</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createObject"></a>f_LwM2M_step_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link230 onMouseOver="ShowTip(event, 'tt53', 'link230')" onMouseOut="HideTip('tt53')">LwM2M_Object</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link231 onMouseOver="ShowTip(event, 'tt44', 'link231')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=LConstant id=link232 onMouseOver="ShowTip(event, 'tt101', 'link232')" onMouseOut="HideTip('tt101')">c_LwM2M_stepIdx_createObject</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=LConstant id=link233 onMouseOver="ShowTip(event, 'tt102', 'link233')" onMouseOut="HideTip('tt102')">c_LwM2M_stepName_createObject</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createObjectInstance"></a>f_LwM2M_step_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link229 onMouseOver="ShowTip(event, 'tt55', 'link229')" onMouseOut="HideTip('tt55')">LwM2M_ObjectInstance</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link230 onMouseOver="ShowTip(event, 'tt44', 'link230')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> the instance will also created the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link231 onMouseOver="ShowTip(event, 'tt56', 'link231')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> instances according to the object instance&rsquo;s <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link232 onMouseOver="ShowTip(event, 'tt57', 'link232')" onMouseOut="HideTip('tt57')">LwM2M_ObjectSpecification</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=LConstant id=link233 onMouseOver="ShowTip(event, 'tt99', 'link233')" onMouseOut="HideTip('tt99')">c_LwM2M_stepIdx_createObjectInstance</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=LConstant id=link234 onMouseOver="ShowTip(event, 'tt100', 'link234')" onMouseOut="HideTip('tt100')">c_LwM2M_stepName_createObjectInstance</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_createObjectInstance"></a>f_LwM2M_step_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to create an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link234 onMouseOver="ShowTip(event, 'tt55', 'link234')" onMouseOut="HideTip('tt55')">LwM2M_ObjectInstance</a> instance on the caller entity&rsquo;s associated <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link235 onMouseOver="ShowTip(event, 'tt44', 'link235')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> the instance will also created the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link236 onMouseOver="ShowTip(event, 'tt56', 'link236')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> instances according to the object instance&rsquo;s <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link237 onMouseOver="ShowTip(event, 'tt57', 'link237')" onMouseOut="HideTip('tt57')">LwM2M_ObjectSpecification</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=LConstant id=link238 onMouseOver="ShowTip(event, 'tt103', 'link238')" onMouseOut="HideTip('tt103')">c_LwM2M_stepIdx_createObjectInstance</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=LConstant id=link239 onMouseOver="ShowTip(event, 'tt104', 'link239')" onMouseOut="HideTip('tt104')">c_LwM2M_stepName_createObjectInstance</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleReadRequest"></a>f_LwM2M_step_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M READ request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link235 onMouseOver="ShowTip(event, 'tt56', 'link235')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and create a response with &lt;Code&gt; 205 and content according to the resource value.&nbsp; In case the READ request also includes observation, the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link236 onMouseOver="ShowTip(event, 'tt56', 'link236')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> will be marked as observed</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=LConstant id=link237 onMouseOver="ShowTip(event, 'tt101', 'link237')" onMouseOut="HideTip('tt101')">c_LwM2M_stepIdx_handleReadRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=LConstant id=link238 onMouseOver="ShowTip(event, 'tt102', 'link238')" onMouseOut="HideTip('tt102')">c_LwM2M_stepName_handleReadRequest</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleReadRequest"></a>f_LwM2M_step_handleReadRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M READ request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link240 onMouseOver="ShowTip(event, 'tt56', 'link240')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and create a response with &lt;Code&gt; 205 and content according to the resource value.&nbsp; In case the READ request also includes observation, the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link241 onMouseOver="ShowTip(event, 'tt56', 'link241')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> will be marked as observed</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=LConstant id=link242 onMouseOver="ShowTip(event, 'tt105', 'link242')" onMouseOut="HideTip('tt105')">c_LwM2M_stepIdx_handleReadRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=LConstant id=link243 onMouseOver="ShowTip(event, 'tt106', 'link243')" onMouseOut="HideTip('tt106')">c_LwM2M_stepName_handleReadRequest</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleWriteRequest"></a>f_LwM2M_step_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M WRITE request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link239 onMouseOver="ShowTip(event, 'tt56', 'link239')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and load the updated value from the request.&nbsp; Finally, it will create a response with &lt;Code&gt; 204 in case the resource was found (404 otherwise).</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=LConstant id=link240 onMouseOver="ShowTip(event, 'tt103', 'link240')" onMouseOut="HideTip('tt103')">c_LwM2M_stepIdx_handleWriteRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=LConstant id=link241 onMouseOver="ShowTip(event, 'tt104', 'link241')" onMouseOut="HideTip('tt104')">c_LwM2M_stepName_handleWriteRequest</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleWriteRequest"></a>f_LwM2M_step_handleWriteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M WRITE request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link244 onMouseOver="ShowTip(event, 'tt56', 'link244')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and load the updated value from the request.&nbsp; Finally, it will create a response with &lt;Code&gt; 204 in case the resource was found (404 otherwise).</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=LConstant id=link245 onMouseOver="ShowTip(event, 'tt107', 'link245')" onMouseOut="HideTip('tt107')">c_LwM2M_stepIdx_handleWriteRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=LConstant id=link246 onMouseOver="ShowTip(event, 'tt108', 'link246')" onMouseOut="HideTip('tt108')">c_LwM2M_stepName_handleWriteRequest</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleExecuteRequest"></a>f_LwM2M_step_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link242 onMouseOver="ShowTip(event, 'tt56', 'link242')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and create a response with &lt;Code&gt; 204 in case the resource was found (404 otherwise).</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=LConstant id=link243 onMouseOver="ShowTip(event, 'tt105', 'link243')" onMouseOut="HideTip('tt105')">c_LwM2M_stepIdx_handleExecuteRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=LConstant id=link244 onMouseOver="ShowTip(event, 'tt106', 'link244')" onMouseOut="HideTip('tt106')">c_LwM2M_stepName_handleExecuteRequest</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_handleExecuteRequest"></a>f_LwM2M_step_handleExecuteRequest</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request.&nbsp; The test step will bind the current request to the caller FSM, look up the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link247 onMouseOver="ShowTip(event, 'tt56', 'link247')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> addressed in the request and create a response with &lt;Code&gt; 204 in case the resource was found (404 otherwise).</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=LConstant id=link248 onMouseOver="ShowTip(event, 'tt109', 'link248')" onMouseOut="HideTip('tt109')">c_LwM2M_stepIdx_handleExecuteRequest</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=LConstant id=link249 onMouseOver="ShowTip(event, 'tt110', 'link249')" onMouseOut="HideTip('tt110')">c_LwM2M_stepName_handleExecuteRequest</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_sendNotificationForObservedResources"></a>f_LwM2M_step_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will iterate through the observed resources of the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link245 onMouseOver="ShowTip(event, 'tt44', 'link245')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and creates and sends a NOTIFICATION for each.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=LConstant id=link246 onMouseOver="ShowTip(event, 'tt107', 'link246')" onMouseOut="HideTip('tt107')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link247 onMouseOver="ShowTip(event, 'tt108', 'link247')" onMouseOut="HideTip('tt108')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_sendNotificationForObservedResources"></a>f_LwM2M_step_sendNotificationForObservedResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will iterate through the observed resources of the caller entity&rsquo;s <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link250 onMouseOver="ShowTip(event, 'tt44', 'link250')" onMouseOut="HideTip('tt44')">LwM2M_Device</a> and creates and sends a NOTIFICATION for each.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=LConstant id=link251 onMouseOver="ShowTip(event, 'tt111', 'link251')" onMouseOut="HideTip('tt111')">c_LwM2M_stepIdx_sendNotificationForObservedResources</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=LConstant id=link252 onMouseOver="ShowTip(event, 'tt112', 'link252')" onMouseOut="HideTip('tt112')">c_LwM2M_stepName_sendNotificationForObservedResources</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setFirmwareUpdateState"></a>f_LwM2M_step_setFirmwareUpdateState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will set the firmware update state resource value.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li>&lt;c_LwM2M_stepIdx_setFirmwareUpdateState&gt;</li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link248 onMouseOver="ShowTip(event, 'tt109', 'link248')" onMouseOut="HideTip('tt109')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setFirmwareUpdateState"></a>f_LwM2M_step_setFirmwareUpdateState</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will set the firmware update state resource value.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li>&lt;c_LwM2M_stepIdx_setFirmwareUpdateState&gt;</li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=LConstant id=link253 onMouseOver="ShowTip(event, 'tt113', 'link253')" onMouseOut="HideTip('tt113')">c_LwM2M_stepName_setFirmwareUpdateState</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setFirmwareUpdateResult"></a>f_LwM2M_step_setFirmwareUpdateResult</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will set the firmware update result resource value.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=LConstant id=link249 onMouseOver="ShowTip(event, 'tt110', 'link249')" onMouseOut="HideTip('tt110')">c_LwM2M_stepIdx_setFirmwareUpdateResult</a></li><li>&lt;c_LwM2M_stepName_setFirmwareUpdateReslut&gt;</li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setFirmwareUpdateResult"></a>f_LwM2M_step_setFirmwareUpdateResult</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The test step will set the firmware update result resource value.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=LConstant id=link254 onMouseOver="ShowTip(event, 'tt114', 'link254')" onMouseOut="HideTip('tt114')">c_LwM2M_stepIdx_setFirmwareUpdateResult</a></li><li>&lt;c_LwM2M_stepName_setFirmwareUpdateReslut&gt;</li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_setStepCtx"></a>f_EPTF_LwM2M_setStepCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link250 onMouseOver="ShowTip(event, 'tt65', 'link250')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link251 onMouseOver="ShowTip(event, 'tt65', 'link251')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> - step context with pointers to the related instances</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link252 onMouseOver="ShowTip(event, 'tt6', 'link252')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link253 onMouseOver="ShowTip(event, 'tt65', 'link253')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_step_setContentFormats"></a>f_LwM2M_step_setContentFormats</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setContentFormats(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test Step to set the preferred encoding content format for a <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link255 onMouseOver="ShowTip(event, 'tt44', 'link255')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>pl_ptr.refContext.fRefArgs[0]</td><td class=CDLDescription><b>in integer</b> - content format code</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=LConstant id=link256 onMouseOver="ShowTip(event, 'tt101', 'link256')" onMouseOut="HideTip('tt101')">c_LwM2M_stepIdx_createObject</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=LConstant id=link257 onMouseOver="ShowTip(event, 'tt102', 'link257')" onMouseOut="HideTip('tt102')">c_LwM2M_stepName_createObject</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_setCtx"></a>f_EPTF_LwM2M_setCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link254 onMouseOver="ShowTip(event, 'tt65', 'link254')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - entity index</td></tr><tr><td class=CDLEntry>p_fsmIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - fsm instace index</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*inout* p_ctx</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link255 onMouseOver="ShowTip(event, 'tt65', 'link255')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> - step context with pointers to the related instances</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link256 onMouseOver="ShowTip(event, 'tt6', 'link256')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link257 onMouseOver="ShowTip(event, 'tt65', 'link257')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_setStepCtx"></a>f_EPTF_LwM2M_setStepCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link258 onMouseOver="ShowTip(event, 'tt66', 'link258')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link259 onMouseOver="ShowTip(event, 'tt66', 'link259')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> - step context with pointers to the related instances</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link260 onMouseOver="ShowTip(event, 'tt6', 'link260')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link261 onMouseOver="ShowTip(event, 'tt66', 'link261')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_hasDevice"></a>f_EPTF_LwM2M_hasDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Checks if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link258 onMouseOver="ShowTip(event, 'tt6', 'link258')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> instance of the actual entity has an associated device or not</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link259 onMouseOver="ShowTip(event, 'tt65', 'link259')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> - pointer related to the actual entity</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>TRUE if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link260 onMouseOver="ShowTip(event, 'tt6', 'link260')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> has an associated device, FALSE otherwise</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link261 onMouseOver="ShowTip(event, 'tt6', 'link261')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_setCtx"></a>f_EPTF_LwM2M_setCtx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This sets the instance pointers of <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link262 onMouseOver="ShowTip(event, 'tt66', 'link262')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> to the related instances of a simulated device (entity) calculated from the test step args &lt;EPTF_LGenBase_TestStepArgs&gt;</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - entity index</td></tr><tr><td class=CDLEntry>p_fsmIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - fsm instace index</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*inout* p_ctx</td><td class=CDLDescription><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link263 onMouseOver="ShowTip(event, 'tt66', 'link263')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> - step context with pointers to the related instances</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link264 onMouseOver="ShowTip(event, 'tt6', 'link264')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></li><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link265 onMouseOver="ShowTip(event, 'tt66', 'link265')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a></li></ul></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_stack_fromApp"></a>f_EPTF_LwM2M_stack_fromApp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link262 onMouseOver="ShowTip(event, 'tt2', 'link262')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the application layer (e.g.&nbsp; FSMs)</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_msg</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link263 onMouseOver="ShowTip(event, 'tt33', 'link263')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - message that enters into the stack (will be modified by the stack)</td></tr><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link264 onMouseOver="ShowTip(event, 'tt65', 'link264')" onMouseOut="HideTip('tt65')">LwM2M_StepCtx</a> - pointers for the instances related to a particular simulated entity</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link265 onMouseOver="ShowTip(event, 'tt2', 'link265')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_hasDevice"></a>f_EPTF_LwM2M_hasDevice</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Checks if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link266 onMouseOver="ShowTip(event, 'tt6', 'link266')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> instance of the actual entity has an associated device or not</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link267 onMouseOver="ShowTip(event, 'tt66', 'link267')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> - pointer related to the actual entity</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>TRUE if the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link268 onMouseOver="ShowTip(event, 'tt6', 'link268')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a> has an associated device, FALSE otherwise</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=LType id=link269 onMouseOver="ShowTip(event, 'tt6', 'link269')" onMouseOut="HideTip('tt6')">LwM2M_EntityCtx</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_stack_fromEnv"></a>f_EPTF_LwM2M_stack_fromEnv</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link266 onMouseOver="ShowTip(event, 'tt2', 'link266')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the environment layer (e.g. transport layer)</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_msg</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link267 onMouseOver="ShowTip(event, 'tt33', 'link267')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - message that enters into the stack (will be modified by the stack)</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true, if the <b>p_msg</b> message was a duplicate, false if it was not</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link268 onMouseOver="ShowTip(event, 'tt2', 'link268')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_stack_fromApp"></a>f_EPTF_LwM2M_stack_fromApp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link270 onMouseOver="ShowTip(event, 'tt2', 'link270')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the application layer (e.g.&nbsp; FSMs)</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_msg</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link271 onMouseOver="ShowTip(event, 'tt33', 'link271')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - message that enters into the stack (will be modified by the stack)</td></tr><tr><td class=CDLEntry>p_ctx</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=LType id=link272 onMouseOver="ShowTip(event, 'tt66', 'link272')" onMouseOut="HideTip('tt66')">LwM2M_StepCtx</a> - pointers for the instances related to a particular simulated entity</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link273 onMouseOver="ShowTip(event, 'tt2', 'link273')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_dispatchEventsForPDU"></a>f_EPTF_LwM2M_dispatchEventsForPDU</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_pdu</td><td class=CDLDescription><b>in</b> &lt;LWM2M_PDU&gt; - the LWM2M PDU</td></tr><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity</td></tr><tr><td class=CDLEntry>pl_fsmCtx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of FSM</td></tr><tr><td class=CDLEntry>pl_reportedArgs</td><td class=CDLDescription><b>in</b> &lt;EPTF_IntegerList&gt; - additional arguments to be reported to the entity/FSM</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link269 onMouseOver="ShowTip(event, 'tt2', 'link269')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_stack_fromEnv"></a>f_EPTF_LwM2M_stack_fromEnv</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This is the main entry point for the LwM2M stack realization of the <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link274 onMouseOver="ShowTip(event, 'tt2', 'link274')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a> component that handles messages received from the environment layer (e.g. transport layer)</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_msg</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link275 onMouseOver="ShowTip(event, 'tt33', 'link275')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - message that enters into the stack (will be modified by the stack)</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true, if the <b>p_msg</b> message was a duplicate, false if it was not</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link276 onMouseOver="ShowTip(event, 'tt2', 'link276')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_sendNotificationForResource"></a>f_EPTF_LwM2M_sendNotificationForResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>v_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link270 onMouseOver="ShowTip(event, 'tt56', 'link270')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> - resource for notification</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link271 onMouseOver="ShowTip(event, 'tt44', 'link271')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></li></ul></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_dispatchEventsForPDU"></a>f_EPTF_LwM2M_dispatchEventsForPDU</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_pdu</td><td class=CDLDescription><b>in</b> &lt;LWM2M_PDU&gt; - the LWM2M PDU</td></tr><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity</td></tr><tr><td class=CDLEntry>pl_fsmCtx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of FSM</td></tr><tr><td class=CDLEntry>pl_reportedArgs</td><td class=CDLDescription><b>in</b> &lt;EPTF_IntegerList&gt; - additional arguments to be reported to the entity/FSM</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link277 onMouseOver="ShowTip(event, 'tt2', 'link277')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_sendNotificationForResource"></a>f_EPTF_LwM2M_sendNotificationForResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>v_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link278 onMouseOver="ShowTip(event, 'tt56', 'link278')" onMouseOut="HideTip('tt56')">LwM2M_Resource</a> - resource for notification</td></tr></table><h4 class=CHeading>Related Types</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=LType id=link279 onMouseOver="ShowTip(event, 'tt44', 'link279')" onMouseOut="HideTip('tt44')">LwM2M_Device</a></li></ul></div></div></div>
 
 <div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_PduToEventIdx"></a>f_EPTF_LwM2M_PduToEventIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Maps a &lt;LWM2M_PDU&gt; to an event id (integer number) that represents the PDU&rsquo;s type</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_code</td><td class=CDLDescription><b>in</b> &lt;LWM2M_PDU&gt; - the LwM2M PDU</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the returned id</td></tr></table></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_dispatchEvent"></a>f_EPTF_LwM2M_dispatchEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Wrapper for CLL&rsquo;s &lt;f_EPTF_LGenBase_postEvent&gt; to handle multi level event (generic, entity, FSM) reporting</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eventIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - index of the vent to be reported</td></tr><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity, in case it&rsquo;s -1 the reported event will be <b>generic</b> level</td></tr><tr><td class=CDLEntry>pl_fsmCtx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of FSM, , in case it&rsquo;s -1 the reported event will be <b>entity</b> level</td></tr><tr><td class=CDLEntry>pl_reportedArgs</td><td class=CDLDescription><b>in</b> &lt;EPTF_IntegerList&gt; - additional arguments to be reported to the entity/FSM</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link272 onMouseOver="ShowTip(event, 'tt2', 'link272')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_dispatchEvent"></a>f_EPTF_LwM2M_dispatchEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Wrapper for CLL&rsquo;s &lt;f_EPTF_LGenBase_postEvent&gt; to handle multi level event (generic, entity, FSM) reporting</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_eventIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - index of the vent to be reported</td></tr><tr><td class=CDLEntry>pl_eIdx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of the entity, in case it&rsquo;s -1 the reported event will be <b>generic</b> level</td></tr><tr><td class=CDLEntry>pl_fsmCtx</td><td class=CDLDescription><b>in</b> <b>integer</b> - the index of FSM, , in case it&rsquo;s -1 the reported event will be <b>entity</b> level</td></tr><tr><td class=CDLEntry>pl_reportedArgs</td><td class=CDLDescription><b>in</b> &lt;EPTF_IntegerList&gt; - additional arguments to be reported to the entity/FSM</td></tr></table><h4 class=CHeading>Related Types</h4><p><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=LType id=link280 onMouseOver="ShowTip(event, 'tt2', 'link280')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_LGen_CT</a></p></div></div></div>
 
 <div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_getIntValue"></a>f_EPTF_LwM2M_getIntValue</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retreives an element of an &lt;EPTF_IntegerList&gt; if it exists</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_intList</td><td class=CDLDescription><b>in</b> &lt;EPTF_IntegerList&gt; - list of integers</td></tr><tr><td class=CDLEntry>pl_number</td><td class=CDLDescription><b>in</b> <b>integer</b> - index of the integer to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_value</td><td class=CDLDescription><b>inout</b> <b>integer</b> - value of the retrieved integer</td></tr><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if the element existed in the integer list</td></tr></table></div></div></div>
 
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_updateMessageStatistics"></a>f_EPTF_LwM2M_updateMessageStatistics</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_updateMessageStatistics(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Message_Statistics&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_stats,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Updates the message statistics based on the incoming PDU</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_stats</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" class=LType id=link281 onMouseOver="ShowTip(event, 'tt115', 'link281')" onMouseOut="HideTip('tt115')">EPTF_LwM2M_Message_Statistics</a> - the updated statistics</td></tr><tr><td class=CDLEntry>p_pdu</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=LType id=link282 onMouseOver="ShowTip(event, 'tt33', 'link282')" onMouseOut="HideTip('tt33')">EPTF_LwM2M_PDU</a> - the incoming PDU</td></tr></table></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_getEncodingContentFormat"></a>f_EPTF_LwM2M_getEncodingContentFormat</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getEncodingContentFormat(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Format_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_preferred,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Integer_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_accepted,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Negotiates an encoding format based on this side&rsquo;s preferred, the other side&rsquo;s accepted and the list of resources to be encoded</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_preferred</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Format_List" class=LType id=link283 onMouseOver="ShowTip(event, 'tt116', 'link283')" onMouseOut="HideTip('tt116')">LwM2M_Format_List</a> - this side&rsquo;s preferred format</td></tr><tr><td class=CDLEntry>p_accepted</td><td class=CDLDescription><b>in</b> &lt;Integer_List&gt; - the other side&rsquo;s accepted list</td></tr><tr><td class=CDLEntry>p_resources</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=LType id=link284 onMouseOver="ShowTip(event, 'tt117', 'link284')" onMouseOut="HideTip('tt117')">LwM2M_Resource_List</a> - resources to be encoded</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the negotiated content format</td></tr></table></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_EPTF_LwM2M_canEncode"></a>f_EPTF_LwM2M_canEncode</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_canEncode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_code,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Finds out if a list of resources can be encoded with a certain content format</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_code</td><td class=CDLDescription><b>in integer</b> - content format code</td></tr><tr><td class=CDLEntry>p_resources</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=LType id=link285 onMouseOver="ShowTip(event, 'tt117', 'link285')" onMouseOut="HideTip('tt117')">LwM2M_Resource_List</a> - resources to be encoded</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if they can be encoded with that content format</td></tr></table></div></div></div>
+
 </div><!--Content-->
 
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt5"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt8"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt9"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt11"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt12"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt14"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt16"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt20"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt21"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt24"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt32"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt33"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt34"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt36"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt44"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt47"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt48"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt49"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt50"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt51"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><div class=CToolTip id="tt52"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt53"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt54"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt55"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt56"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt57"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt58"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt59"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt60"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt61"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt62"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt63"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt64"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt65"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt66"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt67"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt68"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt69"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt70"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt71"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt72"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt73"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt74"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt75"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt76"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt77"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt84"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt85"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt86"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt87"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt88"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt89"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt90"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt91"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt92"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt93"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt94"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt95"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt96"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt97"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt98"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt99"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt100"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt101"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt102"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt103"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt104"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt105"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt106"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt107"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt108"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt109"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><div class=CToolTip id="tt110"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt5"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt8"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt9"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt11"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt12"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt14"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt16"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt20"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt21"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt24"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt32"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt33"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt34"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt36"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt44"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt47"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt48"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt49"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt50"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to NOT_REGISTERED.</div></div><div class=CToolTip id="tt51"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><div class=CToolTip id="tt52"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt53"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt54"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt55"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt56"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt57"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt58"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt59"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt60"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt61"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt62"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt63"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt64"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setContentFormats(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the preferred encoding content format for a LwM2M_Device</div></div><div class=CToolTip id="tt65"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt66"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt67"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt68"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt69"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt70"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt71"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt72"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt73"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt74"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt75"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt76"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_updateMessageStatistics(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Message_Statistics&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_stats,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Updates the message statistics based on the incoming PDU</div></div><div class=CToolTip id="tt77"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getEncodingContentFormat(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Format_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_preferred,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Integer_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_accepted,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Negotiates an encoding format based on this side&rsquo;s preferred, the other side&rsquo;s accepted and the list of resources to be encoded</div></div><div class=CToolTip id="tt78"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_canEncode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_code,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Finds out if a list of resources can be encoded with a certain content format</div></div><div class=CToolTip id="tt79"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt80"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt81"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt84"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt85"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt86"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt87"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt88"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt89"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt90"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt91"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt92"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt93"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt94"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt95"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt96"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt97"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt98"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt99"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt100"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt101"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt102"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt103"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt104"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt105"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt106"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt107"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt108"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt109"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt110"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt111"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt112"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt113"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><div class=CToolTip id="tt114"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt115"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt116"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_Format_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt117"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><!--END_ND_TOOLTIPS-->
 
 <script language=JavaScript><!--
 if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/EPTF_LwM2M_Object_Decoders-ttcn.html b/apidoc/html/files/EPTF_LwM2M_Object_Decoders-ttcn.html
new file mode 100644
index 0000000..04206ae
--- /dev/null
+++ b/apidoc/html/files/EPTF_LwM2M_Object_Decoders-ttcn.html
@@ -0,0 +1,24 @@
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Object_Definitions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
+
+<!--  Generated by Natural Docs, version 1.52 -->
+<!--  http://www.naturaldocs.org  -->
+
+<!-- saved from url=(0026)http://www.naturaldocs.org -->
+
+
+
+
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Object_Definitions"></a>EPTF_LwM2M_Object_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the smart object decoder functions</p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Object_Definitions" >EPTF_LwM2M_Object_Definitions</a></td><td class=SDescription>This module contains the smart object decoder functions</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_Resource_decode" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">f_LwM2M_Resource_decode</a></td><td class=SDescription>Decodes a resource based on a contnet format and its spceification</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_Resource_decode"></a>f_LwM2M_Resource_decode</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_decode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_contentFormat</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Decodes a resource based on a contnet format and its spceification</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_Resource</a> - the resource to be decoded (it will be updated)</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">LwM2M_ResourceSpecification</a> - the specification of the resource</td></tr><tr><td class=CDLEntry>p_contentFormat</td><td class=CDLDescription><b>in integer</b> - the content format code</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_Resource</a></p></div></div></div>
+
+</div><!--Content-->
+
+
+
+<!--START_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_decode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_contentFormat</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Decodes a resource based on a contnet format and its spceification</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><!--END_ND_TOOLTIPS-->
+
+<script language=JavaScript><!--
+if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/EPTF_LwM2M_Object_Definitions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_Object_Definitions-ttcn.html
index ad64971..4eff9d8 100644
--- a/apidoc/html/files/EPTF_LwM2M_Object_Definitions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_Object_Definitions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Object_Definitions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Object_Definitions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -9,48 +9,48 @@
 
 
 
-<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Object_Definitions"></a>EPTF_LwM2M_Object_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the smart object definitions for the LWM2M load generator component</p><h4 class=CHeading>Class Diagram</h4><p>(see EPTF_LwM2M_Object_Definitions.classes.jpg)</p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Object_Definitions" >EPTF_LwM2M_Object_Definitions</a></td><td class=SDescription>This module contains the smart object definitions for the LWM2M load generator component</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectDB" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a></td><td class=SDescription>Storing <a href="#LwM2M_Object" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Object_List" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">LwM2M_Object_List</a></td><td class=SDescription>List of <a href="#LwM2M_Object" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Object" id=link5 onMouseOver="ShowTip(event, 'tt2', 'link5')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td><td class=SDescription>This structure models a LwM2M smart object</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectInstance" id=link6 onMouseOver="ShowTip(event, 'tt4', 'link6')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a></td><td class=SDescription>Models a smart object instance of a <a href="#LwM2M_Object" class=LType id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ResourceIdx_List" id=link8 onMouseOver="ShowTip(event, 'tt5', 'link8')" onMouseOut="HideTip('tt5')">LwM2M_ResourceIdx_List</a></td><td class=SDescription>List of <b>integer</b></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectInstance_List" id=link9 onMouseOver="ShowTip(event, 'tt6', 'link9')" onMouseOut="HideTip('tt6')">LwM2M_ObjectInstance_List</a></td><td class=SDescription>List of <a href="#LwM2M_ObjectInstance" class=LType id=link10 onMouseOver="ShowTip(event, 'tt4', 'link10')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectSpecificationDB" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a></td><td class=SDescription>Storing <a href="#LwM2M_ObjectSpecification" class=LType id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectSpecification" id=link13 onMouseOver="ShowTip(event, 'tt8', 'link13')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></td><td class=SDescription>Defines a smart oject</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectSpecification_List" id=link14 onMouseOver="ShowTip(event, 'tt9', 'link14')" onMouseOut="HideTip('tt9')">LwM2M_ObjectSpecification_List</a></td><td class=SDescription>List of <a href="#LwM2M_ObjectSpecification" class=LType id=link15 onMouseOver="ShowTip(event, 'tt8', 'link15')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ResourceSpecification_List" id=link16 onMouseOver="ShowTip(event, 'tt10', 'link16')" onMouseOut="HideTip('tt10')">LwM2M_ResourceSpecification_List</a></td><td class=SDescription>List of <a href="#LwM2M_ResourceSpecification" class=LType id=link17 onMouseOver="ShowTip(event, 'tt11', 'link17')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ResourceSpecification" id=link18 onMouseOver="ShowTip(event, 'tt11', 'link18')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></td><td class=SDescription>Defines a smart resource</td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_OperationTypeEnum" >LwM2M_OperationTypeEnum</a></td><td class=SDescription>Operation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></td></tr><tr class="SEnumeration SMarked"><td class=SEntry><a href="#LwM2M_InstanceTypeEnum" >LwM2M_InstanceTypeEnum</a></td><td class=SDescription>Instantiation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link20 onMouseOver="ShowTip(event, 'tt12', 'link20')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_InstanceTypeEnum" >LwM2M_InstanceTypeEnum</a></td><td class=SDescription>Possible types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link21 onMouseOver="ShowTip(event, 'tt12', 'link21')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a>&rsquo;s value</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_DataSamples" id=link22 onMouseOver="ShowTip(event, 'tt13', 'link22')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></td><td class=SDescription>Storing a list of resource values that can be played back to mimic resource value changes</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_DataSamples_List" id=link23 onMouseOver="ShowTip(event, 'tt14', 'link23')" onMouseOut="HideTip('tt14')">LwM2M_DataSamples_List</a></td><td class=SDescription>List of <a href="#LwM2M_DataSamples" class=LType id=link24 onMouseOver="ShowTip(event, 'tt13', 'link24')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_DataSamples_DB" id=link25 onMouseOver="ShowTip(event, 'tt15', 'link25')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_DataSamples" class=LType id=link26 onMouseOver="ShowTip(event, 'tt13', 'link26')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Object_Definitions"></a>EPTF_LwM2M_Object_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the smart object definitions for the LWM2M load generator component</p><h4 class=CHeading>Class Diagram</h4><img src="../images/EPTF_LwM2M_Object_Definitions.classes.jpg"><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Object_Definitions" >EPTF_LwM2M_Object_Definitions</a></td><td class=SDescription>This module contains the smart object definitions for the LWM2M load generator component</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectDB" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a></td><td class=SDescription>Storing <a href="#LwM2M_Object" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_Object_List" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">LwM2M_Object_List</a></td><td class=SDescription>List of <a href="#LwM2M_Object" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_Object" id=link5 onMouseOver="ShowTip(event, 'tt2', 'link5')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td><td class=SDescription>This structure models a LwM2M smart object</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectInstance" id=link6 onMouseOver="ShowTip(event, 'tt4', 'link6')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a></td><td class=SDescription>Models a smart object instance of a <a href="#LwM2M_Object" class=LType id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ResourceIdx_List" id=link8 onMouseOver="ShowTip(event, 'tt5', 'link8')" onMouseOut="HideTip('tt5')">LwM2M_ResourceIdx_List</a></td><td class=SDescription>List of <b>integer</b></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectInstance_List" id=link9 onMouseOver="ShowTip(event, 'tt6', 'link9')" onMouseOut="HideTip('tt6')">LwM2M_ObjectInstance_List</a></td><td class=SDescription>List of <a href="#LwM2M_ObjectInstance" class=LType id=link10 onMouseOver="ShowTip(event, 'tt4', 'link10')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectSpecificationDB" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a></td><td class=SDescription>Storing <a href="#LwM2M_ObjectSpecification" class=LType id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ObjectSpecification" id=link13 onMouseOver="ShowTip(event, 'tt8', 'link13')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></td><td class=SDescription>Defines a smart oject</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ObjectSpecification_List" id=link14 onMouseOver="ShowTip(event, 'tt9', 'link14')" onMouseOut="HideTip('tt9')">LwM2M_ObjectSpecification_List</a></td><td class=SDescription>List of <a href="#LwM2M_ObjectSpecification" class=LType id=link15 onMouseOver="ShowTip(event, 'tt8', 'link15')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_ResourceSpecification_List" id=link16 onMouseOver="ShowTip(event, 'tt10', 'link16')" onMouseOut="HideTip('tt10')">LwM2M_ResourceSpecification_List</a></td><td class=SDescription>List of <a href="#LwM2M_ResourceSpecification" class=LType id=link17 onMouseOver="ShowTip(event, 'tt11', 'link17')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_ResourceSpecification" id=link18 onMouseOver="ShowTip(event, 'tt11', 'link18')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></td><td class=SDescription>Defines a smart resource</td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_OperationTypeEnum" >LwM2M_OperationTypeEnum</a></td><td class=SDescription>Operation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></td></tr><tr class="SEnumeration SMarked"><td class=SEntry><a href="#LwM2M_InstanceTypeEnum" >LwM2M_InstanceTypeEnum</a></td><td class=SDescription>Instantiation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link20 onMouseOver="ShowTip(event, 'tt12', 'link20')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LwM2M_InstanceTypeEnum" >LwM2M_InstanceTypeEnum</a></td><td class=SDescription>Possible types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link21 onMouseOver="ShowTip(event, 'tt12', 'link21')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a>&rsquo;s value</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_DataSamples" id=link22 onMouseOver="ShowTip(event, 'tt13', 'link22')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></td><td class=SDescription>Storing a list of resource values that can be played back to mimic resource value changes</td></tr><tr class="SType"><td class=SEntry><a href="#LwM2M_DataSamples_List" id=link23 onMouseOver="ShowTip(event, 'tt14', 'link23')" onMouseOut="HideTip('tt14')">LwM2M_DataSamples_List</a></td><td class=SDescription>List of <a href="#LwM2M_DataSamples" class=LType id=link24 onMouseOver="ShowTip(event, 'tt13', 'link24')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LwM2M_DataSamples_DB" id=link25 onMouseOver="ShowTip(event, 'tt15', 'link25')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a></td><td class=SDescription>Storing <a href="#LwM2M_DataSamples" class=LType id=link26 onMouseOver="ShowTip(event, 'tt13', 'link26')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectDB"></a>LwM2M_ObjectDB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Object" class=LType id=link27 onMouseOver="ShowTip(event, 'tt2', 'link27')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_ObjectDB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the <a href="#LwM2M_ObjectDB" class=LType id=link28 onMouseOver="ShowTip(event, 'tt1', 'link28')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> instance</td></tr><tr><td class=CDLEntry>objs</td><td class=CDLDescription><a href="#LwM2M_Object_List" class=LType id=link29 onMouseOver="ShowTip(event, 'tt3', 'link29')" onMouseOut="HideTip('tt3')">LwM2M_Object_List</a> - object instance elements</td></tr><tr><td class=CDLEntry>resources</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=LType id=link30 onMouseOver="ShowTip(event, 'tt16', 'link30')" onMouseOut="HideTip('tt16')">LwM2M_Resource_List</a> - smart resource instance elements</td></tr><tr><td class=CDLEntry>objHashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_Object" class=LType id=link31 onMouseOver="ShowTip(event, 'tt2', 'link31')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</td></tr><tr><td class=CDLEntry>resHashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link32 onMouseOver="ShowTip(event, 'tt12', 'link32')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> instances</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=LFunction id=link33 onMouseOver="ShowTip(event, 'tt17', 'link33')" onMouseOut="HideTip('tt17')">f_LwM2M_ObjectDB_init</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link34 onMouseOver="ShowTip(event, 'tt1', 'link34')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=LFunction id=link35 onMouseOver="ShowTip(event, 'tt18', 'link35')" onMouseOut="HideTip('tt18')">f_LwM2M_ObjectDB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link36 onMouseOver="ShowTip(event, 'tt1', 'link36')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=LFunction id=link37 onMouseOver="ShowTip(event, 'tt19', 'link37')" onMouseOut="HideTip('tt19')">f_LwM2M_ObjectDB_createObject</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt1', 'link38')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="#LwM2M_ObjectSpecification" class=LType id=link39 onMouseOver="ShowTip(event, 'tt8', 'link39')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> p_spec)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=LFunction id=link40 onMouseOver="ShowTip(event, 'tt20', 'link40')" onMouseOut="HideTip('tt20')">f_LwM2M_ObjectDB_getObject</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link41 onMouseOver="ShowTip(event, 'tt1', 'link41')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id, <b>inout</b> <a href="#LwM2M_Object" class=LType id=link42 onMouseOver="ShowTip(event, 'tt2', 'link42')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> p_obj)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=LFunction id=link43 onMouseOver="ShowTip(event, 'tt21', 'link43')" onMouseOut="HideTip('tt21')">f_LwM2M_ObjectDB_getObjectIdx</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link44 onMouseOver="ShowTip(event, 'tt1', 'link44')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=LFunction id=link45 onMouseOver="ShowTip(event, 'tt22', 'link45')" onMouseOut="HideTip('tt22')">f_LwM2M_ObjectDB_createObjectInstance</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link46 onMouseOver="ShowTip(event, 'tt1', 'link46')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link47 onMouseOver="ShowTip(event, 'tt7', 'link47')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_spec_db, <b>in integer</b> p_id, <b>in boolean</b> p_createResources := true)</li><li>&lt;f_LwM2M_ObjectDB_addResource&gt; (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link48 onMouseOver="ShowTip(event, 'tt1', 'link48')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link49 onMouseOver="ShowTip(event, 'tt12', 'link49')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=LFunction id=link50 onMouseOver="ShowTip(event, 'tt23', 'link50')" onMouseOut="HideTip('tt23')">f_LwM2M_ObjectDB_getObjectInstance</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link51 onMouseOver="ShowTip(event, 'tt1', 'link51')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>inout</b> <a href="#LwM2M_ObjectInstance" class=LType id=link52 onMouseOver="ShowTip(event, 'tt4', 'link52')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a> p_objInst)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=LFunction id=link53 onMouseOver="ShowTip(event, 'tt24', 'link53')" onMouseOut="HideTip('tt24')">f_LwM2M_ObjectDB_getResource</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link54 onMouseOver="ShowTip(event, 'tt1', 'link54')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link55 onMouseOver="ShowTip(event, 'tt12', 'link55')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=LFunction id=link56 onMouseOver="ShowTip(event, 'tt25', 'link56')" onMouseOut="HideTip('tt25')">f_LwM2M_ObjectDB_setResource</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link57 onMouseOver="ShowTip(event, 'tt1', 'link57')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link58 onMouseOver="ShowTip(event, 'tt12', 'link58')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=LFunction id=link59 onMouseOver="ShowTip(event, 'tt26', 'link59')" onMouseOut="HideTip('tt26')">f_LwM2M_ObjectDB_getResourceValue</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link60 onMouseOver="ShowTip(event, 'tt1', 'link60')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link61 onMouseOver="ShowTip(event, 'tt27', 'link61')" onMouseOut="HideTip('tt27')">LwM2M_ResourceValue</a> p_value)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=LFunction id=link62 onMouseOver="ShowTip(event, 'tt28', 'link62')" onMouseOut="HideTip('tt28')">f_LwM2M_ObjectDB_setResourceValue</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link63 onMouseOver="ShowTip(event, 'tt1', 'link63')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link64 onMouseOver="ShowTip(event, 'tt27', 'link64')" onMouseOut="HideTip('tt27')">LwM2M_ResourceValue</a> p_value)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=LFunction id=link65 onMouseOver="ShowTip(event, 'tt29', 'link65')" onMouseOut="HideTip('tt29')">f_LwM2M_ObjectDB_setResourceObserved</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link66 onMouseOver="ShowTip(event, 'tt1', 'link66')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in boolean</b> p_observed)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=LFunction id=link67 onMouseOver="ShowTip(event, 'tt30', 'link67')" onMouseOut="HideTip('tt30')">f_LwM2M_ObjectDB_getObjectPaths</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link68 onMouseOver="ShowTip(event, 'tt1', 'link68')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link69 onMouseOver="ShowTip(event, 'tt31', 'link69')" onMouseOut="HideTip('tt31')">ObjectPath_List</a> p_paths)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectDB"></a>LwM2M_ObjectDB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_Object" class=LType id=link27 onMouseOver="ShowTip(event, 'tt2', 'link27')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectDB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the <a href="#LwM2M_ObjectDB" class=LType id=link28 onMouseOver="ShowTip(event, 'tt1', 'link28')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> instance</td></tr><tr><td class=CDLEntry>objs</td><td class=CDLDescription><a href="#LwM2M_Object_List" class=LType id=link29 onMouseOver="ShowTip(event, 'tt3', 'link29')" onMouseOut="HideTip('tt3')">LwM2M_Object_List</a> - object instance elements</td></tr><tr><td class=CDLEntry>resources</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=LType id=link30 onMouseOver="ShowTip(event, 'tt16', 'link30')" onMouseOut="HideTip('tt16')">LwM2M_Resource_List</a> - smart resource instance elements</td></tr><tr><td class=CDLEntry>objHashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_Object" class=LType id=link31 onMouseOver="ShowTip(event, 'tt2', 'link31')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> instances</td></tr><tr><td class=CDLEntry>resHashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link32 onMouseOver="ShowTip(event, 'tt12', 'link32')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> instances</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=LFunction id=link33 onMouseOver="ShowTip(event, 'tt17', 'link33')" onMouseOut="HideTip('tt17')">f_LwM2M_ObjectDB_init</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link34 onMouseOver="ShowTip(event, 'tt1', 'link34')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=LFunction id=link35 onMouseOver="ShowTip(event, 'tt18', 'link35')" onMouseOut="HideTip('tt18')">f_LwM2M_ObjectDB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link36 onMouseOver="ShowTip(event, 'tt1', 'link36')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=LFunction id=link37 onMouseOver="ShowTip(event, 'tt19', 'link37')" onMouseOut="HideTip('tt19')">f_LwM2M_ObjectDB_createObject</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt1', 'link38')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="#LwM2M_ObjectSpecification" class=LType id=link39 onMouseOver="ShowTip(event, 'tt8', 'link39')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> p_spec)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=LFunction id=link40 onMouseOver="ShowTip(event, 'tt20', 'link40')" onMouseOut="HideTip('tt20')">f_LwM2M_ObjectDB_getObject</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link41 onMouseOver="ShowTip(event, 'tt1', 'link41')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id, <b>inout</b> <a href="#LwM2M_Object" class=LType id=link42 onMouseOver="ShowTip(event, 'tt2', 'link42')" onMouseOut="HideTip('tt2')">LwM2M_Object</a> p_obj)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=LFunction id=link43 onMouseOver="ShowTip(event, 'tt21', 'link43')" onMouseOut="HideTip('tt21')">f_LwM2M_ObjectDB_getObjectIdx</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link44 onMouseOver="ShowTip(event, 'tt1', 'link44')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=LFunction id=link45 onMouseOver="ShowTip(event, 'tt22', 'link45')" onMouseOut="HideTip('tt22')">f_LwM2M_ObjectDB_createObjectInstance</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link46 onMouseOver="ShowTip(event, 'tt1', 'link46')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link47 onMouseOver="ShowTip(event, 'tt7', 'link47')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_spec_db, <b>in integer</b> p_id, <b>in boolean</b> p_createResources := true)</li><li>&lt;f_LwM2M_ObjectDB_addResource&gt; (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link48 onMouseOver="ShowTip(event, 'tt1', 'link48')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link49 onMouseOver="ShowTip(event, 'tt12', 'link49')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=LFunction id=link50 onMouseOver="ShowTip(event, 'tt23', 'link50')" onMouseOut="HideTip('tt23')">f_LwM2M_ObjectDB_getObjectInstance</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link51 onMouseOver="ShowTip(event, 'tt1', 'link51')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>inout</b> <a href="#LwM2M_ObjectInstance" class=LType id=link52 onMouseOver="ShowTip(event, 'tt4', 'link52')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a> p_objInst)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=LFunction id=link53 onMouseOver="ShowTip(event, 'tt24', 'link53')" onMouseOut="HideTip('tt24')">f_LwM2M_ObjectDB_getResource</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link54 onMouseOver="ShowTip(event, 'tt1', 'link54')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link55 onMouseOver="ShowTip(event, 'tt12', 'link55')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=LFunction id=link56 onMouseOver="ShowTip(event, 'tt25', 'link56')" onMouseOut="HideTip('tt25')">f_LwM2M_ObjectDB_setResource</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link57 onMouseOver="ShowTip(event, 'tt1', 'link57')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link58 onMouseOver="ShowTip(event, 'tt12', 'link58')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a> p_resource)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=LFunction id=link59 onMouseOver="ShowTip(event, 'tt26', 'link59')" onMouseOut="HideTip('tt26')">f_LwM2M_ObjectDB_getResourceValue</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link60 onMouseOver="ShowTip(event, 'tt1', 'link60')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link61 onMouseOver="ShowTip(event, 'tt27', 'link61')" onMouseOut="HideTip('tt27')">LwM2M_ResourceValue</a> p_value)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=LFunction id=link62 onMouseOver="ShowTip(event, 'tt28', 'link62')" onMouseOut="HideTip('tt28')">f_LwM2M_ObjectDB_setResourceValue</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link63 onMouseOver="ShowTip(event, 'tt1', 'link63')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link64 onMouseOver="ShowTip(event, 'tt27', 'link64')" onMouseOut="HideTip('tt27')">LwM2M_ResourceValue</a> p_value)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=LFunction id=link65 onMouseOver="ShowTip(event, 'tt29', 'link65')" onMouseOut="HideTip('tt29')">f_LwM2M_ObjectDB_setResourceObserved</a> (<b>inout</b> <a href="#LwM2M_ObjectDB" class=LType id=link66 onMouseOver="ShowTip(event, 'tt1', 'link66')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>in integer</b> p_objId, <b>in integer</b> p_objInstId, <b>in integer</b> p_resourceId, <b>in boolean</b> p_observed)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=LFunction id=link67 onMouseOver="ShowTip(event, 'tt30', 'link67')" onMouseOut="HideTip('tt30')">f_LwM2M_ObjectDB_getObjectPaths</a> (<b>in</b> <a href="#LwM2M_ObjectDB" class=LType id=link68 onMouseOver="ShowTip(event, 'tt1', 'link68')" onMouseOut="HideTip('tt1')">LwM2M_ObjectDB</a> p_db, <b>inout</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link69 onMouseOver="ShowTip(event, 'tt31', 'link69')" onMouseOut="HideTip('tt31')">ObjectPath_List</a> p_paths)</li></ul></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Object_List"></a>LwM2M_Object_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_Object" class=LType id=link70 onMouseOver="ShowTip(event, 'tt2', 'link70')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Object"></a>LwM2M_Object</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This structure models a LwM2M smart object</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_Object.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - smart object id</td></tr><tr><td class=CDLEntry>instances</td><td class=CDLDescription><a href="#LwM2M_ObjectInstance_List" class=LType id=link71 onMouseOver="ShowTip(event, 'tt6', 'link71')" onMouseOut="HideTip('tt6')">LwM2M_ObjectInstance_List</a> - objec instances of the smart object</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_Object"></a>LwM2M_Object</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>This structure models a LwM2M smart object</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_Object.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - smart object id</td></tr><tr><td class=CDLEntry>instances</td><td class=CDLDescription><a href="#LwM2M_ObjectInstance_List" class=LType id=link71 onMouseOver="ShowTip(event, 'tt6', 'link71')" onMouseOut="HideTip('tt6')">LwM2M_ObjectInstance_List</a> - objec instances of the smart object</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectInstance"></a>LwM2M_ObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Models a smart object instance of a <a href="#LwM2M_Object" class=LType id=link72 onMouseOver="ShowTip(event, 'tt2', 'link72')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_ObjectInstance.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - instance id of the <a href="#LwM2M_Object" class=LType id=link73 onMouseOver="ShowTip(event, 'tt2', 'link73')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr><td class=CDLEntry>objId</td><td class=CDLDescription><b>integer</b> - object id of the parent <a href="#LwM2M_Object" class=LType id=link74 onMouseOver="ShowTip(event, 'tt2', 'link74')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr><td class=CDLEntry>resources</td><td class=CDLDescription><a href="#LwM2M_ResourceIdx_List" class=LType id=link75 onMouseOver="ShowTip(event, 'tt5', 'link75')" onMouseOut="HideTip('tt5')">LwM2M_ResourceIdx_List</a> - pointers to the resources of the object instance&rsquo;s own resources (stored in the parent <a href="#LwM2M_Object" class=LType id=link76 onMouseOver="ShowTip(event, 'tt2', 'link76')" onMouseOut="HideTip('tt2')">LwM2M_Object</a>.resources)</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=LFunction id=link77 onMouseOver="ShowTip(event, 'tt32', 'link77')" onMouseOut="HideTip('tt32')">f_LwM2M_createResource</a> (<b>inout</b> <a href="#LwM2M_ObjectInstance" class=LType id=link78 onMouseOver="ShowTip(event, 'tt4', 'link78')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a> p_oi, <b>in</b> <a href="#LwM2M_ResourceSpecification" class=LType id=link79 onMouseOver="ShowTip(event, 'tt11', 'link79')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a> p_spec)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectInstance"></a>LwM2M_ObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Models a smart object instance of a <a href="#LwM2M_Object" class=LType id=link72 onMouseOver="ShowTip(event, 'tt2', 'link72')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectInstance.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - instance id of the <a href="#LwM2M_Object" class=LType id=link73 onMouseOver="ShowTip(event, 'tt2', 'link73')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr><td class=CDLEntry>objId</td><td class=CDLDescription><b>integer</b> - object id of the parent <a href="#LwM2M_Object" class=LType id=link74 onMouseOver="ShowTip(event, 'tt2', 'link74')" onMouseOut="HideTip('tt2')">LwM2M_Object</a></td></tr><tr><td class=CDLEntry>resources</td><td class=CDLDescription><a href="#LwM2M_ResourceIdx_List" class=LType id=link75 onMouseOver="ShowTip(event, 'tt5', 'link75')" onMouseOut="HideTip('tt5')">LwM2M_ResourceIdx_List</a> - pointers to the resources of the object instance&rsquo;s own resources (stored in the parent <a href="#LwM2M_Object" class=LType id=link76 onMouseOver="ShowTip(event, 'tt2', 'link76')" onMouseOut="HideTip('tt2')">LwM2M_Object</a>.resources)</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=LFunction id=link77 onMouseOver="ShowTip(event, 'tt32', 'link77')" onMouseOut="HideTip('tt32')">f_LwM2M_createResource</a> (<b>inout</b> <a href="#LwM2M_ObjectInstance" class=LType id=link78 onMouseOver="ShowTip(event, 'tt4', 'link78')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a> p_oi, <b>in</b> <a href="#LwM2M_ResourceSpecification" class=LType id=link79 onMouseOver="ShowTip(event, 'tt11', 'link79')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a> p_spec)</li></ul></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ResourceIdx_List"></a>LwM2M_ResourceIdx_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <b>integer</b></p></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectInstance_List"></a>LwM2M_ObjectInstance_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_ObjectInstance" class=LType id=link80 onMouseOver="ShowTip(event, 'tt4', 'link80')" onMouseOut="HideTip('tt4')">LwM2M_ObjectInstance</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecificationDB"></a>LwM2M_ObjectSpecificationDB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_ObjectSpecification" class=LType id=link81 onMouseOver="ShowTip(event, 'tt8', 'link81')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecificationDB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link82 onMouseOver="ShowTip(event, 'tt7', 'link82')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> instance</td></tr><tr><td class=CDLEntry>specs</td><td class=CDLDescription><a href="#LwM2M_ObjectSpecification_List" class=LType id=link83 onMouseOver="ShowTip(event, 'tt9', 'link83')" onMouseOut="HideTip('tt9')">LwM2M_ObjectSpecification_List</a> - the stored <a href="#LwM2M_ObjectSpecification" class=LType id=link84 onMouseOver="ShowTip(event, 'tt8', 'link84')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</td></tr><tr><td class=CDLEntry>hashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_ObjectSpecification" class=LType id=link85 onMouseOver="ShowTip(event, 'tt8', 'link85')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances based on their id</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=LFunction id=link86 onMouseOver="ShowTip(event, 'tt33', 'link86')" onMouseOut="HideTip('tt33')">f_LwM2M_ObjectSpecificationDB_init</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link87 onMouseOver="ShowTip(event, 'tt7', 'link87')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=LFunction id=link88 onMouseOver="ShowTip(event, 'tt34', 'link88')" onMouseOut="HideTip('tt34')">f_LwM2M_ObjectSpecificationDB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link89 onMouseOver="ShowTip(event, 'tt7', 'link89')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=LFunction id=link90 onMouseOver="ShowTip(event, 'tt35', 'link90')" onMouseOut="HideTip('tt35')">f_LwM2M_ObjectSpecificationDB_add</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link91 onMouseOver="ShowTip(event, 'tt7', 'link91')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <a href="#LwM2M_ObjectSpecification" class=LType id=link92 onMouseOver="ShowTip(event, 'tt8', 'link92')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> p_spec)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=LFunction id=link93 onMouseOver="ShowTip(event, 'tt36', 'link93')" onMouseOut="HideTip('tt36')">f_LwM2M_ObjectSpecificationDB_lookUp</a> (<b>in</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link94 onMouseOver="ShowTip(event, 'tt7', 'link94')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <b>in integer</b> p_objId)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=LFunction id=link95 onMouseOver="ShowTip(event, 'tt37', 'link95')" onMouseOut="HideTip('tt37')">f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link96 onMouseOver="ShowTip(event, 'tt7', 'link96')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecificationDB"></a>LwM2M_ObjectSpecificationDB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_ObjectSpecification" class=LType id=link81 onMouseOver="ShowTip(event, 'tt8', 'link81')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecificationDB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link82 onMouseOver="ShowTip(event, 'tt7', 'link82')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> instance</td></tr><tr><td class=CDLEntry>specs</td><td class=CDLDescription><a href="#LwM2M_ObjectSpecification_List" class=LType id=link83 onMouseOver="ShowTip(event, 'tt9', 'link83')" onMouseOut="HideTip('tt9')">LwM2M_ObjectSpecification_List</a> - the stored <a href="#LwM2M_ObjectSpecification" class=LType id=link84 onMouseOver="ShowTip(event, 'tt8', 'link84')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances</td></tr><tr><td class=CDLEntry>hashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_ObjectSpecification" class=LType id=link85 onMouseOver="ShowTip(event, 'tt8', 'link85')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> instances based on their id</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=LFunction id=link86 onMouseOver="ShowTip(event, 'tt33', 'link86')" onMouseOut="HideTip('tt33')">f_LwM2M_ObjectSpecificationDB_init</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link87 onMouseOver="ShowTip(event, 'tt7', 'link87')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <b>in integer</b> p_id)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=LFunction id=link88 onMouseOver="ShowTip(event, 'tt34', 'link88')" onMouseOut="HideTip('tt34')">f_LwM2M_ObjectSpecificationDB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link89 onMouseOver="ShowTip(event, 'tt7', 'link89')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=LFunction id=link90 onMouseOver="ShowTip(event, 'tt35', 'link90')" onMouseOut="HideTip('tt35')">f_LwM2M_ObjectSpecificationDB_add</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link91 onMouseOver="ShowTip(event, 'tt7', 'link91')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <a href="#LwM2M_ObjectSpecification" class=LType id=link92 onMouseOver="ShowTip(event, 'tt8', 'link92')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a> p_spec)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=LFunction id=link93 onMouseOver="ShowTip(event, 'tt36', 'link93')" onMouseOut="HideTip('tt36')">f_LwM2M_ObjectSpecificationDB_lookUp</a> (<b>in</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link94 onMouseOver="ShowTip(event, 'tt7', 'link94')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db, <b>in integer</b> p_objId)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" class=LFunction id=link95 onMouseOver="ShowTip(event, 'tt37', 'link95')" onMouseOut="HideTip('tt37')">f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a> (<a href="#LwM2M_ObjectSpecificationDB" class=LType id=link96 onMouseOver="ShowTip(event, 'tt7', 'link96')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_spec_db, <b>integer</b> p_objId, <b>integer</b> p_resId, <b>inout</b> <a href="#LwM2M_ResourceSpecification" class=LType id=link97 onMouseOver="ShowTip(event, 'tt11', 'link97')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a> p_spec)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=LFunction id=link98 onMouseOver="ShowTip(event, 'tt38', 'link98')" onMouseOut="HideTip('tt38')">f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a> (<b>inout</b> <a href="#LwM2M_ObjectSpecificationDB" class=LType id=link99 onMouseOver="ShowTip(event, 'tt7', 'link99')" onMouseOut="HideTip('tt7')">LwM2M_ObjectSpecificationDB</a> p_db)</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecification"></a>LwM2M_ObjectSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Defines a smart oject</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecification.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - name of the smart object</td></tr><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the smart object</td></tr><tr><td class=CDLEntry>instancetype</td><td class=CDLDescription><a href="#LwM2M_InstanceTypeEnum" class=LType id=link97 onMouseOver="ShowTip(event, 'tt38', 'link97')" onMouseOut="HideTip('tt38')">LwM2M_InstanceTypeEnum</a> - instantiation restrictions</td></tr><tr><td class=CDLEntry>mandatory</td><td class=CDLDescription><b>boolean</b> - shall it be supported by a device in a compulsory fashion?</td></tr><tr><td class=CDLEntry>description</td><td class=CDLDescription><b>charstring</b> - textual description (purpose) of the smart boject definition</td></tr><tr><td class=CDLEntry>resourcedefs</td><td class=CDLDescription><a href="#LwM2M_ResourceSpecification_List" class=LType id=link98 onMouseOver="ShowTip(event, 'tt10', 'link98')" onMouseOut="HideTip('tt10')">LwM2M_ResourceSpecification_List</a> - resource definitions used by the smart boject</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecification"></a>LwM2M_ObjectSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Defines a smart oject</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecification.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - name of the smart object</td></tr><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the smart object</td></tr><tr><td class=CDLEntry>instancetype</td><td class=CDLDescription><a href="#LwM2M_InstanceTypeEnum" class=LType id=link100 onMouseOver="ShowTip(event, 'tt39', 'link100')" onMouseOut="HideTip('tt39')">LwM2M_InstanceTypeEnum</a> - instantiation restrictions</td></tr><tr><td class=CDLEntry>mandatory</td><td class=CDLDescription><b>boolean</b> - shall it be supported by a device in a compulsory fashion?</td></tr><tr><td class=CDLEntry>description</td><td class=CDLDescription><b>charstring</b> - textual description (purpose) of the smart boject definition</td></tr><tr><td class=CDLEntry>resourcedefs</td><td class=CDLDescription><a href="#LwM2M_ResourceSpecification_List" class=LType id=link101 onMouseOver="ShowTip(event, 'tt10', 'link101')" onMouseOut="HideTip('tt10')">LwM2M_ResourceSpecification_List</a> - resource definitions used by the smart boject</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecification_List"></a>LwM2M_ObjectSpecification_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_ObjectSpecification" class=LType id=link99 onMouseOver="ShowTip(event, 'tt8', 'link99')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></p></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ObjectSpecification_List"></a>LwM2M_ObjectSpecification_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_ObjectSpecification" class=LType id=link102 onMouseOver="ShowTip(event, 'tt8', 'link102')" onMouseOut="HideTip('tt8')">LwM2M_ObjectSpecification</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ResourceSpecification_List"></a>LwM2M_ResourceSpecification_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_ResourceSpecification" class=LType id=link100 onMouseOver="ShowTip(event, 'tt11', 'link100')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></p></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ResourceSpecification_List"></a>LwM2M_ResourceSpecification_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_ResourceSpecification" class=LType id=link103 onMouseOver="ShowTip(event, 'tt11', 'link103')" onMouseOut="HideTip('tt11')">LwM2M_ResourceSpecification</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ResourceSpecification"></a>LwM2M_ResourceSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Defines a smart resource</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_ResourceSpecification.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - name of the smart resource</td></tr><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the smart resource</td></tr><tr><td class=CDLEntry>operations</td><td class=CDLDescription><a href="#LwM2M_OperationTypeEnum" class=LType id=link101 onMouseOver="ShowTip(event, 'tt39', 'link101')" onMouseOut="HideTip('tt39')">LwM2M_OperationTypeEnum</a> - allowed operations on the resource</td></tr><tr><td class=CDLEntry>instancetype</td><td class=CDLDescription><a href="#LwM2M_InstanceTypeEnum" class=LType id=link102 onMouseOver="ShowTip(event, 'tt38', 'link102')" onMouseOut="HideTip('tt38')">LwM2M_InstanceTypeEnum</a> - instantiation restrictions</td></tr><tr><td class=CDLEntry>mandatory</td><td class=CDLDescription><b>boolean</b> - shall it be supported by a device in a compulsory fashion?</td></tr><tr><td class=CDLEntry>type_</td><td class=CDLDescription>&lt;LwM2M_TypeEnum&gt; - type of the resource value</td></tr><tr><td class=CDLEntry>range</td><td class=CDLDescription><b>charstring</b> - the allowed value range of the resource</td></tr><tr><td class=CDLEntry>units</td><td class=CDLDescription><b>charstring</b> - units of the resource value</td></tr><tr><td class=CDLEntry>description</td><td class=CDLDescription><b>charstring</b> - textual description (purpose) of the smart boject definition</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_ResourceSpecification"></a>LwM2M_ResourceSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Defines a smart resource</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_ResourceSpecification.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - name of the smart resource</td></tr><tr><td class=CDLEntry>id</td><td class=CDLDescription><b>integer</b> - unique id of the smart resource</td></tr><tr><td class=CDLEntry>operations</td><td class=CDLDescription><a href="#LwM2M_OperationTypeEnum" class=LType id=link104 onMouseOver="ShowTip(event, 'tt40', 'link104')" onMouseOut="HideTip('tt40')">LwM2M_OperationTypeEnum</a> - allowed operations on the resource</td></tr><tr><td class=CDLEntry>instancetype</td><td class=CDLDescription><a href="#LwM2M_InstanceTypeEnum" class=LType id=link105 onMouseOver="ShowTip(event, 'tt39', 'link105')" onMouseOut="HideTip('tt39')">LwM2M_InstanceTypeEnum</a> - instantiation restrictions</td></tr><tr><td class=CDLEntry>mandatory</td><td class=CDLDescription><b>boolean</b> - shall it be supported by a device in a compulsory fashion?</td></tr><tr><td class=CDLEntry>type_</td><td class=CDLDescription>&lt;LwM2M_TypeEnum&gt; - type of the resource value</td></tr><tr><td class=CDLEntry>range</td><td class=CDLDescription><b>charstring</b> - the allowed value range of the resource</td></tr><tr><td class=CDLEntry>units</td><td class=CDLDescription><b>charstring</b> - units of the resource value</td></tr><tr><td class=CDLEntry>description</td><td class=CDLDescription><b>charstring</b> - textual description (purpose) of the smart boject definition</td></tr></table></div></div></div>
 
-<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_OperationTypeEnum"></a>LwM2M_OperationTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Operation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link103 onMouseOver="ShowTip(event, 'tt12', 'link103')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></p><h4 class=CHeading>Elements</h4><ul><li>NONE</li><li>W</li><li>R</li><li>RW</li><li>RE</li><li>E</li><li>RWE</li></ul></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_OperationTypeEnum"></a>LwM2M_OperationTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Operation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link106 onMouseOver="ShowTip(event, 'tt12', 'link106')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></p><h4 class=CHeading>Elements</h4><ul><li>NONE</li><li>W</li><li>R</li><li>RW</li><li>RE</li><li>E</li><li>RWE</li></ul></div></div></div>
 
-<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_InstanceTypeEnum"></a>LwM2M_InstanceTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Instantiation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link104 onMouseOver="ShowTip(event, 'tt12', 'link104')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></p><h4 class=CHeading>Elements</h4><ul><li>SINGLE</li><li>MULTIPLE</li></ul></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_InstanceTypeEnum"></a>LwM2M_InstanceTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Instantiation types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link107 onMouseOver="ShowTip(event, 'tt12', 'link107')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a></p><h4 class=CHeading>Elements</h4><ul><li>SINGLE</li><li>MULTIPLE</li></ul></div></div></div>
 
-<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_InstanceTypeEnum"></a>LwM2M_InstanceTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Possible types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link105 onMouseOver="ShowTip(event, 'tt12', 'link105')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a>&rsquo;s value</p><h4 class=CHeading>Elements</h4><ul><li>STRING</li><li>FLOAT</li><li>BOOLEAN</li><li>INTEGER</li><li>OPAQUE</li><li>TIME</li><li>NONE</li></ul></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LwM2M_InstanceTypeEnum"></a>LwM2M_InstanceTypeEnum</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Possible types of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link108 onMouseOver="ShowTip(event, 'tt12', 'link108')" onMouseOut="HideTip('tt12')">LwM2M_Resource</a>&rsquo;s value</p><h4 class=CHeading>Elements</h4><ul><li>STRING</li><li>FLOAT</li><li>BOOLEAN</li><li>INTEGER</li><li>OPAQUE</li><li>TIME</li><li>NONE</li></ul></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples"></a>LwM2M_DataSamples</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing a list of resource values that can be played back to mimic resource value changes</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - unique name of the data samples</td></tr><tr><td class=CDLEntry>values</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=LType id=link106 onMouseOver="ShowTip(event, 'tt40', 'link106')" onMouseOut="HideTip('tt40')">LwM2M_ResourceValue_List</a> - data samples consisting of resource values</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples"></a>LwM2M_DataSamples</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing a list of resource values that can be played back to mimic resource value changes</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - unique name of the data samples</td></tr><tr><td class=CDLEntry>values</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=LType id=link109 onMouseOver="ShowTip(event, 'tt41', 'link109')" onMouseOut="HideTip('tt41')">LwM2M_ResourceValue_List</a> - data samples consisting of resource values</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples_List"></a>LwM2M_DataSamples_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_DataSamples" class=LType id=link107 onMouseOver="ShowTip(event, 'tt13', 'link107')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></p></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples_List"></a>LwM2M_DataSamples_List</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>List of <a href="#LwM2M_DataSamples" class=LType id=link110 onMouseOver="ShowTip(event, 'tt13', 'link110')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a></p></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples_DB"></a>LwM2M_DataSamples_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_DataSamples" class=LType id=link108 onMouseOver="ShowTip(event, 'tt13', 'link108')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples_DB.jpg)</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - unique name of the data samples database</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_DataSamples_List" class=LType id=link109 onMouseOver="ShowTip(event, 'tt14', 'link109')" onMouseOut="HideTip('tt14')">LwM2M_DataSamples_List</a> - elements</td></tr><tr><td class=CDLEntry>hashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_DataSamples" class=LType id=link110 onMouseOver="ShowTip(event, 'tt13', 'link110')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=LFunction id=link111 onMouseOver="ShowTip(event, 'tt41', 'link111')" onMouseOut="HideTip('tt41')">f_LwM2M_DataSamples_DB_init</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link112 onMouseOver="ShowTip(event, 'tt15', 'link112')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in charstring</b> p_name)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=LFunction id=link113 onMouseOver="ShowTip(event, 'tt42', 'link113')" onMouseOut="HideTip('tt42')">f_LwM2M_DataSamples_DB_add</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link114 onMouseOver="ShowTip(event, 'tt15', 'link114')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in</b> <a href="#LwM2M_DataSamples" class=LType id=link115 onMouseOver="ShowTip(event, 'tt13', 'link115')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> p_samples)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=LFunction id=link116 onMouseOver="ShowTip(event, 'tt43', 'link116')" onMouseOut="HideTip('tt43')">f_LwM2M_DataSamples_DB_lookUp</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link117 onMouseOver="ShowTip(event, 'tt15', 'link117')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in charstring</b> p_sampleName)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=LFunction id=link118 onMouseOver="ShowTip(event, 'tt44', 'link118')" onMouseOut="HideTip('tt44')">f_LwM2M_DataSamples_DB_get</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link119 onMouseOver="ShowTip(event, 'tt15', 'link119')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in integer</b> p_idx, <b>inout</b> <a href="#LwM2M_DataSamples" class=LType id=link120 onMouseOver="ShowTip(event, 'tt13', 'link120')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> p_samples)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=LFunction id=link121 onMouseOver="ShowTip(event, 'tt45', 'link121')" onMouseOut="HideTip('tt45')">f_LwM2M_DataSamples_DB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link122 onMouseOver="ShowTip(event, 'tt15', 'link122')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db)</li></ul></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LwM2M_DataSamples_DB"></a>LwM2M_DataSamples_DB</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Storing <a href="#LwM2M_DataSamples" class=LType id=link111 onMouseOver="ShowTip(event, 'tt13', 'link111')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples_DB.jpg"><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>name</td><td class=CDLDescription><b>charstring</b> - unique name of the data samples database</td></tr><tr><td class=CDLEntry>data</td><td class=CDLDescription><a href="#LwM2M_DataSamples_List" class=LType id=link112 onMouseOver="ShowTip(event, 'tt14', 'link112')" onMouseOut="HideTip('tt14')">LwM2M_DataSamples_List</a> - elements</td></tr><tr><td class=CDLEntry>hashRef</td><td class=CDLDescription><b>integer</b> - hashmap id for looking up <a href="#LwM2M_DataSamples" class=LType id=link113 onMouseOver="ShowTip(event, 'tt13', 'link113')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> instances</td></tr></table><h4 class=CHeading>Related Functions</h4><ul><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=LFunction id=link114 onMouseOver="ShowTip(event, 'tt42', 'link114')" onMouseOut="HideTip('tt42')">f_LwM2M_DataSamples_DB_init</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link115 onMouseOver="ShowTip(event, 'tt15', 'link115')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in charstring</b> p_name)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=LFunction id=link116 onMouseOver="ShowTip(event, 'tt43', 'link116')" onMouseOut="HideTip('tt43')">f_LwM2M_DataSamples_DB_add</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link117 onMouseOver="ShowTip(event, 'tt15', 'link117')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in</b> <a href="#LwM2M_DataSamples" class=LType id=link118 onMouseOver="ShowTip(event, 'tt13', 'link118')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> p_samples)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=LFunction id=link119 onMouseOver="ShowTip(event, 'tt44', 'link119')" onMouseOut="HideTip('tt44')">f_LwM2M_DataSamples_DB_lookUp</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link120 onMouseOver="ShowTip(event, 'tt15', 'link120')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in charstring</b> p_sampleName)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=LFunction id=link121 onMouseOver="ShowTip(event, 'tt45', 'link121')" onMouseOut="HideTip('tt45')">f_LwM2M_DataSamples_DB_get</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link122 onMouseOver="ShowTip(event, 'tt15', 'link122')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db, <b>in integer</b> p_idx, <b>inout</b> <a href="#LwM2M_DataSamples" class=LType id=link123 onMouseOver="ShowTip(event, 'tt13', 'link123')" onMouseOut="HideTip('tt13')">LwM2M_DataSamples</a> p_samples)</li><li><a href="EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=LFunction id=link124 onMouseOver="ShowTip(event, 'tt46', 'link124')" onMouseOut="HideTip('tt46')">f_LwM2M_DataSamples_DB_cleanUp</a> (<b>inout</b> <a href="#LwM2M_DataSamples_DB" class=LType id=link125 onMouseOver="ShowTip(event, 'tt15', 'link125')" onMouseOut="HideTip('tt15')">LwM2M_DataSamples_DB</a> p_db)</li></ul></div></div></div>
 
 </div><!--Content-->
 
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt10"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt12"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt15"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt16"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt27"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_observed</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt31"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt38"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt39"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt40"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt44"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt10"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt12"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt15"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt16"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt27"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resourceId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_observed,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in template integer&nbsp;</td><td class="PType  prettyprint " nowrap>p_contentFormat&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> omit</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt31"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_ResourceSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt39"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt40"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt41"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt44"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><!--END_ND_TOOLTIPS-->
 
 <script language=JavaScript><!--
 if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/EPTF_LwM2M_Object_Functions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_Object_Functions-ttcn.html
index e66e710..234f8c0 100644
--- a/apidoc/html/files/EPTF_LwM2M_Object_Functions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_Object_Functions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Object_Functions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Object_Functions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -9,70 +9,76 @@
 
 
 
-<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Object_Functions"></a>EPTF_LwM2M_Object_Functions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the functions of the smart object definitions for the LWM2M load generator component</p><h4 class=CHeading>See also</h4><p>&lt;EPTF_COAP_LGen_Definitions&gt;</p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Object_Functions" >EPTF_LwM2M_Object_Functions</a></td><td class=SDescription>This module contains the functions of the smart object definitions for the LWM2M load generator component</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_init" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">f_LwM2M_ObjectSpecificationDB_init</a></td><td class=SDescription>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">f_LwM2M_ObjectSpecificationDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_add" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">f_LwM2M_ObjectSpecificationDB_add</a></td><td class=SDescription>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link6 onMouseOver="ShowTip(event, 'tt5', 'link6')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_lookUp" id=link8 onMouseOver="ShowTip(event, 'tt6', 'link8')" onMouseOut="HideTip('tt6')">f_LwM2M_ObjectSpecificationDB_lookUp</a></td><td class=SDescription>Gets the index of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link9 onMouseOver="ShowTip(event, 'tt5', 'link9')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link10 onMouseOver="ShowTip(event, 'tt2', 'link10')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td><td class=SDescription>Loads known OMA related <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link12 onMouseOver="ShowTip(event, 'tt5', 'link12')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> elements into the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link13 onMouseOver="ShowTip(event, 'tt2', 'link13')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_init" id=link14 onMouseOver="ShowTip(event, 'tt8', 'link14')" onMouseOut="HideTip('tt8')">f_LwM2M_ObjectDB_init</a></td><td class=SDescription>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link15 onMouseOver="ShowTip(event, 'tt9', 'link15')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_cleanUp" id=link16 onMouseOver="ShowTip(event, 'tt10', 'link16')" onMouseOut="HideTip('tt10')">f_LwM2M_ObjectDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link17 onMouseOver="ShowTip(event, 'tt9', 'link17')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObject" id=link18 onMouseOver="ShowTip(event, 'tt11', 'link18')" onMouseOut="HideTip('tt11')">f_LwM2M_ObjectDB_createObject</a></td><td class=SDescription>Creates a new instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> and adds it to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link20 onMouseOver="ShowTip(event, 'tt9', 'link20')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObject" id=link21 onMouseOver="ShowTip(event, 'tt13', 'link21')" onMouseOut="HideTip('tt13')">f_LwM2M_ObjectDB_getObject</a></td><td class=SDescription>Retrieves an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link22 onMouseOver="ShowTip(event, 'tt12', 'link22')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link23 onMouseOver="ShowTip(event, 'tt9', 'link23')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectIdx" id=link24 onMouseOver="ShowTip(event, 'tt14', 'link24')" onMouseOut="HideTip('tt14')">f_LwM2M_ObjectDB_getObjectIdx</a></td><td class=SDescription>Retrieves the index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link25 onMouseOver="ShowTip(event, 'tt12', 'link25')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link26 onMouseOver="ShowTip(event, 'tt9', 'link26')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObjectInstance" id=link27 onMouseOver="ShowTip(event, 'tt15', 'link27')" onMouseOut="HideTip('tt15')">f_LwM2M_ObjectDB_createObjectInstance</a></td><td class=SDescription>Creates an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link28 onMouseOver="ShowTip(event, 'tt16', 'link28')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link29 onMouseOver="ShowTip(event, 'tt12', 'link29')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link30 onMouseOver="ShowTip(event, 'tt9', 'link30')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObjectInstance" >f_LwM2M_ObjectDB_createObjectInstance</a></td><td class=SDescription>Links in an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link31 onMouseOver="ShowTip(event, 'tt17', 'link31')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link32 onMouseOver="ShowTip(event, 'tt9', 'link32')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectInstance" id=link33 onMouseOver="ShowTip(event, 'tt18', 'link33')" onMouseOut="HideTip('tt18')">f_LwM2M_ObjectDB_getObjectInstance</a></td><td class=SDescription>Retrieves an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link34 onMouseOver="ShowTip(event, 'tt16', 'link34')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link35 onMouseOver="ShowTip(event, 'tt9', 'link35')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getResource" id=link36 onMouseOver="ShowTip(event, 'tt19', 'link36')" onMouseOut="HideTip('tt19')">f_LwM2M_ObjectDB_getResource</a></td><td class=SDescription>Retrieves an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link37 onMouseOver="ShowTip(event, 'tt17', 'link37')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt9', 'link38')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResource" id=link39 onMouseOver="ShowTip(event, 'tt20', 'link39')" onMouseOut="HideTip('tt20')">f_LwM2M_ObjectDB_setResource</a></td><td class=SDescription>Updates the contents of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link40 onMouseOver="ShowTip(event, 'tt17', 'link40')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link41 onMouseOver="ShowTip(event, 'tt9', 'link41')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getResourceValue" id=link42 onMouseOver="ShowTip(event, 'tt21', 'link42')" onMouseOut="HideTip('tt21')">f_LwM2M_ObjectDB_getResourceValue</a></td><td class=SDescription>Retrieves the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link43 onMouseOver="ShowTip(event, 'tt22', 'link43')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link44 onMouseOver="ShowTip(event, 'tt17', 'link44')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link45 onMouseOver="ShowTip(event, 'tt9', 'link45')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResourceValue" id=link46 onMouseOver="ShowTip(event, 'tt23', 'link46')" onMouseOut="HideTip('tt23')">f_LwM2M_ObjectDB_setResourceValue</a></td><td class=SDescription>Sets the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link47 onMouseOver="ShowTip(event, 'tt22', 'link47')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link48 onMouseOver="ShowTip(event, 'tt17', 'link48')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link49 onMouseOver="ShowTip(event, 'tt9', 'link49')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResourceObserved" id=link50 onMouseOver="ShowTip(event, 'tt24', 'link50')" onMouseOut="HideTip('tt24')">f_LwM2M_ObjectDB_setResourceObserved</a></td><td class=SDescription>Sets the observation flag of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link51 onMouseOver="ShowTip(event, 'tt17', 'link51')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link52 onMouseOver="ShowTip(event, 'tt9', 'link52')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectPaths" id=link53 onMouseOver="ShowTip(event, 'tt25', 'link53')" onMouseOut="HideTip('tt25')">f_LwM2M_ObjectDB_getObjectPaths</a></td><td class=SDescription>Retrieves all the object paths <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link54 onMouseOver="ShowTip(event, 'tt26', 'link54')" onMouseOut="HideTip('tt26')">ObjectPath_List</a> that are stored in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link55 onMouseOver="ShowTip(event, 'tt9', 'link55')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_resourceHash_forResource" id=link56 onMouseOver="ShowTip(event, 'tt27', 'link56')" onMouseOut="HideTip('tt27')">f_LwM2M_resourceHash_forResource</a></td><td class=SDescription>Function to generate a unique key for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link57 onMouseOver="ShowTip(event, 'tt17', 'link57')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_resourceHash_forIds" id=link58 onMouseOver="ShowTip(event, 'tt28', 'link58')" onMouseOut="HideTip('tt28')">f_LwM2M_resourceHash_forIds</a></td><td class=SDescription>Function to generate a unique key for <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link59 onMouseOver="ShowTip(event, 'tt17', 'link59')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> IDs</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_createResource" id=link60 onMouseOver="ShowTip(event, 'tt29', 'link60')" onMouseOut="HideTip('tt29')">f_LwM2M_createResource</a></td><td class=SDescription>Function to create an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link61 onMouseOver="ShowTip(event, 'tt17', 'link61')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance based on a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link62 onMouseOver="ShowTip(event, 'tt30', 'link62')" onMouseOut="HideTip('tt30')">LwM2M_ResourceSpecification</a> and link it into an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link63 onMouseOver="ShowTip(event, 'tt16', 'link63')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_Resource_setNextDataSample" id=link64 onMouseOver="ShowTip(event, 'tt31', 'link64')" onMouseOut="HideTip('tt31')">f_LwM2M_Resource_setNextDataSample</a></td><td class=SDescription>In case the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link65 onMouseOver="ShowTip(event, 'tt17', 'link65')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance is associated with a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link66 onMouseOver="ShowTip(event, 'tt32', 'link66')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> it will set its value to the next from the samples</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_init" id=link67 onMouseOver="ShowTip(event, 'tt33', 'link67')" onMouseOut="HideTip('tt33')">f_LwM2M_DataSamples_DB_init</a></td><td class=SDescription>Initializes a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link68 onMouseOver="ShowTip(event, 'tt34', 'link68')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_add" id=link69 onMouseOver="ShowTip(event, 'tt35', 'link69')" onMouseOut="HideTip('tt35')">f_LwM2M_DataSamples_DB_add</a></td><td class=SDescription>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link70 onMouseOver="ShowTip(event, 'tt32', 'link70')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element to a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link71 onMouseOver="ShowTip(event, 'tt34', 'link71')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_lookUp" id=link72 onMouseOver="ShowTip(event, 'tt36', 'link72')" onMouseOut="HideTip('tt36')">f_LwM2M_DataSamples_DB_lookUp</a></td><td class=SDescription>Looks up a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link73 onMouseOver="ShowTip(event, 'tt32', 'link73')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link74 onMouseOver="ShowTip(event, 'tt34', 'link74')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database based on the samples&rsquo; name</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_get" id=link75 onMouseOver="ShowTip(event, 'tt37', 'link75')" onMouseOut="HideTip('tt37')">f_LwM2M_DataSamples_DB_get</a></td><td class=SDescription>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link76 onMouseOver="ShowTip(event, 'tt32', 'link76')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link77 onMouseOver="ShowTip(event, 'tt34', 'link77')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database based on its internal index</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_cleanUp" id=link78 onMouseOver="ShowTip(event, 'tt38', 'link78')" onMouseOut="HideTip('tt38')">f_LwM2M_DataSamples_DB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link79 onMouseOver="ShowTip(event, 'tt34', 'link79')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Object_Functions"></a>EPTF_LwM2M_Object_Functions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the functions of the smart object definitions for the LWM2M load generator component</p><h4 class=CHeading>See also</h4><p>&lt;EPTF_COAP_LGen_Definitions&gt;</p><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Object_Functions" >EPTF_LwM2M_Object_Functions</a></td><td class=SDescription>This module contains the functions of the smart object definitions for the LWM2M load generator component</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_init" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">f_LwM2M_ObjectSpecificationDB_init</a></td><td class=SDescription>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">f_LwM2M_ObjectSpecificationDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link4 onMouseOver="ShowTip(event, 'tt2', 'link4')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_add" id=link5 onMouseOver="ShowTip(event, 'tt4', 'link5')" onMouseOut="HideTip('tt4')">f_LwM2M_ObjectSpecificationDB_add</a></td><td class=SDescription>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link6 onMouseOver="ShowTip(event, 'tt5', 'link6')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_lookUp" id=link8 onMouseOver="ShowTip(event, 'tt6', 'link8')" onMouseOut="HideTip('tt6')">f_LwM2M_ObjectSpecificationDB_lookUp</a></td><td class=SDescription>Gets the index of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link9 onMouseOver="ShowTip(event, 'tt5', 'link9')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link10 onMouseOver="ShowTip(event, 'tt2', 'link10')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a></td><td class=SDescription>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link13 onMouseOver="ShowTip(event, 'tt2', 'link13')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link14 onMouseOver="ShowTip(event, 'tt9', 'link14')" onMouseOut="HideTip('tt9')">f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td><td class=SDescription>Loads known OMA related <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link15 onMouseOver="ShowTip(event, 'tt5', 'link15')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> elements into the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link16 onMouseOver="ShowTip(event, 'tt2', 'link16')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_init" id=link17 onMouseOver="ShowTip(event, 'tt10', 'link17')" onMouseOut="HideTip('tt10')">f_LwM2M_ObjectDB_init</a></td><td class=SDescription>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link18 onMouseOver="ShowTip(event, 'tt11', 'link18')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_cleanUp" id=link19 onMouseOver="ShowTip(event, 'tt12', 'link19')" onMouseOut="HideTip('tt12')">f_LwM2M_ObjectDB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link20 onMouseOver="ShowTip(event, 'tt11', 'link20')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObject" id=link21 onMouseOver="ShowTip(event, 'tt13', 'link21')" onMouseOut="HideTip('tt13')">f_LwM2M_ObjectDB_createObject</a></td><td class=SDescription>Creates a new instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link22 onMouseOver="ShowTip(event, 'tt14', 'link22')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> and adds it to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link23 onMouseOver="ShowTip(event, 'tt11', 'link23')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObject" id=link24 onMouseOver="ShowTip(event, 'tt15', 'link24')" onMouseOut="HideTip('tt15')">f_LwM2M_ObjectDB_getObject</a></td><td class=SDescription>Retrieves an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link25 onMouseOver="ShowTip(event, 'tt14', 'link25')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link26 onMouseOver="ShowTip(event, 'tt11', 'link26')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectIdx" id=link27 onMouseOver="ShowTip(event, 'tt16', 'link27')" onMouseOut="HideTip('tt16')">f_LwM2M_ObjectDB_getObjectIdx</a></td><td class=SDescription>Retrieves the index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link28 onMouseOver="ShowTip(event, 'tt14', 'link28')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link29 onMouseOver="ShowTip(event, 'tt11', 'link29')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObjectInstance" id=link30 onMouseOver="ShowTip(event, 'tt17', 'link30')" onMouseOut="HideTip('tt17')">f_LwM2M_ObjectDB_createObjectInstance</a></td><td class=SDescription>Creates an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link31 onMouseOver="ShowTip(event, 'tt18', 'link31')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link32 onMouseOver="ShowTip(event, 'tt14', 'link32')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link33 onMouseOver="ShowTip(event, 'tt11', 'link33')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_createObjectInstance" >f_LwM2M_ObjectDB_createObjectInstance</a></td><td class=SDescription>Links in an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link34 onMouseOver="ShowTip(event, 'tt19', 'link34')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link35 onMouseOver="ShowTip(event, 'tt11', 'link35')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectInstance" id=link36 onMouseOver="ShowTip(event, 'tt20', 'link36')" onMouseOut="HideTip('tt20')">f_LwM2M_ObjectDB_getObjectInstance</a></td><td class=SDescription>Retrieves an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link37 onMouseOver="ShowTip(event, 'tt18', 'link37')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link38 onMouseOver="ShowTip(event, 'tt11', 'link38')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getResource" id=link39 onMouseOver="ShowTip(event, 'tt21', 'link39')" onMouseOut="HideTip('tt21')">f_LwM2M_ObjectDB_getResource</a></td><td class=SDescription>Retrieves an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link40 onMouseOver="ShowTip(event, 'tt19', 'link40')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link41 onMouseOver="ShowTip(event, 'tt11', 'link41')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResource" id=link42 onMouseOver="ShowTip(event, 'tt22', 'link42')" onMouseOut="HideTip('tt22')">f_LwM2M_ObjectDB_setResource</a></td><td class=SDescription>Updates the contents of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link43 onMouseOver="ShowTip(event, 'tt19', 'link43')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link44 onMouseOver="ShowTip(event, 'tt11', 'link44')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getResourceValue" id=link45 onMouseOver="ShowTip(event, 'tt23', 'link45')" onMouseOut="HideTip('tt23')">f_LwM2M_ObjectDB_getResourceValue</a></td><td class=SDescription>Retrieves the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link46 onMouseOver="ShowTip(event, 'tt24', 'link46')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link47 onMouseOver="ShowTip(event, 'tt19', 'link47')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link48 onMouseOver="ShowTip(event, 'tt11', 'link48')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResourceValue" id=link49 onMouseOver="ShowTip(event, 'tt25', 'link49')" onMouseOut="HideTip('tt25')">f_LwM2M_ObjectDB_setResourceValue</a></td><td class=SDescription>Sets the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link50 onMouseOver="ShowTip(event, 'tt24', 'link50')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link51 onMouseOver="ShowTip(event, 'tt19', 'link51')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link52 onMouseOver="ShowTip(event, 'tt11', 'link52')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_ObjectDB_setResourceObserved" id=link53 onMouseOver="ShowTip(event, 'tt26', 'link53')" onMouseOut="HideTip('tt26')">f_LwM2M_ObjectDB_setResourceObserved</a></td><td class=SDescription>Sets the observation flag of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link54 onMouseOver="ShowTip(event, 'tt19', 'link54')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link55 onMouseOver="ShowTip(event, 'tt11', 'link55')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_ObjectDB_getObjectPaths" id=link56 onMouseOver="ShowTip(event, 'tt27', 'link56')" onMouseOut="HideTip('tt27')">f_LwM2M_ObjectDB_getObjectPaths</a></td><td class=SDescription>Retrieves all the object paths <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link57 onMouseOver="ShowTip(event, 'tt28', 'link57')" onMouseOut="HideTip('tt28')">ObjectPath_List</a> that are stored in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link58 onMouseOver="ShowTip(event, 'tt11', 'link58')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_resourceHash_forResource" id=link59 onMouseOver="ShowTip(event, 'tt29', 'link59')" onMouseOut="HideTip('tt29')">f_LwM2M_resourceHash_forResource</a></td><td class=SDescription>Function to generate a unique key for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link60 onMouseOver="ShowTip(event, 'tt19', 'link60')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_resourceHash_forIds" id=link61 onMouseOver="ShowTip(event, 'tt30', 'link61')" onMouseOut="HideTip('tt30')">f_LwM2M_resourceHash_forIds</a></td><td class=SDescription>Function to generate a unique key for <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link62 onMouseOver="ShowTip(event, 'tt19', 'link62')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> IDs</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_createResource" id=link63 onMouseOver="ShowTip(event, 'tt31', 'link63')" onMouseOut="HideTip('tt31')">f_LwM2M_createResource</a></td><td class=SDescription>Function to create an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link64 onMouseOver="ShowTip(event, 'tt19', 'link64')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance based on a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link65 onMouseOver="ShowTip(event, 'tt8', 'link65')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> and link it into an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link66 onMouseOver="ShowTip(event, 'tt18', 'link66')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_Resource_getSpecification" id=link67 onMouseOver="ShowTip(event, 'tt32', 'link67')" onMouseOut="HideTip('tt32')">f_LwM2M_Resource_getSpecification</a></td><td class=SDescription>Function to look up the specification of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link68 onMouseOver="ShowTip(event, 'tt19', 'link68')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_Resource_checkSpecification" id=link69 onMouseOver="ShowTip(event, 'tt33', 'link69')" onMouseOut="HideTip('tt33')">f_LwM2M_Resource_checkSpecification</a></td><td class=SDescription>Function to check the specification of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link70 onMouseOver="ShowTip(event, 'tt19', 'link70')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance against a template</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_Resource_setNextDataSample" id=link71 onMouseOver="ShowTip(event, 'tt34', 'link71')" onMouseOut="HideTip('tt34')">f_LwM2M_Resource_setNextDataSample</a></td><td class=SDescription>In case the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link72 onMouseOver="ShowTip(event, 'tt19', 'link72')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance is associated with a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link73 onMouseOver="ShowTip(event, 'tt35', 'link73')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> it will set its value to the next from the samples</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_init" id=link74 onMouseOver="ShowTip(event, 'tt36', 'link74')" onMouseOut="HideTip('tt36')">f_LwM2M_DataSamples_DB_init</a></td><td class=SDescription>Initializes a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link75 onMouseOver="ShowTip(event, 'tt37', 'link75')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_add" id=link76 onMouseOver="ShowTip(event, 'tt38', 'link76')" onMouseOut="HideTip('tt38')">f_LwM2M_DataSamples_DB_add</a></td><td class=SDescription>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link77 onMouseOver="ShowTip(event, 'tt35', 'link77')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element to a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link78 onMouseOver="ShowTip(event, 'tt37', 'link78')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_lookUp" id=link79 onMouseOver="ShowTip(event, 'tt39', 'link79')" onMouseOut="HideTip('tt39')">f_LwM2M_DataSamples_DB_lookUp</a></td><td class=SDescription>Looks up a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link80 onMouseOver="ShowTip(event, 'tt35', 'link80')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link81 onMouseOver="ShowTip(event, 'tt37', 'link81')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database based on the samples&rsquo; name</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_get" id=link82 onMouseOver="ShowTip(event, 'tt40', 'link82')" onMouseOut="HideTip('tt40')">f_LwM2M_DataSamples_DB_get</a></td><td class=SDescription>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link83 onMouseOver="ShowTip(event, 'tt35', 'link83')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link84 onMouseOver="ShowTip(event, 'tt37', 'link84')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database based on its internal index</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_LwM2M_DataSamples_DB_cleanUp" id=link85 onMouseOver="ShowTip(event, 'tt41', 'link85')" onMouseOut="HideTip('tt41')">f_LwM2M_DataSamples_DB_cleanUp</a></td><td class=SDescription>Cleans up the reserved resources of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link86 onMouseOver="ShowTip(event, 'tt37', 'link86')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_init"></a>f_LwM2M_ObjectSpecificationDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link80 onMouseOver="ShowTip(event, 'tt2', 'link80')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link81 onMouseOver="ShowTip(event, 'tt2', 'link81')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - unique id for the instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link82 onMouseOver="ShowTip(event, 'tt2', 'link82')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_init"></a>f_LwM2M_ObjectSpecificationDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link87 onMouseOver="ShowTip(event, 'tt2', 'link87')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link88 onMouseOver="ShowTip(event, 'tt2', 'link88')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - unique id for the instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link89 onMouseOver="ShowTip(event, 'tt2', 'link89')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_cleanUp"></a>f_LwM2M_ObjectSpecificationDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link83 onMouseOver="ShowTip(event, 'tt2', 'link83')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link84 onMouseOver="ShowTip(event, 'tt2', 'link84')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link85 onMouseOver="ShowTip(event, 'tt2', 'link85')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_cleanUp"></a>f_LwM2M_ObjectSpecificationDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link90 onMouseOver="ShowTip(event, 'tt2', 'link90')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link91 onMouseOver="ShowTip(event, 'tt2', 'link91')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link92 onMouseOver="ShowTip(event, 'tt2', 'link92')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_add"></a>f_LwM2M_ObjectSpecificationDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link86 onMouseOver="ShowTip(event, 'tt5', 'link86')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link87 onMouseOver="ShowTip(event, 'tt2', 'link87')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link88 onMouseOver="ShowTip(event, 'tt2', 'link88')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link89 onMouseOver="ShowTip(event, 'tt5', 'link89')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> - new element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link90 onMouseOver="ShowTip(event, 'tt2', 'link90')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_add"></a>f_LwM2M_ObjectSpecificationDB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link93 onMouseOver="ShowTip(event, 'tt5', 'link93')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link94 onMouseOver="ShowTip(event, 'tt2', 'link94')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link95 onMouseOver="ShowTip(event, 'tt2', 'link95')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link96 onMouseOver="ShowTip(event, 'tt5', 'link96')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> - new element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link97 onMouseOver="ShowTip(event, 'tt2', 'link97')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_lookUp"></a>f_LwM2M_ObjectSpecificationDB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Gets the index of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link91 onMouseOver="ShowTip(event, 'tt5', 'link91')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link92 onMouseOver="ShowTip(event, 'tt2', 'link92')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link93 onMouseOver="ShowTip(event, 'tt2', 'link93')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>integer</b> - obj id of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link94 onMouseOver="ShowTip(event, 'tt5', 'link94')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the looked up element in the database, or -1 if not found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link95 onMouseOver="ShowTip(event, 'tt2', 'link95')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_lookUp"></a>f_LwM2M_ObjectSpecificationDB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Gets the index of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link98 onMouseOver="ShowTip(event, 'tt5', 'link98')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link99 onMouseOver="ShowTip(event, 'tt2', 'link99')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link100 onMouseOver="ShowTip(event, 'tt2', 'link100')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>integer</b> - obj id of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link101 onMouseOver="ShowTip(event, 'tt5', 'link101')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the looked up element in the database, or -1 if not found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link102 onMouseOver="ShowTip(event, 'tt2', 'link102')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs"></a>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Loads known OMA related <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link96 onMouseOver="ShowTip(event, 'tt5', 'link96')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> elements into the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link97 onMouseOver="ShowTip(event, 'tt2', 'link97')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link98 onMouseOver="ShowTip(event, 'tt2', 'link98')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link99 onMouseOver="ShowTip(event, 'tt2', 'link99')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_getResourceSpecification"></a>f_LwM2M_ObjectSpecificationDB_getResourceSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link103 onMouseOver="ShowTip(event, 'tt8', 'link103')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> element in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link104 onMouseOver="ShowTip(event, 'tt2', 'link104')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_spec_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link105 onMouseOver="ShowTip(event, 'tt2', 'link105')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>integer</b> - obj id of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link106 onMouseOver="ShowTip(event, 'tt8', 'link106')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> to be retrieved</td></tr><tr><td class=CDLEntry>p_resId</td><td class=CDLDescription><b>integer</b> - resource id of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link107 onMouseOver="ShowTip(event, 'tt8', 'link107')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> to be retrieved</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link108 onMouseOver="ShowTip(event, 'tt8', 'link108')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> - the returned specification</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true, in case the specification was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link109 onMouseOver="ShowTip(event, 'tt2', 'link109')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_init"></a>f_LwM2M_ObjectDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link100 onMouseOver="ShowTip(event, 'tt9', 'link100')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link101 onMouseOver="ShowTip(event, 'tt9', 'link101')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - unique id for the instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link102 onMouseOver="ShowTip(event, 'tt9', 'link102')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs"></a>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Loads known OMA related <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link110 onMouseOver="ShowTip(event, 'tt5', 'link110')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> elements into the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link111 onMouseOver="ShowTip(event, 'tt2', 'link111')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link112 onMouseOver="ShowTip(event, 'tt2', 'link112')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link113 onMouseOver="ShowTip(event, 'tt2', 'link113')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_cleanUp"></a>f_LwM2M_ObjectDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link103 onMouseOver="ShowTip(event, 'tt9', 'link103')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link104 onMouseOver="ShowTip(event, 'tt9', 'link104')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link105 onMouseOver="ShowTip(event, 'tt9', 'link105')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_init"></a>f_LwM2M_ObjectDB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link114 onMouseOver="ShowTip(event, 'tt11', 'link114')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link115 onMouseOver="ShowTip(event, 'tt11', 'link115')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - unique id for the instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link116 onMouseOver="ShowTip(event, 'tt11', 'link116')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObject"></a>f_LwM2M_ObjectDB_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Creates a new instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link106 onMouseOver="ShowTip(event, 'tt12', 'link106')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> and adds it to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link107 onMouseOver="ShowTip(event, 'tt9', 'link107')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link108 onMouseOver="ShowTip(event, 'tt9', 'link108')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link109 onMouseOver="ShowTip(event, 'tt5', 'link109')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> - specification of the smart object to be instantiated</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link110 onMouseOver="ShowTip(event, 'tt12', 'link110')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> instance in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link111 onMouseOver="ShowTip(event, 'tt9', 'link111')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_cleanUp"></a>f_LwM2M_ObjectDB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link117 onMouseOver="ShowTip(event, 'tt11', 'link117')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link118 onMouseOver="ShowTip(event, 'tt11', 'link118')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link119 onMouseOver="ShowTip(event, 'tt11', 'link119')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObject"></a>f_LwM2M_ObjectDB_getObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link112 onMouseOver="ShowTip(event, 'tt12', 'link112')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link113 onMouseOver="ShowTip(event, 'tt9', 'link113')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link114 onMouseOver="ShowTip(event, 'tt9', 'link114')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_obj</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link115 onMouseOver="ShowTip(event, 'tt12', 'link115')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> - the  retrieved <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link116 onMouseOver="ShowTip(event, 'tt12', 'link116')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> instance</td></tr><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if the instance was found, false otherwise</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link117 onMouseOver="ShowTip(event, 'tt9', 'link117')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObject"></a>f_LwM2M_ObjectDB_createObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Creates a new instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link120 onMouseOver="ShowTip(event, 'tt14', 'link120')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> and adds it to the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link121 onMouseOver="ShowTip(event, 'tt11', 'link121')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link122 onMouseOver="ShowTip(event, 'tt11', 'link122')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=LType id=link123 onMouseOver="ShowTip(event, 'tt5', 'link123')" onMouseOut="HideTip('tt5')">LwM2M_ObjectSpecification</a> - specification of the smart object to be instantiated</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*integer*</td><td class=CDLDescription>the index of the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link124 onMouseOver="ShowTip(event, 'tt14', 'link124')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> instance in the database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link125 onMouseOver="ShowTip(event, 'tt11', 'link125')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectIdx"></a>f_LwM2M_ObjectDB_getObjectIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves the index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link118 onMouseOver="ShowTip(event, 'tt12', 'link118')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link119 onMouseOver="ShowTip(event, 'tt9', 'link119')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link120 onMouseOver="ShowTip(event, 'tt9', 'link120')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>integer</td><td class=CDLDescription>index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link121 onMouseOver="ShowTip(event, 'tt12', 'link121')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link122 onMouseOver="ShowTip(event, 'tt9', 'link122')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link123 onMouseOver="ShowTip(event, 'tt9', 'link123')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObject"></a>f_LwM2M_ObjectDB_getObject</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link126 onMouseOver="ShowTip(event, 'tt14', 'link126')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link127 onMouseOver="ShowTip(event, 'tt11', 'link127')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link128 onMouseOver="ShowTip(event, 'tt11', 'link128')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_obj</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link129 onMouseOver="ShowTip(event, 'tt14', 'link129')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> - the  retrieved <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link130 onMouseOver="ShowTip(event, 'tt14', 'link130')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> instance</td></tr><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if the instance was found, false otherwise</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link131 onMouseOver="ShowTip(event, 'tt11', 'link131')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObjectInstance"></a>f_LwM2M_ObjectDB_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Creates an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link124 onMouseOver="ShowTip(event, 'tt16', 'link124')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link125 onMouseOver="ShowTip(event, 'tt12', 'link125')" onMouseOut="HideTip('tt12')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link126 onMouseOver="ShowTip(event, 'tt9', 'link126')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link127 onMouseOver="ShowTip(event, 'tt9', 'link127')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be instantiated</td></tr><tr><td class=CDLEntry>p_spec_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link128 onMouseOver="ShowTip(event, 'tt2', 'link128')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - object specification DB</td></tr><tr><td class=CDLEntry>p_createResources</td><td class=CDLDescription><b>in boolean</b> - should the func create the resource instances as well?</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>integer</td><td class=CDLDescription>index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link129 onMouseOver="ShowTip(event, 'tt16', 'link129')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link130 onMouseOver="ShowTip(event, 'tt9', 'link130')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link131 onMouseOver="ShowTip(event, 'tt9', 'link131')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectIdx"></a>f_LwM2M_ObjectDB_getObjectIdx</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves the index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link132 onMouseOver="ShowTip(event, 'tt14', 'link132')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link133 onMouseOver="ShowTip(event, 'tt11', 'link133')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link134 onMouseOver="ShowTip(event, 'tt11', 'link134')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be retrieved</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>integer</td><td class=CDLDescription>index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link135 onMouseOver="ShowTip(event, 'tt14', 'link135')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link136 onMouseOver="ShowTip(event, 'tt11', 'link136')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link137 onMouseOver="ShowTip(event, 'tt11', 'link137')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObjectInstance"></a>f_LwM2M_ObjectDB_createObjectInstance</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Links in an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link132 onMouseOver="ShowTip(event, 'tt17', 'link132')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link133 onMouseOver="ShowTip(event, 'tt9', 'link133')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link134 onMouseOver="ShowTip(event, 'tt9', 'link134')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link135 onMouseOver="ShowTip(event, 'tt17', 'link135')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> - smart resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>true if it was succesful</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link136 onMouseOver="ShowTip(event, 'tt9', 'link136')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObjectInstance"></a>f_LwM2M_ObjectDB_createObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Creates an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link138 onMouseOver="ShowTip(event, 'tt18', 'link138')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=LType id=link139 onMouseOver="ShowTip(event, 'tt14', 'link139')" onMouseOut="HideTip('tt14')">LwM2M_Object</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link140 onMouseOver="ShowTip(event, 'tt11', 'link140')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link141 onMouseOver="ShowTip(event, 'tt11', 'link141')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_id</td><td class=CDLDescription><b>in integer</b> - id of the smart object to be instantiated</td></tr><tr><td class=CDLEntry>p_spec_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link142 onMouseOver="ShowTip(event, 'tt2', 'link142')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - object specification DB</td></tr><tr><td class=CDLEntry>p_createResources</td><td class=CDLDescription><b>in boolean</b> - should the func create the resource instances as well?</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>integer</td><td class=CDLDescription>index of an instance of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link143 onMouseOver="ShowTip(event, 'tt18', 'link143')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link144 onMouseOver="ShowTip(event, 'tt11', 'link144')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link145 onMouseOver="ShowTip(event, 'tt11', 'link145')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectInstance"></a>f_LwM2M_ObjectDB_getObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link137 onMouseOver="ShowTip(event, 'tt16', 'link137')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link138 onMouseOver="ShowTip(event, 'tt9', 'link138')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link139 onMouseOver="ShowTip(event, 'tt9', 'link139')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_objInst</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link140 onMouseOver="ShowTip(event, 'tt16', 'link140')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> - object instance</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link141 onMouseOver="ShowTip(event, 'tt9', 'link141')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_createObjectInstance"></a>f_LwM2M_ObjectDB_createObjectInstance</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Links in an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link146 onMouseOver="ShowTip(event, 'tt19', 'link146')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link147 onMouseOver="ShowTip(event, 'tt11', 'link147')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link148 onMouseOver="ShowTip(event, 'tt11', 'link148')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link149 onMouseOver="ShowTip(event, 'tt19', 'link149')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - smart resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>true if it was succesful</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link150 onMouseOver="ShowTip(event, 'tt11', 'link150')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getResource"></a>f_LwM2M_ObjectDB_getResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link142 onMouseOver="ShowTip(event, 'tt17', 'link142')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link143 onMouseOver="ShowTip(event, 'tt9', 'link143')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link144 onMouseOver="ShowTip(event, 'tt9', 'link144')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link145 onMouseOver="ShowTip(event, 'tt17', 'link145')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> - object instance</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link146 onMouseOver="ShowTip(event, 'tt9', 'link146')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectInstance"></a>f_LwM2M_ObjectDB_getObjectInstance</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link151 onMouseOver="ShowTip(event, 'tt18', 'link151')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link152 onMouseOver="ShowTip(event, 'tt11', 'link152')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link153 onMouseOver="ShowTip(event, 'tt11', 'link153')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_objInst</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link154 onMouseOver="ShowTip(event, 'tt18', 'link154')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> - object instance</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link155 onMouseOver="ShowTip(event, 'tt11', 'link155')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResource"></a>f_LwM2M_ObjectDB_setResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Updates the contents of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link147 onMouseOver="ShowTip(event, 'tt17', 'link147')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link148 onMouseOver="ShowTip(event, 'tt9', 'link148')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link149 onMouseOver="ShowTip(event, 'tt9', 'link149')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link150 onMouseOver="ShowTip(event, 'tt17', 'link150')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link151 onMouseOver="ShowTip(event, 'tt9', 'link151')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getResource"></a>f_LwM2M_ObjectDB_getResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link156 onMouseOver="ShowTip(event, 'tt19', 'link156')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link157 onMouseOver="ShowTip(event, 'tt11', 'link157')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link158 onMouseOver="ShowTip(event, 'tt11', 'link158')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link159 onMouseOver="ShowTip(event, 'tt19', 'link159')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - object instance</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link160 onMouseOver="ShowTip(event, 'tt11', 'link160')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getResourceValue"></a>f_LwM2M_ObjectDB_getResourceValue</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link152 onMouseOver="ShowTip(event, 'tt22', 'link152')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link153 onMouseOver="ShowTip(event, 'tt17', 'link153')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link154 onMouseOver="ShowTip(event, 'tt9', 'link154')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link155 onMouseOver="ShowTip(event, 'tt9', 'link155')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_value</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link156 onMouseOver="ShowTip(event, 'tt22', 'link156')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> - resource value</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link157 onMouseOver="ShowTip(event, 'tt9', 'link157')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResource"></a>f_LwM2M_ObjectDB_setResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Updates the contents of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link161 onMouseOver="ShowTip(event, 'tt19', 'link161')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link162 onMouseOver="ShowTip(event, 'tt11', 'link162')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link163 onMouseOver="ShowTip(event, 'tt11', 'link163')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_resource</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link164 onMouseOver="ShowTip(event, 'tt19', 'link164')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link165 onMouseOver="ShowTip(event, 'tt11', 'link165')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResourceValue"></a>f_LwM2M_ObjectDB_setResourceValue</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link158 onMouseOver="ShowTip(event, 'tt22', 'link158')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link159 onMouseOver="ShowTip(event, 'tt17', 'link159')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link160 onMouseOver="ShowTip(event, 'tt9', 'link160')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link161 onMouseOver="ShowTip(event, 'tt9', 'link161')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_value</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link162 onMouseOver="ShowTip(event, 'tt22', 'link162')" onMouseOut="HideTip('tt22')">LwM2M_ResourceValue</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link163 onMouseOver="ShowTip(event, 'tt9', 'link163')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getResourceValue"></a>f_LwM2M_ObjectDB_getResourceValue</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link166 onMouseOver="ShowTip(event, 'tt24', 'link166')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link167 onMouseOver="ShowTip(event, 'tt19', 'link167')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link168 onMouseOver="ShowTip(event, 'tt11', 'link168')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link169 onMouseOver="ShowTip(event, 'tt11', 'link169')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_value</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link170 onMouseOver="ShowTip(event, 'tt24', 'link170')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> - resource value</td></tr><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link171 onMouseOver="ShowTip(event, 'tt11', 'link171')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResourceObserved"></a>f_LwM2M_ObjectDB_setResourceObserved</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_observed</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the observation flag of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link164 onMouseOver="ShowTip(event, 'tt17', 'link164')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link165 onMouseOver="ShowTip(event, 'tt9', 'link165')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link166 onMouseOver="ShowTip(event, 'tt9', 'link166')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_observed</td><td class=CDLDescription><b>in boolean</b> - observation flag</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link167 onMouseOver="ShowTip(event, 'tt9', 'link167')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResourceValue"></a>f_LwM2M_ObjectDB_setResourceValue</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link172 onMouseOver="ShowTip(event, 'tt24', 'link172')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link173 onMouseOver="ShowTip(event, 'tt19', 'link173')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link174 onMouseOver="ShowTip(event, 'tt11', 'link174')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link175 onMouseOver="ShowTip(event, 'tt11', 'link175')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_value</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=LType id=link176 onMouseOver="ShowTip(event, 'tt24', 'link176')" onMouseOut="HideTip('tt24')">LwM2M_ResourceValue</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link177 onMouseOver="ShowTip(event, 'tt11', 'link177')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectPaths"></a>f_LwM2M_ObjectDB_getObjectPaths</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves all the object paths <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link168 onMouseOver="ShowTip(event, 'tt26', 'link168')" onMouseOut="HideTip('tt26')">ObjectPath_List</a> that are stored in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link169 onMouseOver="ShowTip(event, 'tt9', 'link169')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link170 onMouseOver="ShowTip(event, 'tt9', 'link170')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a> - DB instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_paths</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link171 onMouseOver="ShowTip(event, 'tt26', 'link171')" onMouseOut="HideTip('tt26')">ObjectPath_List</a> - the pathes of the objects stored in the DB</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link172 onMouseOver="ShowTip(event, 'tt9', 'link172')" onMouseOut="HideTip('tt9')">LwM2M_ObjectDB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_setResourceObserved"></a>f_LwM2M_ObjectDB_setResourceObserved</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resourceId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_observed,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in template integer&nbsp;</td><td class="PType  prettyprint " nowrap>p_contentFormat&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> omit</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Sets the observation flag of an already linked in <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link178 onMouseOver="ShowTip(event, 'tt19', 'link178')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> in a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link179 onMouseOver="ShowTip(event, 'tt11', 'link179')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link180 onMouseOver="ShowTip(event, 'tt11', 'link180')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resourceId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr><tr><td class=CDLEntry>p_observed</td><td class=CDLDescription><b>in boolean</b> - observation flag</td></tr><tr><td class=CDLEntry>p_contentFormat</td><td class=CDLDescription><b>in integer optional</b> - preferred content format</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>boolean</td><td class=CDLDescription>if the instance was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link181 onMouseOver="ShowTip(event, 'tt11', 'link181')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_resourceHash_forResource"></a>f_LwM2M_resourceHash_forResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to generate a unique key for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link173 onMouseOver="ShowTip(event, 'tt17', 'link173')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link174 onMouseOver="ShowTip(event, 'tt17', 'link174')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>charstring</td><td class=CDLDescription>unique hash for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link175 onMouseOver="ShowTip(event, 'tt17', 'link175')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a></td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link176 onMouseOver="ShowTip(event, 'tt17', 'link176')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_ObjectDB_getObjectPaths"></a>f_LwM2M_ObjectDB_getObjectPaths</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves all the object paths <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link182 onMouseOver="ShowTip(event, 'tt28', 'link182')" onMouseOut="HideTip('tt28')">ObjectPath_List</a> that are stored in the <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link183 onMouseOver="ShowTip(event, 'tt11', 'link183')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link184 onMouseOver="ShowTip(event, 'tt11', 'link184')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a> - DB instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_paths</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#ObjectPath_List" class=LType id=link185 onMouseOver="ShowTip(event, 'tt28', 'link185')" onMouseOut="HideTip('tt28')">ObjectPath_List</a> - the pathes of the objects stored in the DB</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=LType id=link186 onMouseOver="ShowTip(event, 'tt11', 'link186')" onMouseOut="HideTip('tt11')">LwM2M_ObjectDB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_resourceHash_forIds"></a>f_LwM2M_resourceHash_forIds</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to generate a unique key for <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link177 onMouseOver="ShowTip(event, 'tt17', 'link177')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> IDs</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>charstring</td><td class=CDLDescription>unique hash for the reource IDs</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link178 onMouseOver="ShowTip(event, 'tt17', 'link178')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_resourceHash_forResource"></a>f_LwM2M_resourceHash_forResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to generate a unique key for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link187 onMouseOver="ShowTip(event, 'tt19', 'link187')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link188 onMouseOver="ShowTip(event, 'tt19', 'link188')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - resource instance</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>charstring</td><td class=CDLDescription>unique hash for the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link189 onMouseOver="ShowTip(event, 'tt19', 'link189')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link190 onMouseOver="ShowTip(event, 'tt19', 'link190')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_createResource"></a>f_LwM2M_createResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to create an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link179 onMouseOver="ShowTip(event, 'tt17', 'link179')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance based on a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link180 onMouseOver="ShowTip(event, 'tt30', 'link180')" onMouseOut="HideTip('tt30')">LwM2M_ResourceSpecification</a> and link it into an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link181 onMouseOver="ShowTip(event, 'tt16', 'link181')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_oi</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link182 onMouseOver="ShowTip(event, 'tt16', 'link182')" onMouseOut="HideTip('tt16')">LwM2M_ObjectInstance</a> - object instance, where the rousrce will be added</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link183 onMouseOver="ShowTip(event, 'tt30', 'link183')" onMouseOut="HideTip('tt30')">LwM2M_ResourceSpecification</a> - resource specification for the instantiation</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;LwM2M_Resource&gt;</td><td class=CDLDescription>the create resource instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link184 onMouseOver="ShowTip(event, 'tt17', 'link184')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_resourceHash_forIds"></a>f_LwM2M_resourceHash_forIds</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to generate a unique key for <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link191 onMouseOver="ShowTip(event, 'tt19', 'link191')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> IDs</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_objId</td><td class=CDLDescription><b>in integer</b> - object id</td></tr><tr><td class=CDLEntry>p_objInstId</td><td class=CDLDescription><b>in integer</b> - object instance id</td></tr><tr><td class=CDLEntry>p_resId</td><td class=CDLDescription><b>in integer</b> - resource id</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>charstring</td><td class=CDLDescription>unique hash for the reource IDs</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link192 onMouseOver="ShowTip(event, 'tt19', 'link192')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_Resource_setNextDataSample"></a>f_LwM2M_Resource_setNextDataSample</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>In case the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link185 onMouseOver="ShowTip(event, 'tt17', 'link185')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> instance is associated with a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link186 onMouseOver="ShowTip(event, 'tt32', 'link186')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> it will set its value to the next from the samples</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link187 onMouseOver="ShowTip(event, 'tt17', 'link187')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a> - resource instance, where the value will be updated</td></tr><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in out</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link188 onMouseOver="ShowTip(event, 'tt34', 'link188')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB where the samples are stored</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;LwM2M_Resource&gt;</td><td class=CDLDescription>with the updated value</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link189 onMouseOver="ShowTip(event, 'tt17', 'link189')" onMouseOut="HideTip('tt17')">LwM2M_Resource</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_createResource"></a>f_LwM2M_createResource</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to create an <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link193 onMouseOver="ShowTip(event, 'tt19', 'link193')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance based on a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link194 onMouseOver="ShowTip(event, 'tt8', 'link194')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> and link it into an <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link195 onMouseOver="ShowTip(event, 'tt18', 'link195')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a></p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_oi</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=LType id=link196 onMouseOver="ShowTip(event, 'tt18', 'link196')" onMouseOut="HideTip('tt18')">LwM2M_ObjectInstance</a> - object instance, where the rousrce will be added</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link197 onMouseOver="ShowTip(event, 'tt8', 'link197')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> - resource specification for the instantiation</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;LwM2M_Resource&gt;</td><td class=CDLDescription>the create resource instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link198 onMouseOver="ShowTip(event, 'tt19', 'link198')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_init"></a>f_LwM2M_DataSamples_DB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link190 onMouseOver="ShowTip(event, 'tt34', 'link190')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link191 onMouseOver="ShowTip(event, 'tt34', 'link191')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_name</td><td class=CDLDescription><b>in charstring</b> - name for the DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link192 onMouseOver="ShowTip(event, 'tt34', 'link192')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_Resource_getSpecification"></a>f_LwM2M_Resource_getSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_getSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to look up the specification of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link199 onMouseOver="ShowTip(event, 'tt19', 'link199')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link200 onMouseOver="ShowTip(event, 'tt19', 'link200')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - the resource</td></tr><tr><td class=CDLEntry>p_spec_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link201 onMouseOver="ShowTip(event, 'tt2', 'link201')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - object specification database</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link202 onMouseOver="ShowTip(event, 'tt8', 'link202')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> - resource specification for the instantiation</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if the specification was found</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link203 onMouseOver="ShowTip(event, 'tt19', 'link203')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_add"></a>f_LwM2M_DataSamples_DB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link193 onMouseOver="ShowTip(event, 'tt32', 'link193')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element to a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link194 onMouseOver="ShowTip(event, 'tt34', 'link194')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link195 onMouseOver="ShowTip(event, 'tt34', 'link195')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_samples</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link196 onMouseOver="ShowTip(event, 'tt32', 'link196')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> - element to be added</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link197 onMouseOver="ShowTip(event, 'tt34', 'link197')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_Resource_checkSpecification"></a>f_LwM2M_Resource_checkSpecification</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_checkSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>template&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to check the specification of a <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link204 onMouseOver="ShowTip(event, 'tt19', 'link204')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance against a template</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>in</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link205 onMouseOver="ShowTip(event, 'tt19', 'link205')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - the resource</td></tr><tr><td class=CDLEntry>p_spec_db</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=LType id=link206 onMouseOver="ShowTip(event, 'tt2', 'link206')" onMouseOut="HideTip('tt2')">LwM2M_ObjectSpecificationDB</a> - object specification database</td></tr><tr><td class=CDLEntry>p_spec</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=LType id=link207 onMouseOver="ShowTip(event, 'tt8', 'link207')" onMouseOut="HideTip('tt8')">LwM2M_ResourceSpecification</a> - resource specification for the instantiation</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>*boolean*</td><td class=CDLDescription>true if the specifications were matching</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link208 onMouseOver="ShowTip(event, 'tt19', 'link208')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_lookUp"></a>f_LwM2M_DataSamples_DB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Looks up a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link198 onMouseOver="ShowTip(event, 'tt32', 'link198')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link199 onMouseOver="ShowTip(event, 'tt34', 'link199')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database based on the samples&rsquo; name</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link200 onMouseOver="ShowTip(event, 'tt34', 'link200')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_sampleName</td><td class=CDLDescription><b>in charstring</b> - name of the sample to look up</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link201 onMouseOver="ShowTip(event, 'tt34', 'link201')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_Resource_setNextDataSample"></a>f_LwM2M_Resource_setNextDataSample</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>In case the <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link209 onMouseOver="ShowTip(event, 'tt19', 'link209')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> instance is associated with a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link210 onMouseOver="ShowTip(event, 'tt35', 'link210')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> it will set its value to the next from the samples</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_res</td><td class=CDLDescription><b>inout</b> <a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link211 onMouseOver="ShowTip(event, 'tt19', 'link211')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a> - resource instance, where the value will be updated</td></tr><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>in out</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link212 onMouseOver="ShowTip(event, 'tt37', 'link212')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB where the samples are stored</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>&lt;LwM2M_Resource&gt;</td><td class=CDLDescription>with the updated value</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=LType id=link213 onMouseOver="ShowTip(event, 'tt19', 'link213')" onMouseOut="HideTip('tt19')">LwM2M_Resource</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_get"></a>f_LwM2M_DataSamples_DB_get</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link202 onMouseOver="ShowTip(event, 'tt32', 'link202')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link203 onMouseOver="ShowTip(event, 'tt34', 'link203')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database based on its internal index</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link204 onMouseOver="ShowTip(event, 'tt34', 'link204')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in integer</b> - index of the sample to be fetched</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_samples</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link205 onMouseOver="ShowTip(event, 'tt32', 'link205')" onMouseOut="HideTip('tt32')">LwM2M_DataSamples</a> - retrieved element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link206 onMouseOver="ShowTip(event, 'tt34', 'link206')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_init"></a>f_LwM2M_DataSamples_DB_init</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Initializes a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link214 onMouseOver="ShowTip(event, 'tt37', 'link214')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link215 onMouseOver="ShowTip(event, 'tt37', 'link215')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_name</td><td class=CDLDescription><b>in charstring</b> - name for the DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link216 onMouseOver="ShowTip(event, 'tt37', 'link216')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a></p></div></div></div>
 
-<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_cleanUp"></a>f_LwM2M_DataSamples_DB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link207 onMouseOver="ShowTip(event, 'tt34', 'link207')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link208 onMouseOver="ShowTip(event, 'tt34', 'link208')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link209 onMouseOver="ShowTip(event, 'tt34', 'link209')" onMouseOut="HideTip('tt34')">LwM2M_DataSamples_DB</a></p></div></div></div>
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_add"></a>f_LwM2M_DataSamples_DB_add</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Adds a new <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link217 onMouseOver="ShowTip(event, 'tt35', 'link217')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element to a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link218 onMouseOver="ShowTip(event, 'tt37', 'link218')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link219 onMouseOver="ShowTip(event, 'tt37', 'link219')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_samples</td><td class=CDLDescription><b>in</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link220 onMouseOver="ShowTip(event, 'tt35', 'link220')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> - element to be added</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link221 onMouseOver="ShowTip(event, 'tt37', 'link221')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a></p></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_lookUp"></a>f_LwM2M_DataSamples_DB_lookUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Looks up a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link222 onMouseOver="ShowTip(event, 'tt35', 'link222')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link223 onMouseOver="ShowTip(event, 'tt37', 'link223')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database based on the samples&rsquo; name</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link224 onMouseOver="ShowTip(event, 'tt37', 'link224')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_sampleName</td><td class=CDLDescription><b>in charstring</b> - name of the sample to look up</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link225 onMouseOver="ShowTip(event, 'tt37', 'link225')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a></p></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_get"></a>f_LwM2M_DataSamples_DB_get</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Retrieves a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link226 onMouseOver="ShowTip(event, 'tt35', 'link226')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> element from a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link227 onMouseOver="ShowTip(event, 'tt37', 'link227')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database based on its internal index</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link228 onMouseOver="ShowTip(event, 'tt37', 'link228')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB instance</td></tr><tr><td class=CDLEntry>p_idx</td><td class=CDLDescription><b>in integer</b> - index of the sample to be fetched</td></tr></table><h4 class=CHeading>Returns</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_samples</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=LType id=link229 onMouseOver="ShowTip(event, 'tt35', 'link229')" onMouseOut="HideTip('tt35')">LwM2M_DataSamples</a> - retrieved element</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link230 onMouseOver="ShowTip(event, 'tt37', 'link230')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a></p></div></div></div>
+
+<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_LwM2M_DataSamples_DB_cleanUp"></a>f_LwM2M_DataSamples_DB_cleanUp</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Cleans up the reserved resources of a <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link231 onMouseOver="ShowTip(event, 'tt37', 'link231')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> database</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_db</td><td class=CDLDescription><b>inout</b> <a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link232 onMouseOver="ShowTip(event, 'tt37', 'link232')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a> - DB instance</td></tr></table><h4 class=CHeading>Related Type</h4><p><a href="EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=LType id=link233 onMouseOver="ShowTip(event, 'tt37', 'link233')" onMouseOut="HideTip('tt37')">LwM2M_DataSamples_DB</a></p></div></div></div>
 
 </div><!--Content-->
 
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt6"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt7"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt8"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt11"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt12"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt13"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt14"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt16"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt17"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt22"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_observed</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt26"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt30"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt32"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt34"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt6"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt7"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_ResourceSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt9"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt12"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt13"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt16"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt18"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt19"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt24"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resourceId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_observed,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in template integer&nbsp;</td><td class="PType  prettyprint " nowrap>p_contentFormat&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> omit</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt28"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_getSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to look up the specification of a LwM2M_Resource instance</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_checkSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>template&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to check the specification of a LwM2M_Resource instance against a template</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt35"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt37"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><!--END_ND_TOOLTIPS-->
 
 <script language=JavaScript><!--
 if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/EPTF_LwM2M_Transport_Definitions-ttcn.html b/apidoc/html/files/EPTF_LwM2M_Transport_Definitions-ttcn.html
index 938ab5d..431cdeb 100644
--- a/apidoc/html/files/EPTF_LwM2M_Transport_Definitions-ttcn.html
+++ b/apidoc/html/files/EPTF_LwM2M_Transport_Definitions-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Transport_Definitions - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>EPTF_LwM2M_Transport_Definitions - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -9,30 +9,34 @@
 
 
 
-<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Transport_Definitions"></a>EPTF_LwM2M_Transport_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the generic transport definitions of the LwM2M load generator</p><h4 class=CHeading>Component Diagram</h4><p>(see EPTF_LwM2M_Transport_Definitions.components.jpg)</p><h4 class=CHeading>See also</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=LFile id=link13 onMouseOver="ShowTip(event, 'tt9', 'link13')" onMouseOut="HideTip('tt9')">EPTF_LwM2M_LGen_Definitions</a></li><li><a href="#EPTF_LwM2M_Transport_User_CT" class=LType id=link14 onMouseOver="ShowTip(event, 'tt8', 'link14')" onMouseOut="HideTip('tt8')">EPTF_LwM2M_Transport_User_CT</a></li><li><a href="#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link15 onMouseOver="ShowTip(event, 'tt7', 'link15')" onMouseOut="HideTip('tt7')">EPTF_LwM2M_Transport_Provider_CT</a></li></ul><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Transport_Definitions" >EPTF_LwM2M_Transport_Definitions</a></td><td class=SDescription>This module contains the generic transport definitions of the LwM2M load generator</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">fcb_EPTF_LwM2M_Transport_receiveMessage</a></td><td class=SDescription>Call-back function type for reporting received <a href="#EPTF_LwM2M_PDU" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M messages</td></tr><tr class="SType"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">fcb_EPTF_LwM2M_Transport_receiveEvent</a></td><td class=SDescription>Call-back function type for reporting received <a href="#EPTF_LwM2M_Event" class=LType id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> LWM2M event</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_sendMessage" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')">fcb_EPTF_LwM2M_Transport_sendMessage</a></td><td class=SDescription>Call-back function type for sending a <a href="#EPTF_LwM2M_PDU" class=LType id=link6 onMouseOver="ShowTip(event, 'tt2', 'link6')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M message</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_PDU" id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a></td><td class=SDescription>Encapsulates a &lt;LWM2M_PDU&gt; with the corresponding entity (and FSM) indices</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_Event" id=link8 onMouseOver="ShowTip(event, 'tt4', 'link8')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a></td><td class=SDescription>Encapsulates a <a href="#EPTF_LwM2M_Event" class=LType id=link9 onMouseOver="ShowTip(event, 'tt4', 'link9')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> with the corresponding entity</td></tr><tr class="SType"><td class=SEntry><a href="#LWM2M_Event" id=link10 onMouseOver="ShowTip(event, 'tt6', 'link10')" onMouseOut="HideTip('tt6')">LWM2M_Event</a></td><td class=SDescription>A union of possible LwM2M events</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_Transport_Provider_CT" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">EPTF_LwM2M_Transport_Provider_CT</a></td><td class=SDescription>Base component type for a LwM2M transport realization</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_Transport_User_CT" id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">EPTF_LwM2M_Transport_User_CT</a></td><td class=SDescription>Base component type for a LwM2M transport user realization</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
+<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="EPTF_LwM2M_Transport_Definitions"></a>EPTF_LwM2M_Transport_Definitions</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains the generic transport definitions of the LwM2M load generator</p><h4 class=CHeading>Component Diagram</h4><img src="../images/EPTF_LwM2M_Transport_Definitions.components.jpg"><h4 class=CHeading>See also</h4><ul><li><a href="EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=LFile id=link14 onMouseOver="ShowTip(event, 'tt10', 'link14')" onMouseOut="HideTip('tt10')">EPTF_LwM2M_LGen_Definitions</a></li><li><a href="#EPTF_LwM2M_Transport_User_CT" class=LType id=link15 onMouseOver="ShowTip(event, 'tt9', 'link15')" onMouseOut="HideTip('tt9')">EPTF_LwM2M_Transport_User_CT</a></li><li><a href="#EPTF_LwM2M_Transport_Provider_CT" class=LType id=link16 onMouseOver="ShowTip(event, 'tt8', 'link16')" onMouseOut="HideTip('tt8')">EPTF_LwM2M_Transport_Provider_CT</a></li></ul><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#EPTF_LwM2M_Transport_Definitions" >EPTF_LwM2M_Transport_Definitions</a></td><td class=SDescription>This module contains the generic transport definitions of the LwM2M load generator</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">fcb_EPTF_LwM2M_Transport_receiveMessage</a></td><td class=SDescription>Call-back function type for reporting received <a href="#EPTF_LwM2M_PDU" class=LType id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M messages</td></tr><tr class="SType"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">fcb_EPTF_LwM2M_Transport_receiveEvent</a></td><td class=SDescription>Call-back function type for reporting received <a href="#EPTF_LwM2M_Event" class=LType id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> LWM2M event</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#fcb_EPTF_LwM2M_Transport_sendMessage" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')">fcb_EPTF_LwM2M_Transport_sendMessage</a></td><td class=SDescription>Call-back function type for sending a <a href="#EPTF_LwM2M_PDU" class=LType id=link6 onMouseOver="ShowTip(event, 'tt2', 'link6')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M message</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_PDU" id=link7 onMouseOver="ShowTip(event, 'tt2', 'link7')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a></td><td class=SDescription>Encapsulates a &lt;LWM2M_PDU&gt; with the corresponding entity (and FSM) indices</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_Event" id=link8 onMouseOver="ShowTip(event, 'tt4', 'link8')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a></td><td class=SDescription>Encapsulates a <a href="#EPTF_LwM2M_Event" class=LType id=link9 onMouseOver="ShowTip(event, 'tt4', 'link9')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> with the corresponding entity</td></tr><tr class="SType"><td class=SEntry><a href="#LWM2M_Event" id=link10 onMouseOver="ShowTip(event, 'tt6', 'link10')" onMouseOut="HideTip('tt6')">LWM2M_Event</a></td><td class=SDescription>A union of possible LwM2M events</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#LWM2M_Event_Block1" id=link11 onMouseOver="ShowTip(event, 'tt7', 'link11')" onMouseOut="HideTip('tt7')">LWM2M_Event_Block1</a></td><td class=SDescription>Blcok1 event descriptor</td></tr><tr class="SEnumeration"><td class=SEntry><a href="#LWM2M_Block1_Method" >LWM2M_Block1_Method</a></td><td class=SDescription>Block1 method types</td></tr><tr class="SType SMarked"><td class=SEntry><a href="#EPTF_LwM2M_Transport_Provider_CT" id=link12 onMouseOver="ShowTip(event, 'tt8', 'link12')" onMouseOut="HideTip('tt8')">EPTF_LwM2M_Transport_Provider_CT</a></td><td class=SDescription>Base component type for a LwM2M transport realization</td></tr><tr class="SType"><td class=SEntry><a href="#EPTF_LwM2M_Transport_User_CT" id=link13 onMouseOver="ShowTip(event, 'tt9', 'link13')" onMouseOut="HideTip('tt9')">EPTF_LwM2M_Transport_User_CT</a></td><td class=SDescription>Base component type for a LwM2M transport user realization</td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_receiveMessage"></a>fcb_EPTF_LwM2M_Transport_receiveMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for reporting received <a href="#EPTF_LwM2M_PDU" class=LType id=link16 onMouseOver="ShowTip(event, 'tt2', 'link16')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M messages</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_PDU" class=LType id=link17 onMouseOver="ShowTip(event, 'tt2', 'link17')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> - received COAP message</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_receiveMessage"></a>fcb_EPTF_LwM2M_Transport_receiveMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for reporting received <a href="#EPTF_LwM2M_PDU" class=LType id=link17 onMouseOver="ShowTip(event, 'tt2', 'link17')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M messages</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_message</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_PDU" class=LType id=link18 onMouseOver="ShowTip(event, 'tt2', 'link18')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> - received COAP message</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_receiveEvent"></a>fcb_EPTF_LwM2M_Transport_receiveEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for reporting received <a href="#EPTF_LwM2M_Event" class=LType id=link18 onMouseOver="ShowTip(event, 'tt4', 'link18')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> LWM2M event</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_event</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_Event" class=LType id=link19 onMouseOver="ShowTip(event, 'tt4', 'link19')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> - received LWM2M event</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_receiveEvent"></a>fcb_EPTF_LwM2M_Transport_receiveEvent</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for reporting received <a href="#EPTF_LwM2M_Event" class=LType id=link19 onMouseOver="ShowTip(event, 'tt4', 'link19')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> LWM2M event</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>p_event</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_Event" class=LType id=link20 onMouseOver="ShowTip(event, 'tt4', 'link20')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> - received LWM2M event</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_sendMessage"></a>fcb_EPTF_LwM2M_Transport_sendMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for sending a <a href="#EPTF_LwM2M_PDU" class=LType id=link20 onMouseOver="ShowTip(event, 'tt2', 'link20')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M message</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_msg</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_PDU" class=LType id=link21 onMouseOver="ShowTip(event, 'tt2', 'link21')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> - LwM2M message to be sent</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="fcb_EPTF_LwM2M_Transport_sendMessage"></a>fcb_EPTF_LwM2M_Transport_sendMessage</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Call-back function type for sending a <a href="#EPTF_LwM2M_PDU" class=LType id=link21 onMouseOver="ShowTip(event, 'tt2', 'link21')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> LwM2M message</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_msg</td><td class=CDLDescription><b>in</b> <a href="#EPTF_LwM2M_PDU" class=LType id=link22 onMouseOver="ShowTip(event, 'tt2', 'link22')" onMouseOut="HideTip('tt2')">EPTF_LwM2M_PDU</a> - LwM2M message to be sent</td></tr></table></div></div></div>
 
 <div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_PDU"></a>EPTF_LwM2M_PDU</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Encapsulates a &lt;LWM2M_PDU&gt; with the corresponding entity (and FSM) indices</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pdu</td><td class=CDLDescription>&lt;LWM2M_PDU&gt; - LwM2M PDU</td></tr><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - entity index</td></tr><tr><td class=CDLEntry>fsmIdx</td><td class=CDLDescription><b>integer</b> - fsm index</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Event"></a>EPTF_LwM2M_Event</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Encapsulates a <a href="#EPTF_LwM2M_Event" class=LType id=link22 onMouseOver="ShowTip(event, 'tt4', 'link22')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> with the corresponding entity</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>event</td><td class=CDLDescription><a href="#LWM2M_Event" class=LType id=link23 onMouseOver="ShowTip(event, 'tt6', 'link23')" onMouseOut="HideTip('tt6')">LWM2M_Event</a> - LwM2M event</td></tr><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - entity index</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Event"></a>EPTF_LwM2M_Event</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Encapsulates a <a href="#EPTF_LwM2M_Event" class=LType id=link23 onMouseOver="ShowTip(event, 'tt4', 'link23')" onMouseOut="HideTip('tt4')">EPTF_LwM2M_Event</a> with the corresponding entity</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>event</td><td class=CDLDescription><a href="#LWM2M_Event" class=LType id=link24 onMouseOver="ShowTip(event, 'tt6', 'link24')" onMouseOut="HideTip('tt6')">LWM2M_Event</a> - LwM2M event</td></tr><tr><td class=CDLEntry>eIdx</td><td class=CDLDescription><b>integer</b> - entity index</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LWM2M_Event"></a>LWM2M_Event</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>A union of possible LwM2M events</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>resourceNotObserved</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#ObjectPath" class=LType id=link24 onMouseOver="ShowTip(event, 'tt10', 'link24')" onMouseOut="HideTip('tt10')">ObjectPath</a> - dispatched when a resource is not observed any more, the object path identifies the resource</td></tr><tr><td class=CDLEntry>atomicBlock1Finished</td><td class=CDLDescription>&lt;LWM2M_Event_Block1&gt; - in case an atomic block1 transfer finished, it is indicated here</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LWM2M_Event"></a>LWM2M_Event</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>A union of possible LwM2M events</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>resourceNotObserved</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#ObjectPath" class=LType id=link25 onMouseOver="ShowTip(event, 'tt11', 'link25')" onMouseOut="HideTip('tt11')">ObjectPath</a> - dispatched when a resource is not observed any more, the object path identifies the resource</td></tr><tr><td class=CDLEntry>atomicBlock1Finished</td><td class=CDLDescription><a href="#LWM2M_Event_Block1" class=LType id=link26 onMouseOver="ShowTip(event, 'tt7', 'link26')" onMouseOut="HideTip('tt7')">LWM2M_Event_Block1</a> - in case an atomic block1 transfer finished, it is indicated here</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Transport_Provider_CT"></a>EPTF_LwM2M_Transport_Provider_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Base component type for a LwM2M transport realization</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_Provider_CT.jpg)</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_receiveMessage</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_receiveMessage" class=LType id=link25 onMouseOver="ShowTip(event, 'tt1', 'link25')" onMouseOut="HideTip('tt1')">fcb_EPTF_LwM2M_Transport_receiveMessage</a> - Function hook for reporting received messages</td></tr><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_receiveEvent</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_receiveEvent" class=LType id=link26 onMouseOver="ShowTip(event, 'tt3', 'link26')" onMouseOut="HideTip('tt3')">fcb_EPTF_LwM2M_Transport_receiveEvent</a> - Function hook for reporting received events</td></tr></table></div></div></div>
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="LWM2M_Event_Block1"></a>LWM2M_Event_Block1</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LWM2M_Event_Block1</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Blcok1 event descriptor</p><h4 class=CHeading>Elements</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>path</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#ObjectPath" class=LType id=link27 onMouseOver="ShowTip(event, 'tt11', 'link27')" onMouseOut="HideTip('tt11')">ObjectPath</a> - path uri</td></tr><tr><td class=CDLEntry>method</td><td class=CDLDescription><a href="#LWM2M_Block1_Method" class=LType id=link28 onMouseOver="ShowTip(event, 'tt12', 'link28')" onMouseOut="HideTip('tt12')">LWM2M_Block1_Method</a> - method of the request</td></tr><tr><td class=CDLEntry>contentFormat</td><td class=CDLDescription>integer - content format code</td></tr><tr><td class=CDLEntry>resources</td><td class=CDLDescription><a href="LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=LType id=link29 onMouseOver="ShowTip(event, 'tt13', 'link29')" onMouseOut="HideTip('tt13')">LwM2M_Resource_List</a> - resource list</td></tr></table></div></div></div>
 
-<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Transport_User_CT"></a>EPTF_LwM2M_Transport_User_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Base component type for a LwM2M transport user realization</p><h4 class=CHeading>Class</h4><p>(see EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_User_CT.jpg)</p><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_send</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_sendMessage" class=LType id=link27 onMouseOver="ShowTip(event, 'tt5', 'link27')" onMouseOut="HideTip('tt5')">fcb_EPTF_LwM2M_Transport_sendMessage</a> - Function hook for reporting received messages</td></tr></table></div></div></div>
+<div class="CEnumeration"><div class=CTopic><h3 class=CTitle><a name="LWM2M_Block1_Method"></a>LWM2M_Block1_Method</h3><div class=CBody><h4 class=CHeading>Purpose</h4><p>Block1 method types</p><h4 class=CHeading>Elements</h4><ul><li>UNMAPPED</li><li>WRITE</li></ul></div></div></div>
+
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Transport_Provider_CT"></a>EPTF_LwM2M_Transport_Provider_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Base component type for a LwM2M transport realization</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_Provider_CT.jpg"><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_receiveMessage</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_receiveMessage" class=LType id=link30 onMouseOver="ShowTip(event, 'tt1', 'link30')" onMouseOut="HideTip('tt1')">fcb_EPTF_LwM2M_Transport_receiveMessage</a> - Function hook for reporting received messages</td></tr><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_receiveEvent</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_receiveEvent" class=LType id=link31 onMouseOver="ShowTip(event, 'tt3', 'link31')" onMouseOut="HideTip('tt3')">fcb_EPTF_LwM2M_Transport_receiveEvent</a> - Function hook for reporting received events</td></tr></table></div></div></div>
+
+<div class="CType"><div class=CTopic><h3 class=CTitle><a name="EPTF_LwM2M_Transport_User_CT"></a>EPTF_LwM2M_Transport_User_CT</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Base component type for a LwM2M transport user realization</p><h4 class=CHeading>Class</h4><img src="../images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_User_CT.jpg"><h4 class=CHeading>Variables</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>vf_EPTF_LwM2M_Transport_send</td><td class=CDLDescription><a href="#fcb_EPTF_LwM2M_Transport_sendMessage" class=LType id=link32 onMouseOver="ShowTip(event, 'tt5', 'link32')" onMouseOut="HideTip('tt5')">fcb_EPTF_LwM2M_Transport_sendMessage</a> - Function hook for reporting received messages</td></tr></table></div></div></div>
 
 </div><!--Content-->
 
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for sending a EPTF_LwM2M_PDU LwM2M message</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt9"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt10"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for sending a EPTF_LwM2M_PDU LwM2M message</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LWM2M_Event_Block1</td></tr></table></blockquote>Blcok1 event descriptor</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><div class=CToolTip id="tt10"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt11"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><div class=CToolTip id="tt12"><div class=CType>Block1 method types</div></div><div class=CToolTip id="tt13"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><!--END_ND_TOOLTIPS-->
 
 <script language=JavaScript><!--
 if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/files/LightweightM2M_Types-ttcn.html b/apidoc/html/files/LightweightM2M_Types-ttcn.html
index 099d239..6c7ab99 100644
--- a/apidoc/html/files/LightweightM2M_Types-ttcn.html
+++ b/apidoc/html/files/LightweightM2M_Types-ttcn.html
@@ -1,4 +1,4 @@
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LightweightM2M_Types - LwM2M_Applib</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LightweightM2M_Types - Massive IoT Test Tools</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
diff --git a/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_CT.jpg b/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_CT.jpg
new file mode 100644
index 0000000..be6b9d5
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_CT.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_Statistics.jpg b/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_Statistics.jpg
new file mode 100644
index 0000000..6c14482
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_CoapApplibTransport_Definitions.EPTF_LwM2M_CoapApplibTransport_Statistics.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg
new file mode 100644
index 0000000..748c783
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg
new file mode 100644
index 0000000..2be5268
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg
new file mode 100644
index 0000000..07c4adc
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg
new file mode 100644
index 0000000..530029e
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg
new file mode 100644
index 0000000..712b4fa
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg
new file mode 100644
index 0000000..d674efa
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.classes.jpg b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.classes.jpg
new file mode 100644
index 0000000..19b6d24
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_LGen_Definitions.classes.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples.jpg
new file mode 100644
index 0000000..c105d52
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples_DB.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples_DB.jpg
new file mode 100644
index 0000000..eedfb61
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_DataSamples_DB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_Object.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_Object.jpg
new file mode 100644
index 0000000..c9fb3dd
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_Object.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectDB.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectDB.jpg
new file mode 100644
index 0000000..2f1d254
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectDB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectInstance.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectInstance.jpg
new file mode 100644
index 0000000..707481d
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectInstance.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecification.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecification.jpg
new file mode 100644
index 0000000..34d97db
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecification.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecificationDB.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecificationDB.jpg
new file mode 100644
index 0000000..3f8ab83
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ObjectSpecificationDB.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ResourceSpecification.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ResourceSpecification.jpg
new file mode 100644
index 0000000..fce625b
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.LwM2M_ResourceSpecification.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Object_Definitions.classes.jpg b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.classes.jpg
new file mode 100644
index 0000000..83d3622
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Object_Definitions.classes.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_Provider_CT.jpg b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_Provider_CT.jpg
new file mode 100644
index 0000000..276cabc
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_Provider_CT.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_User_CT.jpg b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_User_CT.jpg
new file mode 100644
index 0000000..791b23b
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.EPTF_LwM2M_Transport_User_CT.jpg
Binary files differ
diff --git a/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.components.jpg b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.components.jpg
new file mode 100644
index 0000000..dbe8727
--- /dev/null
+++ b/apidoc/html/images/EPTF_LwM2M_Transport_Definitions.components.jpg
Binary files differ
diff --git a/apidoc/html/index.html b/apidoc/html/index.html
index 4e794f8..8ba517b 100644
--- a/apidoc/html/index.html
+++ b/apidoc/html/index.html
@@ -1,10 +1,10 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Frameset//EN" "http://www.w3.org/TR/REC-html40/frameset.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib</title></head>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Frameset//EN" "http://www.w3.org/TR/REC-html40/frameset.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools</title></head>
 
 <!--  Generated by Natural Docs, version 1.52 -->
 <!--  http://www.naturaldocs.org  -->
 
 <!-- saved from url=(0026)http://www.naturaldocs.org -->
 
-<frameset cols="185,*"><frame name=Menu src="menu.html"><frame name=Content src="files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html"></frameset><noframes>This documentation was designed for use with frames.  However, you can still use it by <a href="menu.html">starting from the menu page</a>.<script language=JavaScript><!--
+<frameset cols="185,*"><frame name=Menu src="menu.html"><frame name=Content src="files/EPTF_LwM2M_LGen_Definitions-ttcn.html">starting from the menu page</a>.<script language=JavaScript><!--
 location.href="menu.html";
-// --></script></noframes></html>
\ No newline at end of file
+// --></script></noframes></html>
diff --git a/apidoc/html/index/Constants.html b/apidoc/html/index/Constants.html
index 1fe1e6c..4478e09 100644
--- a/apidoc/html/index/Constants.html
+++ b/apidoc/html/index/Constants.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Constant Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Constant Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,9 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Constant Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="#C">C</a> &middot; D &middot; E &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="C"></a>C</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>c_LwM2M_behaviorType</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>c_LwM2M_eventIdx_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>c_LwM2M_eventIdx_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>c_LwM2M_eventIdx_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>c_LwM2M_eventIdx_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>c_LwM2M_eventIdx_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>c_LwM2M_eventIdx_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>c_LwM2M_eventIdx_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>c_LwM2M_eventIdx_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>c_LwM2M_eventIdx_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>c_LwM2M_eventIdx_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>c_LwM2M_eventIdx_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>c_LwM2M_eventIdx_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>c_LwM2M_eventIdx_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>c_LwM2M_eventIdx_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>c_LwM2M_eventName_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>c_LwM2M_eventName_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>c_LwM2M_eventName_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>c_LwM2M_eventName_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>c_LwM2M_eventName_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>c_LwM2M_eventName_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>c_LwM2M_eventName_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>c_LwM2M_eventName_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>c_LwM2M_eventName_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>c_LwM2M_eventName_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>c_LwM2M_eventName_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>c_LwM2M_eventName_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>c_LwM2M_eventName_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>c_LwM2M_eventName_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>c_LwM2M_stepIdx_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>c_LwM2M_stepName_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>c_LwM2M_stepName_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>c_LwM2M_stepName_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>c_LwM2M_stepName_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Constant Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="#C">C</a> &middot; D &middot; E &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="C"></a>C</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>c_LwM2M_behaviorType</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>c_LwM2M_eventIdx_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>c_LwM2M_eventIdx_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>c_LwM2M_eventIdx_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>c_LwM2M_eventIdx_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>c_LwM2M_eventIdx_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>c_LwM2M_eventIdx_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>c_LwM2M_eventIdx_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>c_LwM2M_eventIdx_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>c_LwM2M_eventIdx_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>c_LwM2M_eventIdx_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>c_LwM2M_eventIdx_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>c_LwM2M_eventIdx_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>c_LwM2M_eventIdx_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>c_LwM2M_eventIdx_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>c_LwM2M_eventName_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>c_LwM2M_eventName_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>c_LwM2M_eventName_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>c_LwM2M_eventName_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>c_LwM2M_eventName_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>c_LwM2M_eventName_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>c_LwM2M_eventName_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>c_LwM2M_eventName_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>c_LwM2M_eventName_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>c_LwM2M_eventName_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>c_LwM2M_eventName_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>c_LwM2M_eventName_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>c_LwM2M_eventName_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>c_LwM2M_eventName_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>c_LwM2M_stepIdx_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setContentFormats" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>c_LwM2M_stepIdx_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>c_LwM2M_stepName_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>c_LwM2M_stepName_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>c_LwM2M_stepName_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>c_LwM2M_stepName_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setContentFormats" id=link83 onMouseOver="ShowTip(event, 'tt83', 'link83')" onMouseOut="HideTip('tt83')" class=ISymbol>c_LwM2M_stepName_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" id=link84 onMouseOver="ShowTip(event, 'tt84', 'link84')" onMouseOut="HideTip('tt84')" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt3"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt4"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt5"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt6"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt7"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt8"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt9"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt10"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt11"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt12"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt13"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt14"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt82"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt3"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt4"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt5"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt6"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt7"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt8"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt9"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt10"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt11"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt12"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt13"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt14"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setContentFormats := 18</td></tr></table></blockquote>Integer constant for setting the preferred content formats</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setContentFormats := &quot;LWM2M Applib: setContentFormats&quot;</td></tr></table></blockquote>Charstring constant for setting the preferred content format</div></div><div class=CToolTip id="tt84"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/Files.html b/apidoc/html/index/Files.html
index 9f2187f..19cda31 100644
--- a/apidoc/html/index/Files.html
+++ b/apidoc/html/index/Files.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - File Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - File Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,9 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>File Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; <a href="#E">E</a> &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>EPTF_LwM2M_Object_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>EPTF_LwM2M_Object_Functions</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></td></tr><tr><td class=IHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IOnlySymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>LightweightM2M_Types</a></td></tr></table>
+<div id=Index><div class=IPageTitle>File Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; <a href="#E">E</a> &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><span class=ISymbol>EPTF_LwM2M_Object_Definitions</span><div class=ISubIndex><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=IFile>EPTF_LwM2M_Object_Decoders.ttcn</a><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link6 onMouseOver="ShowTip(event, 'tt5', 'link6')" onMouseOut="HideTip('tt5')" class=IFile>EPTF_LwM2M_Object_Definitions.ttcn</a></div></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" id=link7 onMouseOver="ShowTip(event, 'tt6', 'link7')" onMouseOut="HideTip('tt6')" class=ISymbol>EPTF_LwM2M_Object_Functions</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" id=link8 onMouseOver="ShowTip(event, 'tt7', 'link8')" onMouseOut="HideTip('tt7')" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></td></tr><tr><td class=IHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IOnlySymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" id=link9 onMouseOver="ShowTip(event, 'tt8', 'link9')" onMouseOut="HideTip('tt8')" class=ISymbol>LightweightM2M_Types</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CFile>This module contains the definitions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt2"><div class=CFile>This module contains the functions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt3"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt4"><div class=CFile>This module contains the functions of the LWM2M load generator component</div></div><div class=CToolTip id="tt5"><div class=CFile>This module contains the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt6"><div class=CFile>This module contains the functions of the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt7"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CFile>This module contains the definitions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt2"><div class=CFile>This module contains the functions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt3"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt4"><div class=CFile>This module contains the functions of the LWM2M load generator component</div></div><div class=CToolTip id="tt5"><div class=CFile>This module contains the smart object decoder functions</div></div><div class=CToolTip id="tt6"><div class=CFile>This module contains the functions of the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt7"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><!--END_ND_TOOLTIPS-->
 
 
 <!--START_ND_TOOLTIPS-->
diff --git a/apidoc/html/index/Functions.html b/apidoc/html/index/Functions.html
index 2b8ffed..6925d5e 100644
--- a/apidoc/html/index/Functions.html
+++ b/apidoc/html/index/Functions.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Function Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Function Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,9 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Function Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; E &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>f_EPTF_LwM2M_setCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>f_LwM2M_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>f_LwM2M_createResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>f_LwM2M_eCtxBind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>f_LwM2M_eCtxReset</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>f_LwM2M_eCtxUnbind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>f_LwM2M_ObjectDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>f_LwM2M_resourceHash_forIds</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>f_LwM2M_resourceHash_forResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>f_LwM2M_step_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>f_LwM2M_step_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>f_LwM2M_step_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>f_LwM2M_step_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>f_LwM2M_step_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>f_LwM2M_step_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>f_LwM2M_step_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" id=link83 onMouseOver="ShowTip(event, 'tt83', 'link83')" onMouseOut="HideTip('tt83')" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" id=link84 onMouseOver="ShowTip(event, 'tt84', 'link84')" onMouseOut="HideTip('tt84')" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" id=link85 onMouseOver="ShowTip(event, 'tt85', 'link85')" onMouseOut="HideTip('tt85')" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" id=link86 onMouseOver="ShowTip(event, 'tt86', 'link86')" onMouseOut="HideTip('tt86')" class=ISymbol>f_LwM2M_step_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" id=link87 onMouseOver="ShowTip(event, 'tt87', 'link87')" onMouseOut="HideTip('tt87')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" id=link88 onMouseOver="ShowTip(event, 'tt88', 'link88')" onMouseOut="HideTip('tt88')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" id=link89 onMouseOver="ShowTip(event, 'tt89', 'link89')" onMouseOut="HideTip('tt89')" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" id=link90 onMouseOver="ShowTip(event, 'tt90', 'link90')" onMouseOut="HideTip('tt90')" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Function Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; E &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_canEncode" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>f_EPTF_LwM2M_canEncode</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getEncodingContentFormat" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>f_EPTF_LwM2M_getEncodingContentFormat</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>f_EPTF_LwM2M_setCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_updateMessageStatistics" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>f_EPTF_LwM2M_updateMessageStatistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>f_LwM2M_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>f_LwM2M_createResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>f_LwM2M_eCtxBind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>f_LwM2M_eCtxReset</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>f_LwM2M_eCtxUnbind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>f_LwM2M_ObjectDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_checkSpecification" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>f_LwM2M_Resource_checkSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#f_LwM2M_Resource_decode" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>f_LwM2M_Resource_decode</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_getSpecification" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>f_LwM2M_Resource_getSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>f_LwM2M_resourceHash_forIds</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>f_LwM2M_resourceHash_forResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>f_LwM2M_step_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>f_LwM2M_step_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>f_LwM2M_step_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>f_LwM2M_step_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" id=link83 onMouseOver="ShowTip(event, 'tt83', 'link83')" onMouseOut="HideTip('tt83')" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" id=link84 onMouseOver="ShowTip(event, 'tt84', 'link84')" onMouseOut="HideTip('tt84')" class=ISymbol>f_LwM2M_step_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" id=link85 onMouseOver="ShowTip(event, 'tt85', 'link85')" onMouseOut="HideTip('tt85')" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" id=link86 onMouseOver="ShowTip(event, 'tt86', 'link86')" onMouseOut="HideTip('tt86')" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" id=link87 onMouseOver="ShowTip(event, 'tt87', 'link87')" onMouseOut="HideTip('tt87')" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" id=link88 onMouseOver="ShowTip(event, 'tt88', 'link88')" onMouseOut="HideTip('tt88')" class=ISymbol>f_LwM2M_step_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" id=link89 onMouseOver="ShowTip(event, 'tt89', 'link89')" onMouseOut="HideTip('tt89')" class=ISymbol>f_LwM2M_step_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" id=link90 onMouseOver="ShowTip(event, 'tt90', 'link90')" onMouseOut="HideTip('tt90')" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" id=link91 onMouseOver="ShowTip(event, 'tt91', 'link91')" onMouseOut="HideTip('tt91')" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" id=link92 onMouseOver="ShowTip(event, 'tt92', 'link92')" onMouseOut="HideTip('tt92')" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" id=link93 onMouseOver="ShowTip(event, 'tt93', 'link93')" onMouseOut="HideTip('tt93')" class=ISymbol>f_LwM2M_step_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" id=link94 onMouseOver="ShowTip(event, 'tt94', 'link94')" onMouseOut="HideTip('tt94')" class=ISymbol>f_LwM2M_step_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" id=link95 onMouseOver="ShowTip(event, 'tt95', 'link95')" onMouseOut="HideTip('tt95')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" id=link96 onMouseOver="ShowTip(event, 'tt96', 'link96')" onMouseOut="HideTip('tt96')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" id=link97 onMouseOver="ShowTip(event, 'tt97', 'link97')" onMouseOut="HideTip('tt97')" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" id=link98 onMouseOver="ShowTip(event, 'tt98', 'link98')" onMouseOut="HideTip('tt98')" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_CoapApplibTransport_cleanup() runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt2"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_eventIndication(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_EventDescriptor&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be registered into the COAP applib used as transport layer to receive EPTF_COAP_EventDescriptor EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_eventIndication</b> with type fcb_EPTF_COAP_eventIndication where this function can be registered in. </div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>The main initialization function of the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_messageReceived(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_duplicate,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_autoHandled</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be regsitered into the COAP applib used as transport layer to receive EPTF_COAP_PDU EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_msgReceived</b> with type fcb_EPTF_COAP_messageReceived where this function can be registered in. </div></div><div class=CToolTip id="tt5"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_path</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>This function translates an ObjectPath to its charstring representation</div></div><div class=CToolTip id="tt6"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Function to send out a EPTF_LwM2M_PDU message using the local transport. </div></div><div class=CToolTip id="tt7"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt8"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt9"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt11"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt12"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt13"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt14"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt16"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt44"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt47"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt48"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt49"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt50"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt51"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt52"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt53"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt54"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt55"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt56"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt57"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt58"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt59"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt60"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt61"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt62"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_observed</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt63"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt64"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt65"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt66"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt67"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt68"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt69"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt70"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt71"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt72"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt73"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt74"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt75"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt76"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt77"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt78"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt79"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt80"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt81"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt82"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt83"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt84"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt85"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt86"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt87"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt88"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt89"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt90"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_canEncode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_code,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Finds out if a list of resources can be encoded with a certain content format</div></div><div class=CToolTip id="tt2"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_CoapApplibTransport_cleanup() runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt3"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_eventIndication(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_EventDescriptor&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be registered into the COAP applib used as transport layer to receive EPTF_COAP_EventDescriptor EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_eventIndication</b> with type fcb_EPTF_COAP_eventIndication where this function can be registered in. </div></div><div class=CToolTip id="tt4"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>The main initialization function of the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt5"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_messageReceived(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_duplicate,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_autoHandled</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be regsitered into the COAP applib used as transport layer to receive EPTF_COAP_PDU EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_msgReceived</b> with type fcb_EPTF_COAP_messageReceived where this function can be registered in. </div></div><div class=CToolTip id="tt6"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_path</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>This function translates an ObjectPath to its charstring representation</div></div><div class=CToolTip id="tt7"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Function to send out a EPTF_LwM2M_PDU message using the local transport. </div></div><div class=CToolTip id="tt8"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt9"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt10"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt11"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt12"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt13"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt14"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt15"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt16"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt17"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt18"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt19"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt20"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getEncodingContentFormat(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Format_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_preferred,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Integer_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_accepted,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Negotiates an encoding format based on this side&rsquo;s preferred, the other side&rsquo;s accepted and the list of resources to be encoded</div></div><div class=CToolTip id="tt21"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt22"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt23"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_updateMessageStatistics(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Message_Statistics&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_stats,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Updates the message statistics based on the incoming PDU</div></div><div class=CToolTip id="tt44"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt47"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt48"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt49"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt50"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt51"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt52"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt53"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt54"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt55"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt56"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt57"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt58"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt59"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt60"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt61"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt62"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt63"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt64"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt65"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resourceId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_observed,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in template integer&nbsp;</td><td class="PType  prettyprint " nowrap>p_contentFormat&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> omit</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt66"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt67"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt68"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt69"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt70"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_ResourceSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt71"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt72"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt73"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_checkSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>template&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to check the specification of a LwM2M_Resource instance against a template</div></div><div class=CToolTip id="tt74"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_decode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_contentFormat</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Decodes a resource based on a contnet format and its spceification</div></div><div class=CToolTip id="tt75"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_getSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to look up the specification of a LwM2M_Resource instance</div></div><div class=CToolTip id="tt76"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt77"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt78"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt79"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt80"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt81"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt82"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt83"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt84"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt85"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt86"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt87"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt88"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt89"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt90"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt91"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt92"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt93"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt94"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setContentFormats(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the preferred encoding content format for a LwM2M_Device</div></div><div class=CToolTip id="tt95"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt96"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt97"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to NOT_REGISTERED.</div></div><div class=CToolTip id="tt98"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/General.html b/apidoc/html/index/General.html
index 4838a31..a94e6a0 100644
--- a/apidoc/html/index/General.html
+++ b/apidoc/html/index/General.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,13 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="#C">C</a> &middot; D &middot; <a href="#E">E</a> &middot; <a href="General2.html#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="General3.html#L">L</a> &middot; M &middot; N &middot; <a href="General3.html#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="General3.html#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="C"></a>C</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>c_LwM2M_behaviorType</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>c_LwM2M_eventIdx_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>c_LwM2M_eventIdx_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>c_LwM2M_eventIdx_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>c_LwM2M_eventIdx_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>c_LwM2M_eventIdx_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>c_LwM2M_eventIdx_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>c_LwM2M_eventIdx_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>c_LwM2M_eventIdx_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>c_LwM2M_eventIdx_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>c_LwM2M_eventIdx_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>c_LwM2M_eventIdx_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>c_LwM2M_eventIdx_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>c_LwM2M_eventIdx_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>c_LwM2M_eventIdx_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>c_LwM2M_eventName_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>c_LwM2M_eventName_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>c_LwM2M_eventName_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>c_LwM2M_eventName_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>c_LwM2M_eventName_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>c_LwM2M_eventName_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>c_LwM2M_eventName_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>c_LwM2M_eventName_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>c_LwM2M_eventName_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>c_LwM2M_eventName_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>c_LwM2M_eventName_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>c_LwM2M_eventName_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>c_LwM2M_eventName_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>c_LwM2M_eventName_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>c_LwM2M_stepIdx_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>c_LwM2M_stepName_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>c_LwM2M_stepName_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>c_LwM2M_stepName_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>c_LwM2M_stepName_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></td></tr><tr><td class=IHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" id=link83 onMouseOver="ShowTip(event, 'tt83', 'link83')" onMouseOut="HideTip('tt83')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" id=link84 onMouseOver="ShowTip(event, 'tt84', 'link84')" onMouseOut="HideTip('tt84')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" id=link85 onMouseOver="ShowTip(event, 'tt85', 'link85')" onMouseOut="HideTip('tt85')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" id=link86 onMouseOver="ShowTip(event, 'tt86', 'link86')" onMouseOut="HideTip('tt86')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" id=link87 onMouseOver="ShowTip(event, 'tt87', 'link87')" onMouseOut="HideTip('tt87')" class=ISymbol>EPTF_LwM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" id=link88 onMouseOver="ShowTip(event, 'tt88', 'link88')" onMouseOut="HideTip('tt88')" class=ISymbol>EPTF_LwM2M_LGen_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" id=link89 onMouseOver="ShowTip(event, 'tt89', 'link89')" onMouseOut="HideTip('tt89')" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" id=link90 onMouseOver="ShowTip(event, 'tt90', 'link90')" onMouseOut="HideTip('tt90')" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" id=link91 onMouseOver="ShowTip(event, 'tt91', 'link91')" onMouseOut="HideTip('tt91')" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" id=link92 onMouseOver="ShowTip(event, 'tt92', 'link92')" onMouseOut="HideTip('tt92')" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link93 onMouseOver="ShowTip(event, 'tt93', 'link93')" onMouseOut="HideTip('tt93')" class=ISymbol>EPTF_LwM2M_Object_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" id=link94 onMouseOver="ShowTip(event, 'tt94', 'link94')" onMouseOut="HideTip('tt94')" class=ISymbol>EPTF_LwM2M_Object_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" id=link95 onMouseOver="ShowTip(event, 'tt95', 'link95')" onMouseOut="HideTip('tt95')" class=ISymbol>EPTF_LwM2M_PDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" id=link96 onMouseOver="ShowTip(event, 'tt96', 'link96')" onMouseOut="HideTip('tt96')" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" id=link97 onMouseOver="ShowTip(event, 'tt97', 'link97')" onMouseOut="HideTip('tt97')" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" id=link98 onMouseOver="ShowTip(event, 'tt98', 'link98')" onMouseOut="HideTip('tt98')" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="#C">C</a> &middot; D &middot; <a href="General2.html#E">E</a> &middot; <a href="General3.html#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="General4.html#L">L</a> &middot; M &middot; N &middot; <a href="General4.html#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="General4.html#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="C"></a>C</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>c_LwM2M_behaviorType</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>c_LwM2M_eventIdx_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>c_LwM2M_eventIdx_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>c_LwM2M_eventIdx_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>c_LwM2M_eventIdx_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>c_LwM2M_eventIdx_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>c_LwM2M_eventIdx_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>c_LwM2M_eventIdx_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>c_LwM2M_eventIdx_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>c_LwM2M_eventIdx_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>c_LwM2M_eventIdx_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>c_LwM2M_eventIdx_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>c_LwM2M_eventIdx_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>c_LwM2M_eventIdx_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>c_LwM2M_eventIdx_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>c_LwM2M_eventName_1xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>c_LwM2M_eventName_2xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>c_LwM2M_eventName_3xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>c_LwM2M_eventName_4xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>c_LwM2M_eventName_5xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>c_LwM2M_eventName_6xx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>c_LwM2M_eventName_Create</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>c_LwM2M_eventName_Delete</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>c_LwM2M_eventName_Deregister</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>c_LwM2M_eventName_Execute</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>c_LwM2M_eventName_Observe</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>c_LwM2M_eventName_Read</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>c_LwM2M_eventName_Register</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>c_LwM2M_eventName_Update</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>c_LwM2M_eventName_Write</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" id=link51 onMouseOver="ShowTip(event, 'tt51', 'link51')" onMouseOut="HideTip('tt51')" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" id=link52 onMouseOver="ShowTip(event, 'tt52', 'link52')" onMouseOut="HideTip('tt52')" class=ISymbol>c_LwM2M_stepIdx_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" id=link53 onMouseOver="ShowTip(event, 'tt53', 'link53')" onMouseOut="HideTip('tt53')" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" id=link54 onMouseOver="ShowTip(event, 'tt54', 'link54')" onMouseOut="HideTip('tt54')" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" id=link55 onMouseOver="ShowTip(event, 'tt55', 'link55')" onMouseOut="HideTip('tt55')" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" id=link56 onMouseOver="ShowTip(event, 'tt56', 'link56')" onMouseOut="HideTip('tt56')" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" id=link57 onMouseOver="ShowTip(event, 'tt57', 'link57')" onMouseOut="HideTip('tt57')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" id=link58 onMouseOver="ShowTip(event, 'tt58', 'link58')" onMouseOut="HideTip('tt58')" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" id=link59 onMouseOver="ShowTip(event, 'tt59', 'link59')" onMouseOut="HideTip('tt59')" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" id=link60 onMouseOver="ShowTip(event, 'tt60', 'link60')" onMouseOut="HideTip('tt60')" class=ISymbol>c_LwM2M_stepIdx_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" id=link61 onMouseOver="ShowTip(event, 'tt61', 'link61')" onMouseOut="HideTip('tt61')" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" id=link62 onMouseOver="ShowTip(event, 'tt62', 'link62')" onMouseOut="HideTip('tt62')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" id=link63 onMouseOver="ShowTip(event, 'tt63', 'link63')" onMouseOut="HideTip('tt63')" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" id=link64 onMouseOver="ShowTip(event, 'tt64', 'link64')" onMouseOut="HideTip('tt64')" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setContentFormats" id=link65 onMouseOver="ShowTip(event, 'tt65', 'link65')" onMouseOut="HideTip('tt65')" class=ISymbol>c_LwM2M_stepIdx_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" id=link66 onMouseOver="ShowTip(event, 'tt66', 'link66')" onMouseOut="HideTip('tt66')" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" id=link67 onMouseOver="ShowTip(event, 'tt67', 'link67')" onMouseOut="HideTip('tt67')" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" id=link68 onMouseOver="ShowTip(event, 'tt68', 'link68')" onMouseOut="HideTip('tt68')" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" id=link69 onMouseOver="ShowTip(event, 'tt69', 'link69')" onMouseOut="HideTip('tt69')" class=ISymbol>c_LwM2M_stepName_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" id=link70 onMouseOver="ShowTip(event, 'tt70', 'link70')" onMouseOut="HideTip('tt70')" class=ISymbol>c_LwM2M_stepName_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" id=link71 onMouseOver="ShowTip(event, 'tt71', 'link71')" onMouseOut="HideTip('tt71')" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" id=link72 onMouseOver="ShowTip(event, 'tt72', 'link72')" onMouseOut="HideTip('tt72')" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" id=link73 onMouseOver="ShowTip(event, 'tt73', 'link73')" onMouseOut="HideTip('tt73')" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" id=link74 onMouseOver="ShowTip(event, 'tt74', 'link74')" onMouseOut="HideTip('tt74')" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" id=link75 onMouseOver="ShowTip(event, 'tt75', 'link75')" onMouseOut="HideTip('tt75')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" id=link76 onMouseOver="ShowTip(event, 'tt76', 'link76')" onMouseOut="HideTip('tt76')" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" id=link77 onMouseOver="ShowTip(event, 'tt77', 'link77')" onMouseOut="HideTip('tt77')" class=ISymbol>c_LwM2M_stepName_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" id=link78 onMouseOver="ShowTip(event, 'tt78', 'link78')" onMouseOut="HideTip('tt78')" class=ISymbol>c_LwM2M_stepName_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" id=link79 onMouseOver="ShowTip(event, 'tt79', 'link79')" onMouseOut="HideTip('tt79')" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" id=link80 onMouseOver="ShowTip(event, 'tt80', 'link80')" onMouseOut="HideTip('tt80')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" id=link81 onMouseOver="ShowTip(event, 'tt81', 'link81')" onMouseOut="HideTip('tt81')" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" id=link82 onMouseOver="ShowTip(event, 'tt82', 'link82')" onMouseOut="HideTip('tt82')" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setContentFormats" id=link83 onMouseOver="ShowTip(event, 'tt83', 'link83')" onMouseOut="HideTip('tt83')" class=ISymbol>c_LwM2M_stepName_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" id=link84 onMouseOver="ShowTip(event, 'tt84', 'link84')" onMouseOut="HideTip('tt84')" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt3"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt4"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt5"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt6"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt7"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt8"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt9"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt10"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt11"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt12"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt13"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt14"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt82"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><!--END_ND_TOOLTIPS-->
-
-
-<!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt83"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>LWM2M local transport component realized with EPTF_COAP_LGen_CT</div></div><div class=CToolTip id="tt84"><div class=CFile>This module contains the definitions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt85"><div class=CFile>This module contains the functions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt86"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_CoapApplibTransport_Statistics</td></tr></table></blockquote>Storing counters for transport related statistics</div></div><div class=CToolTip id="tt87"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt88"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt89"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt90"><div class=CFile>This module contains the functions of the LWM2M load generator component</div></div><div class=CToolTip id="tt91"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote>Storing counters for load generator related statistics</div></div><div class=CToolTip id="tt92"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt93"><div class=CFile>This module contains the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt94"><div class=CFile>This module contains the functions of the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt95"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt96"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><div class=CToolTip id="tt97"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt98"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_behaviorType := &quot;LWM2M Behavior&quot;</td></tr></table></blockquote>Constant for LWM2M behaviour name</div></div><div class=CToolTip id="tt2"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_1xx := 700</td></tr></table></blockquote>Integer constant for the LWM2M 1xx reponse event</div></div><div class=CToolTip id="tt3"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_2xx := 701</td></tr></table></blockquote>Integer constant for the LWM2M 2xx reponse event</div></div><div class=CToolTip id="tt4"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xx := 702</td></tr></table></blockquote>Integer constant for the LWM2M 3xx reponse event</div></div><div class=CToolTip id="tt5"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_3xxto6xx := 706</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt6"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_4xx := 703</td></tr></table></blockquote>Integer constant for the LWM2M 4xx reponse event</div></div><div class=CToolTip id="tt7"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_5xx := 704</td></tr></table></blockquote>Integer constant for the LWM2M 5xx reponse event</div></div><div class=CToolTip id="tt8"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_6xx := 705</td></tr></table></blockquote>Integer constant for the LWM2M 6xx reponse event</div></div><div class=CToolTip id="tt9"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708</td></tr></table></blockquote>Integer constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt10"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Delete := 12</td></tr></table></blockquote>Integer constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt11"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Discover := 14</td></tr></table></blockquote>Integer constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt12"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_BS_Finish := 13</td></tr></table></blockquote>Integer constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt13"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Create := 6</td></tr></table></blockquote>Integer constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt14"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Delete := 7</td></tr></table></blockquote>Integer constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Deregister := 2</td></tr></table></blockquote>Integer constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Execute := 5</td></tr></table></blockquote>Integer constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11</td></tr></table></blockquote>Integer constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Observe := 8</td></tr></table></blockquote>Integer constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Read := 3</td></tr></table></blockquote>Integer constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Register := 0</td></tr></table></blockquote>Integer constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707</td></tr></table></blockquote>Integer constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Update := 1</td></tr></table></blockquote>Integer constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_Write := 4</td></tr></table></blockquote>Integer constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt24"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWPackage := 10</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt25"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_eventIdx_WriteFWUri := 9</td></tr></table></blockquote>Integer constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt26"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_1xx := &quot;LWM2M rsp: 1xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 1xx response event</div></div><div class=CToolTip id="tt27"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_2xx := &quot;LWM2M rsp: 2xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 2xx response event</div></div><div class=CToolTip id="tt28"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xx := &quot;LWM2M rsp: 3xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 3xx response event</div></div><div class=CToolTip id="tt29"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_3xxto6xx := &quot;LWM2M rsp: 3xxto6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt30"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_4xx := &quot;LWM2M rsp: 4xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 4xx response event</div></div><div class=CToolTip id="tt31"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_5xx := &quot;LWM2M rsp: 5xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 5xx response event</div></div><div class=CToolTip id="tt32"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_6xx := &quot;LWM2M rsp: 6xx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M 6xx response event</div></div><div class=CToolTip id="tt33"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_atomicBlock1Finished := &quot;LWM2M ind: atomic Block1 transfer finished&quot;</td></tr></table></blockquote>Charstring constant for indicating that a block1 transfer was finished</div></div><div class=CToolTip id="tt34"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Delete := &quot;LWM2M req: BS_Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Delete request event</div></div><div class=CToolTip id="tt35"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Discover := &quot;LWM2M req: BS_Discover&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Discover request event</div></div><div class=CToolTip id="tt36"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_BS_Finish := &quot;LWM2M req: BS_Finish&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M BS_Finish request event</div></div><div class=CToolTip id="tt37"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Create := &quot;LWM2M req: Create&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Create request event</div></div><div class=CToolTip id="tt38"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Delete := &quot;LWM2M req: Delete&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Delete request event</div></div><div class=CToolTip id="tt39"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Deregister := &quot;LWM2M req: Deregister&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Deregister request event</div></div><div class=CToolTip id="tt40"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Execute := &quot;LWM2M req: Execute&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Execute request event</div></div><div class=CToolTip id="tt41"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_ExecuteFWUpdate := &quot;LWM2M req: ExecuteFWUpdate&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M ExecuteFWUpdate request event</div></div><div class=CToolTip id="tt42"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Observe := &quot;LWM2M req: Observe&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Observe request event</div></div><div class=CToolTip id="tt43"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Read := &quot;LWM2M req: Read&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Read request event</div></div><div class=CToolTip id="tt44"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Register := &quot;LWM2M req: Register&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Register request event</div></div><div class=CToolTip id="tt45"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_resourceNotObservedIndication := &quot;LWM2M ind: resource not observed&quot;</td></tr></table></blockquote>Charstring constant for the resource not observed any more indication This event occurs after all subscribers unsubscribed from a resource</div></div><div class=CToolTip id="tt46"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Update := &quot;LWM2M req: Update&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Update request event</div></div><div class=CToolTip id="tt47"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_Write := &quot;LWM2M req: Write&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M Write request event</div></div><div class=CToolTip id="tt48"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWPackage := &quot;LWM2M req: WriteFWPackage&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWPackage request event</div></div><div class=CToolTip id="tt49"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_eventName_WriteFWUri := &quot;LWM2M req: WriteFWUri&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M WriteFWUri request event</div></div><div class=CToolTip id="tt50"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_cleanupDevice := 3</td></tr></table></blockquote>Integer constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt51"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createDevice := 2</td></tr></table></blockquote>Integer constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt52"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObject := 5</td></tr></table></blockquote>Integer constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt53"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_createObjectInstance := 6</td></tr></table></blockquote>Integer constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt54"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleExecuteRequest := 9</td></tr></table></blockquote>Integer constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt55"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleReadRequest := 7</td></tr></table></blockquote>Integer constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt56"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_handleWriteRequest := 8</td></tr></table></blockquote>Integer constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt57"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0</td></tr></table></blockquote>Integer constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt58"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10</td></tr></table></blockquote>Integer constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt59"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_logDevice := 4</td></tr></table></blockquote>Integer constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt60"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_send := 1</td></tr></table></blockquote>Integer constant for the LWM2M send test step</div></div><div class=CToolTip id="tt61"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11</td></tr></table></blockquote>Integer constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt62"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt63"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16</td></tr></table></blockquote>Integer constant for the  LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt64"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setBootstrapState := 14</td></tr></table></blockquote>Integer constant for the  LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt65"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setContentFormats := 18</td></tr></table></blockquote>Integer constant for setting the preferred content formats</div></div><div class=CToolTip id="tt66"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13</td></tr></table></blockquote>Integer constant for the LWM2M set firmware update result test step</div></div><div class=CToolTip id="tt67"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const integer c_LwM2M_stepIdx_setNotRegisteredState := 15</td></tr></table></blockquote>Integer constant for the  LWM2M set not registered state test step</div></div><div class=CToolTip id="tt68"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_cleanupDevice := &quot;LWM2M Applib: cleanupDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M clean up device test step</div></div><div class=CToolTip id="tt69"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createDevice := &quot;LWM2M Applib: createDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create device test step</div></div><div class=CToolTip id="tt70"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObject := &quot;LWM2M Applib: createObject&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object test step</div></div><div class=CToolTip id="tt71"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_createObjectInstance := &quot;LWM2M Applib: createObjectInstance&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M create object instance test step</div></div><div class=CToolTip id="tt72"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleExecuteRequest := &quot;LWM2M Applib: handleExecuteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle EXECUTE request test step</div></div><div class=CToolTip id="tt73"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleReadRequest := &quot;LWM2M Applib: handleReadRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle READ request test step</div></div><div class=CToolTip id="tt74"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_handleWriteRequest := &quot;LWM2M Applib: handleWriteRequest&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M handle WRITE request test step</div></div><div class=CToolTip id="tt75"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := &quot;LWM2M Applib: loadTemplate_byIntIdx&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M loadTemplate (param: integer index) test step</div></div><div class=CToolTip id="tt76"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_loadTemplate_byStringId := &quot;LWM2M Applib: loadTemplate_byStringId&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M load template (param: string id of the template) test step</div></div><div class=CToolTip id="tt77"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_logDevice := &quot;LWM2M Applib: logDevice&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M log device test step</div></div><div class=CToolTip id="tt78"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_send := &quot;LWM2M Applib: send&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send test step</div></div><div class=CToolTip id="tt79"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_sendNotificationForObservedResources := &quot;LWM2M Applib: sendNotificationForObservedResources&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M send notification for observed resources test step</div></div><div class=CToolTip id="tt80"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_atomic := &quot;LWM2M Applib: setBlock1Handling_atomic&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling atomic test step</div></div><div class=CToolTip id="tt81"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBlock1Handling_stateless := &quot;LWM2M Applib: setBlock1Handling_stateless&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set block1 handling stateless test step</div></div><div class=CToolTip id="tt82"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setBootstrapState := &quot;LWM2M Applib: setBootstrapState&quot;</td></tr></table></blockquote>Charstring constant for the LWM2M set bootstrap state test step</div></div><div class=CToolTip id="tt83"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_LwM2M_stepName_setContentFormats := &quot;LWM2M Applib: setContentFormats&quot;</td></tr></table></blockquote>Charstring constant for setting the preferred content format</div></div><div class=CToolTip id="tt84"><div class=CConstant>Integer constant for the LWM2M set firmware update state test step</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/General2.html b/apidoc/html/index/General2.html
index 364e567..0b55ac3 100644
--- a/apidoc/html/index/General2.html
+++ b/apidoc/html/index/General2.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,9 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="General.html#C">C</a> &middot; D &middot; <a href="General.html#E">E</a> &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="General3.html#L">L</a> &middot; M &middot; N &middot; <a href="General3.html#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="General3.html#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" id=link99 onMouseOver="ShowTip(event, 'tt99', 'link99')" onMouseOut="HideTip('tt99')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" id=link100 onMouseOver="ShowTip(event, 'tt100', 'link100')" onMouseOut="HideTip('tt100')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" id=link101 onMouseOver="ShowTip(event, 'tt101', 'link101')" onMouseOut="HideTip('tt101')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" id=link102 onMouseOver="ShowTip(event, 'tt102', 'link102')" onMouseOut="HideTip('tt102')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" id=link103 onMouseOver="ShowTip(event, 'tt103', 'link103')" onMouseOut="HideTip('tt103')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" id=link104 onMouseOver="ShowTip(event, 'tt104', 'link104')" onMouseOut="HideTip('tt104')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" id=link105 onMouseOver="ShowTip(event, 'tt105', 'link105')" onMouseOut="HideTip('tt105')" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" id=link106 onMouseOver="ShowTip(event, 'tt106', 'link106')" onMouseOut="HideTip('tt106')" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" id=link107 onMouseOver="ShowTip(event, 'tt107', 'link107')" onMouseOut="HideTip('tt107')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link108 onMouseOver="ShowTip(event, 'tt108', 'link108')" onMouseOut="HideTip('tt108')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" id=link109 onMouseOver="ShowTip(event, 'tt109', 'link109')" onMouseOut="HideTip('tt109')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" id=link110 onMouseOver="ShowTip(event, 'tt110', 'link110')" onMouseOut="HideTip('tt110')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" id=link111 onMouseOver="ShowTip(event, 'tt111', 'link111')" onMouseOut="HideTip('tt111')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link112 onMouseOver="ShowTip(event, 'tt112', 'link112')" onMouseOut="HideTip('tt112')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" id=link113 onMouseOver="ShowTip(event, 'tt113', 'link113')" onMouseOut="HideTip('tt113')" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" id=link114 onMouseOver="ShowTip(event, 'tt114', 'link114')" onMouseOut="HideTip('tt114')" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link115 onMouseOver="ShowTip(event, 'tt115', 'link115')" onMouseOut="HideTip('tt115')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" id=link116 onMouseOver="ShowTip(event, 'tt116', 'link116')" onMouseOut="HideTip('tt116')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" id=link117 onMouseOver="ShowTip(event, 'tt117', 'link117')" onMouseOut="HideTip('tt117')" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" id=link118 onMouseOver="ShowTip(event, 'tt118', 'link118')" onMouseOut="HideTip('tt118')" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" id=link119 onMouseOver="ShowTip(event, 'tt119', 'link119')" onMouseOut="HideTip('tt119')" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" id=link120 onMouseOver="ShowTip(event, 'tt120', 'link120')" onMouseOut="HideTip('tt120')" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" id=link121 onMouseOver="ShowTip(event, 'tt121', 'link121')" onMouseOut="HideTip('tt121')" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" id=link122 onMouseOver="ShowTip(event, 'tt122', 'link122')" onMouseOut="HideTip('tt122')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" id=link123 onMouseOver="ShowTip(event, 'tt123', 'link123')" onMouseOut="HideTip('tt123')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" id=link124 onMouseOver="ShowTip(event, 'tt124', 'link124')" onMouseOut="HideTip('tt124')" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" id=link125 onMouseOver="ShowTip(event, 'tt125', 'link125')" onMouseOut="HideTip('tt125')" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" id=link126 onMouseOver="ShowTip(event, 'tt126', 'link126')" onMouseOut="HideTip('tt126')" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" id=link127 onMouseOver="ShowTip(event, 'tt127', 'link127')" onMouseOut="HideTip('tt127')" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" id=link128 onMouseOver="ShowTip(event, 'tt128', 'link128')" onMouseOut="HideTip('tt128')" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" id=link129 onMouseOver="ShowTip(event, 'tt129', 'link129')" onMouseOut="HideTip('tt129')" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" id=link130 onMouseOver="ShowTip(event, 'tt130', 'link130')" onMouseOut="HideTip('tt130')" class=ISymbol>f_EPTF_LwM2M_setCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" id=link131 onMouseOver="ShowTip(event, 'tt131', 'link131')" onMouseOut="HideTip('tt131')" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" id=link132 onMouseOver="ShowTip(event, 'tt132', 'link132')" onMouseOut="HideTip('tt132')" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" id=link133 onMouseOver="ShowTip(event, 'tt133', 'link133')" onMouseOut="HideTip('tt133')" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" id=link134 onMouseOver="ShowTip(event, 'tt134', 'link134')" onMouseOut="HideTip('tt134')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link135 onMouseOver="ShowTip(event, 'tt135', 'link135')" onMouseOut="HideTip('tt135')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" id=link136 onMouseOver="ShowTip(event, 'tt136', 'link136')" onMouseOut="HideTip('tt136')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" id=link137 onMouseOver="ShowTip(event, 'tt137', 'link137')" onMouseOut="HideTip('tt137')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" id=link138 onMouseOver="ShowTip(event, 'tt138', 'link138')" onMouseOut="HideTip('tt138')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" id=link139 onMouseOver="ShowTip(event, 'tt139', 'link139')" onMouseOut="HideTip('tt139')" class=ISymbol>f_LwM2M_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" id=link140 onMouseOver="ShowTip(event, 'tt140', 'link140')" onMouseOut="HideTip('tt140')" class=ISymbol>f_LwM2M_createResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" id=link141 onMouseOver="ShowTip(event, 'tt141', 'link141')" onMouseOut="HideTip('tt141')" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" id=link142 onMouseOver="ShowTip(event, 'tt142', 'link142')" onMouseOut="HideTip('tt142')" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" id=link143 onMouseOver="ShowTip(event, 'tt143', 'link143')" onMouseOut="HideTip('tt143')" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" id=link144 onMouseOver="ShowTip(event, 'tt144', 'link144')" onMouseOut="HideTip('tt144')" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" id=link145 onMouseOver="ShowTip(event, 'tt145', 'link145')" onMouseOut="HideTip('tt145')" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" id=link146 onMouseOver="ShowTip(event, 'tt146', 'link146')" onMouseOut="HideTip('tt146')" class=ISymbol>f_LwM2M_eCtxBind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" id=link147 onMouseOver="ShowTip(event, 'tt147', 'link147')" onMouseOut="HideTip('tt147')" class=ISymbol>f_LwM2M_eCtxReset</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" id=link148 onMouseOver="ShowTip(event, 'tt148', 'link148')" onMouseOut="HideTip('tt148')" class=ISymbol>f_LwM2M_eCtxUnbind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" id=link149 onMouseOver="ShowTip(event, 'tt149', 'link149')" onMouseOut="HideTip('tt149')" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" id=link150 onMouseOver="ShowTip(event, 'tt150', 'link150')" onMouseOut="HideTip('tt150')" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" id=link151 onMouseOver="ShowTip(event, 'tt151', 'link151')" onMouseOut="HideTip('tt151')" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" id=link152 onMouseOver="ShowTip(event, 'tt152', 'link152')" onMouseOut="HideTip('tt152')" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" id=link153 onMouseOver="ShowTip(event, 'tt153', 'link153')" onMouseOut="HideTip('tt153')" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" id=link154 onMouseOver="ShowTip(event, 'tt154', 'link154')" onMouseOut="HideTip('tt154')" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" id=link155 onMouseOver="ShowTip(event, 'tt155', 'link155')" onMouseOut="HideTip('tt155')" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" id=link156 onMouseOver="ShowTip(event, 'tt156', 'link156')" onMouseOut="HideTip('tt156')" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" id=link157 onMouseOver="ShowTip(event, 'tt157', 'link157')" onMouseOut="HideTip('tt157')" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" id=link158 onMouseOver="ShowTip(event, 'tt158', 'link158')" onMouseOut="HideTip('tt158')" class=ISymbol>f_LwM2M_ObjectDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" id=link159 onMouseOver="ShowTip(event, 'tt159', 'link159')" onMouseOut="HideTip('tt159')" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" id=link160 onMouseOver="ShowTip(event, 'tt160', 'link160')" onMouseOut="HideTip('tt160')" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" id=link161 onMouseOver="ShowTip(event, 'tt161', 'link161')" onMouseOut="HideTip('tt161')" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" id=link162 onMouseOver="ShowTip(event, 'tt162', 'link162')" onMouseOut="HideTip('tt162')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link163 onMouseOver="ShowTip(event, 'tt163', 'link163')" onMouseOut="HideTip('tt163')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link164 onMouseOver="ShowTip(event, 'tt164', 'link164')" onMouseOut="HideTip('tt164')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" id=link165 onMouseOver="ShowTip(event, 'tt165', 'link165')" onMouseOut="HideTip('tt165')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" id=link166 onMouseOver="ShowTip(event, 'tt166', 'link166')" onMouseOut="HideTip('tt166')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" id=link167 onMouseOver="ShowTip(event, 'tt167', 'link167')" onMouseOut="HideTip('tt167')" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" id=link168 onMouseOver="ShowTip(event, 'tt168', 'link168')" onMouseOut="HideTip('tt168')" class=ISymbol>f_LwM2M_resourceHash_forIds</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" id=link169 onMouseOver="ShowTip(event, 'tt169', 'link169')" onMouseOut="HideTip('tt169')" class=ISymbol>f_LwM2M_resourceHash_forResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" id=link170 onMouseOver="ShowTip(event, 'tt170', 'link170')" onMouseOut="HideTip('tt170')" class=ISymbol>f_LwM2M_step_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" id=link171 onMouseOver="ShowTip(event, 'tt171', 'link171')" onMouseOut="HideTip('tt171')" class=ISymbol>f_LwM2M_step_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" id=link172 onMouseOver="ShowTip(event, 'tt172', 'link172')" onMouseOut="HideTip('tt172')" class=ISymbol>f_LwM2M_step_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" id=link173 onMouseOver="ShowTip(event, 'tt173', 'link173')" onMouseOut="HideTip('tt173')" class=ISymbol>f_LwM2M_step_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" id=link174 onMouseOver="ShowTip(event, 'tt174', 'link174')" onMouseOut="HideTip('tt174')" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" id=link175 onMouseOver="ShowTip(event, 'tt175', 'link175')" onMouseOut="HideTip('tt175')" class=ISymbol>f_LwM2M_step_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" id=link176 onMouseOver="ShowTip(event, 'tt176', 'link176')" onMouseOut="HideTip('tt176')" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" id=link177 onMouseOver="ShowTip(event, 'tt177', 'link177')" onMouseOut="HideTip('tt177')" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" id=link178 onMouseOver="ShowTip(event, 'tt178', 'link178')" onMouseOut="HideTip('tt178')" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" id=link179 onMouseOver="ShowTip(event, 'tt179', 'link179')" onMouseOut="HideTip('tt179')" class=ISymbol>f_LwM2M_step_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" id=link180 onMouseOver="ShowTip(event, 'tt180', 'link180')" onMouseOut="HideTip('tt180')" class=ISymbol>f_LwM2M_step_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" id=link181 onMouseOver="ShowTip(event, 'tt181', 'link181')" onMouseOut="HideTip('tt181')" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" id=link182 onMouseOver="ShowTip(event, 'tt182', 'link182')" onMouseOut="HideTip('tt182')" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" id=link183 onMouseOver="ShowTip(event, 'tt183', 'link183')" onMouseOut="HideTip('tt183')" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" id=link184 onMouseOver="ShowTip(event, 'tt184', 'link184')" onMouseOut="HideTip('tt184')" class=ISymbol>f_LwM2M_step_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" id=link185 onMouseOver="ShowTip(event, 'tt185', 'link185')" onMouseOut="HideTip('tt185')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" id=link186 onMouseOver="ShowTip(event, 'tt186', 'link186')" onMouseOut="HideTip('tt186')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" id=link187 onMouseOver="ShowTip(event, 'tt187', 'link187')" onMouseOut="HideTip('tt187')" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" id=link188 onMouseOver="ShowTip(event, 'tt188', 'link188')" onMouseOut="HideTip('tt188')" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link189 onMouseOver="ShowTip(event, 'tt189', 'link189')" onMouseOut="HideTip('tt189')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link190 onMouseOver="ShowTip(event, 'tt190', 'link190')" onMouseOut="HideTip('tt190')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" id=link191 onMouseOver="ShowTip(event, 'tt191', 'link191')" onMouseOut="HideTip('tt191')" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="General.html#C">C</a> &middot; D &middot; <a href="#E">E</a> &middot; <a href="General3.html#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="General4.html#L">L</a> &middot; M &middot; N &middot; <a href="General4.html#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="General4.html#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" id=link85 onMouseOver="ShowTip(event, 'tt85', 'link85')" onMouseOut="HideTip('tt85')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" id=link86 onMouseOver="ShowTip(event, 'tt86', 'link86')" onMouseOut="HideTip('tt86')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" id=link87 onMouseOver="ShowTip(event, 'tt87', 'link87')" onMouseOut="HideTip('tt87')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" id=link88 onMouseOver="ShowTip(event, 'tt88', 'link88')" onMouseOut="HideTip('tt88')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" id=link89 onMouseOver="ShowTip(event, 'tt89', 'link89')" onMouseOut="HideTip('tt89')" class=ISymbol>EPTF_LwM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" id=link90 onMouseOver="ShowTip(event, 'tt90', 'link90')" onMouseOut="HideTip('tt90')" class=ISymbol>EPTF_LwM2M_LGen_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" id=link91 onMouseOver="ShowTip(event, 'tt91', 'link91')" onMouseOut="HideTip('tt91')" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" id=link92 onMouseOver="ShowTip(event, 'tt92', 'link92')" onMouseOut="HideTip('tt92')" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" id=link93 onMouseOver="ShowTip(event, 'tt93', 'link93')" onMouseOut="HideTip('tt93')" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" id=link94 onMouseOver="ShowTip(event, 'tt94', 'link94')" onMouseOut="HideTip('tt94')" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><span class=ISymbol>EPTF_LwM2M_Object_Definitions</span><div class=ISubIndex><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link95 onMouseOver="ShowTip(event, 'tt95', 'link95')" onMouseOut="HideTip('tt95')" class=IFile>EPTF_LwM2M_Object_Decoders.ttcn</a><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" id=link96 onMouseOver="ShowTip(event, 'tt95', 'link96')" onMouseOut="HideTip('tt95')" class=IFile>EPTF_LwM2M_Object_Definitions.ttcn</a></div></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" id=link97 onMouseOver="ShowTip(event, 'tt96', 'link97')" onMouseOut="HideTip('tt96')" class=ISymbol>EPTF_LwM2M_Object_Functions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" id=link98 onMouseOver="ShowTip(event, 'tt97', 'link98')" onMouseOut="HideTip('tt97')" class=ISymbol>EPTF_LwM2M_PDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" id=link99 onMouseOver="ShowTip(event, 'tt98', 'link99')" onMouseOut="HideTip('tt98')" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" id=link100 onMouseOver="ShowTip(event, 'tt99', 'link100')" onMouseOut="HideTip('tt99')" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" id=link101 onMouseOver="ShowTip(event, 'tt100', 'link101')" onMouseOut="HideTip('tt100')" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt99"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_CoapApplibTransport_cleanup() runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt100"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_eventIndication(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_EventDescriptor&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be registered into the COAP applib used as transport layer to receive EPTF_COAP_EventDescriptor EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_eventIndication</b> with type fcb_EPTF_COAP_eventIndication where this function can be registered in. </div></div><div class=CToolTip id="tt101"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>The main initialization function of the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt102"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_messageReceived(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_duplicate,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_autoHandled</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be regsitered into the COAP applib used as transport layer to receive EPTF_COAP_PDU EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_msgReceived</b> with type fcb_EPTF_COAP_messageReceived where this function can be registered in. </div></div><div class=CToolTip id="tt103"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_path</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>This function translates an ObjectPath to its charstring representation</div></div><div class=CToolTip id="tt104"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Function to send out a EPTF_LwM2M_PDU message using the local transport. </div></div><div class=CToolTip id="tt105"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt106"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt107"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt108"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt109"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt110"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt111"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt112"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt113"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt114"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt115"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt116"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt117"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt118"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt119"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt120"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt121"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt122"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt123"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt124"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt125"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt126"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt127"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt128"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt129"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt130"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt131"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt132"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt133"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt134"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt135"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt136"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt137"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt138"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt139"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt140"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt141"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt142"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt143"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt144"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt145"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt146"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt147"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt148"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt149"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt150"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt151"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt152"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt153"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt154"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt155"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt156"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt157"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt158"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt159"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt160"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_observed</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt161"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt162"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt163"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt164"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt165"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt166"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt167"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt168"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt169"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt170"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt171"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt172"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt173"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt174"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt175"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt176"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt177"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt178"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt179"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt180"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt181"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt182"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt183"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt184"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt185"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt186"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt187"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt188"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><div class=CToolTip id="tt189"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt190"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt191"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for sending a EPTF_LwM2M_PDU LwM2M message</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt85"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>LWM2M local transport component realized with EPTF_COAP_LGen_CT</div></div><div class=CToolTip id="tt86"><div class=CFile>This module contains the definitions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt87"><div class=CFile>This module contains the functions for the LWM2M transport layer that uses the COAP applib</div></div><div class=CToolTip id="tt88"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_CoapApplibTransport_Statistics</td></tr></table></blockquote>Storing counters for transport related statistics</div></div><div class=CToolTip id="tt89"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt90"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt91"><div class=CFile>This module contains the definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt92"><div class=CFile>This module contains the functions of the LWM2M load generator component</div></div><div class=CToolTip id="tt93"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote>Storing counters for load generator related statistics</div></div><div class=CToolTip id="tt94"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt95"><div class=CFile>This module contains the smart object decoder functions</div></div><div class=CToolTip id="tt96"><div class=CFile>This module contains the functions of the smart object definitions for the LWM2M load generator component</div></div><div class=CToolTip id="tt97"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt98"><div class=CFile>This module contains the generic transport definitions of the LwM2M load generator</div></div><div class=CToolTip id="tt99"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt100"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/General3.html b/apidoc/html/index/General3.html
index ede0835..ca1808d 100644
--- a/apidoc/html/index/General3.html
+++ b/apidoc/html/index/General3.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,17 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="General.html#C">C</a> &middot; D &middot; <a href="General.html#E">E</a> &middot; <a href="General2.html#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; <a href="#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" id=link192 onMouseOver="ShowTip(event, 'tt192', 'link192')" onMouseOut="HideTip('tt192')" class=ISymbol>LightweightM2M_Types</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" id=link193 onMouseOver="ShowTip(event, 'tt193', 'link193')" onMouseOut="HideTip('tt193')" class=ISymbol>LwM2M_Block1_Handling</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" id=link194 onMouseOver="ShowTip(event, 'tt194', 'link194')" onMouseOut="HideTip('tt194')" class=ISymbol>LwM2M_DataSamples</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" id=link195 onMouseOver="ShowTip(event, 'tt195', 'link195')" onMouseOut="HideTip('tt195')" class=ISymbol>LwM2M_DataSamples_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" id=link196 onMouseOver="ShowTip(event, 'tt196', 'link196')" onMouseOut="HideTip('tt196')" class=ISymbol>LwM2M_DataSamples_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" id=link197 onMouseOver="ShowTip(event, 'tt197', 'link197')" onMouseOut="HideTip('tt197')" class=ISymbol>LwM2M_Device</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" id=link198 onMouseOver="ShowTip(event, 'tt198', 'link198')" onMouseOut="HideTip('tt198')" class=ISymbol>LwM2M_Device_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" id=link199 onMouseOver="ShowTip(event, 'tt199', 'link199')" onMouseOut="HideTip('tt199')" class=ISymbol>LwM2M_Device_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" id=link200 onMouseOver="ShowTip(event, 'tt200', 'link200')" onMouseOut="HideTip('tt200')" class=ISymbol>LwM2M_Device_State</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" id=link201 onMouseOver="ShowTip(event, 'tt201', 'link201')" onMouseOut="HideTip('tt201')" class=ISymbol>LwM2M_EntityCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" id=link202 onMouseOver="ShowTip(event, 'tt202', 'link202')" onMouseOut="HideTip('tt202')" class=ISymbol>LwM2M_EntityCtx_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" id=link203 onMouseOver="ShowTip(event, 'tt203', 'link203')" onMouseOut="HideTip('tt203')" class=ISymbol>LwM2M_EntityCtx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" id=link204 onMouseOver="ShowTip(event, 'tt204', 'link204')" onMouseOut="HideTip('tt204')" class=ISymbol>LWM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" id=link205 onMouseOver="ShowTip(event, 'tt205', 'link205')" onMouseOut="HideTip('tt205')" class=ISymbol>LwM2M_InstanceTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" id=link206 onMouseOver="ShowTip(event, 'tt206', 'link206')" onMouseOut="HideTip('tt206')" class=ISymbol>LwM2M_Object</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" id=link207 onMouseOver="ShowTip(event, 'tt207', 'link207')" onMouseOut="HideTip('tt207')" class=ISymbol>LwM2M_Object_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" id=link208 onMouseOver="ShowTip(event, 'tt208', 'link208')" onMouseOut="HideTip('tt208')" class=ISymbol>LwM2M_ObjectDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" id=link209 onMouseOver="ShowTip(event, 'tt209', 'link209')" onMouseOut="HideTip('tt209')" class=ISymbol>LwM2M_ObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" id=link210 onMouseOver="ShowTip(event, 'tt210', 'link210')" onMouseOut="HideTip('tt210')" class=ISymbol>LwM2M_ObjectInstance_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" id=link211 onMouseOver="ShowTip(event, 'tt211', 'link211')" onMouseOut="HideTip('tt211')" class=ISymbol>LwM2M_ObjectSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" id=link212 onMouseOver="ShowTip(event, 'tt212', 'link212')" onMouseOut="HideTip('tt212')" class=ISymbol>LwM2M_ObjectSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" id=link213 onMouseOver="ShowTip(event, 'tt213', 'link213')" onMouseOut="HideTip('tt213')" class=ISymbol>LwM2M_ObjectSpecificationDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" id=link214 onMouseOver="ShowTip(event, 'tt214', 'link214')" onMouseOut="HideTip('tt214')" class=ISymbol>LwM2M_OperationTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" id=link215 onMouseOver="ShowTip(event, 'tt215', 'link215')" onMouseOut="HideTip('tt215')" class=ISymbol>LwM2M_Resource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" id=link216 onMouseOver="ShowTip(event, 'tt216', 'link216')" onMouseOut="HideTip('tt216')" class=ISymbol>LwM2M_Resource_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" id=link217 onMouseOver="ShowTip(event, 'tt217', 'link217')" onMouseOut="HideTip('tt217')" class=ISymbol>LwM2M_ResourceIdx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" id=link218 onMouseOver="ShowTip(event, 'tt218', 'link218')" onMouseOut="HideTip('tt218')" class=ISymbol>LwM2M_ResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" id=link219 onMouseOver="ShowTip(event, 'tt219', 'link219')" onMouseOut="HideTip('tt219')" class=ISymbol>LwM2M_ResourceSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" id=link220 onMouseOver="ShowTip(event, 'tt220', 'link220')" onMouseOut="HideTip('tt220')" class=ISymbol>LwM2M_ResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" id=link221 onMouseOver="ShowTip(event, 'tt221', 'link221')" onMouseOut="HideTip('tt221')" class=ISymbol>LwM2M_ResourceValue_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" id=link222 onMouseOver="ShowTip(event, 'tt222', 'link222')" onMouseOut="HideTip('tt222')" class=ISymbol>LwM2M_StepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" id=link223 onMouseOver="ShowTip(event, 'tt223', 'link223')" onMouseOut="HideTip('tt223')" class=ISymbol>LwM2M_Template</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" id=link224 onMouseOver="ShowTip(event, 'tt224', 'link224')" onMouseOut="HideTip('tt224')" class=ISymbol>LwM2M_Template_DB</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" id=link225 onMouseOver="ShowTip(event, 'tt225', 'link225')" onMouseOut="HideTip('tt225')" class=ISymbol>LwM2M_Template_List</a></td></tr><tr><td class=IHeading><a name="O"></a>O</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath" id=link226 onMouseOver="ShowTip(event, 'tt226', 'link226')" onMouseOut="HideTip('tt226')" class=ISymbol>ObjectPath</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath_List" id=link227 onMouseOver="ShowTip(event, 'tt227', 'link227')" onMouseOut="HideTip('tt227')" class=ISymbol>ObjectPath_List</a></td></tr><tr><td class=IHeading><a name="T"></a>T</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" id=link228 onMouseOver="ShowTip(event, 'tt228', 'link228')" onMouseOut="HideTip('tt228')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" id=link229 onMouseOver="ShowTip(event, 'tt229', 'link229')" onMouseOut="HideTip('tt229')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" id=link230 onMouseOver="ShowTip(event, 'tt230', 'link230')" onMouseOut="HideTip('tt230')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" id=link231 onMouseOver="ShowTip(event, 'tt231', 'link231')" onMouseOut="HideTip('tt231')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" id=link232 onMouseOver="ShowTip(event, 'tt232', 'link232')" onMouseOut="HideTip('tt232')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" id=link233 onMouseOver="ShowTip(event, 'tt233', 'link233')" onMouseOut="HideTip('tt233')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" id=link234 onMouseOver="ShowTip(event, 'tt234', 'link234')" onMouseOut="HideTip('tt234')" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" id=link235 onMouseOver="ShowTip(event, 'tt235', 'link235')" onMouseOut="HideTip('tt235')" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="General.html#C">C</a> &middot; D &middot; <a href="General2.html#E">E</a> &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="General4.html#L">L</a> &middot; M &middot; N &middot; <a href="General4.html#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="General4.html#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_canEncode" id=link102 onMouseOver="ShowTip(event, 'tt101', 'link102')" onMouseOut="HideTip('tt101')" class=ISymbol>f_EPTF_LwM2M_canEncode</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" id=link103 onMouseOver="ShowTip(event, 'tt102', 'link103')" onMouseOut="HideTip('tt102')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" id=link104 onMouseOver="ShowTip(event, 'tt103', 'link104')" onMouseOut="HideTip('tt103')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" id=link105 onMouseOver="ShowTip(event, 'tt104', 'link105')" onMouseOut="HideTip('tt104')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" id=link106 onMouseOver="ShowTip(event, 'tt105', 'link106')" onMouseOut="HideTip('tt105')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" id=link107 onMouseOver="ShowTip(event, 'tt106', 'link107')" onMouseOut="HideTip('tt106')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" id=link108 onMouseOver="ShowTip(event, 'tt107', 'link108')" onMouseOut="HideTip('tt107')" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" id=link109 onMouseOver="ShowTip(event, 'tt108', 'link109')" onMouseOut="HideTip('tt108')" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" id=link110 onMouseOver="ShowTip(event, 'tt109', 'link110')" onMouseOut="HideTip('tt109')" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" id=link111 onMouseOver="ShowTip(event, 'tt110', 'link111')" onMouseOut="HideTip('tt110')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" id=link112 onMouseOver="ShowTip(event, 'tt111', 'link112')" onMouseOut="HideTip('tt111')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" id=link113 onMouseOver="ShowTip(event, 'tt112', 'link113')" onMouseOut="HideTip('tt112')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" id=link114 onMouseOver="ShowTip(event, 'tt113', 'link114')" onMouseOut="HideTip('tt113')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" id=link115 onMouseOver="ShowTip(event, 'tt114', 'link115')" onMouseOut="HideTip('tt114')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" id=link116 onMouseOver="ShowTip(event, 'tt115', 'link116')" onMouseOut="HideTip('tt115')" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" id=link117 onMouseOver="ShowTip(event, 'tt116', 'link117')" onMouseOut="HideTip('tt116')" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" id=link118 onMouseOver="ShowTip(event, 'tt117', 'link118')" onMouseOut="HideTip('tt117')" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" id=link119 onMouseOver="ShowTip(event, 'tt118', 'link119')" onMouseOut="HideTip('tt118')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" id=link120 onMouseOver="ShowTip(event, 'tt119', 'link120')" onMouseOut="HideTip('tt119')" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getEncodingContentFormat" id=link121 onMouseOver="ShowTip(event, 'tt120', 'link121')" onMouseOut="HideTip('tt120')" class=ISymbol>f_EPTF_LwM2M_getEncodingContentFormat</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" id=link122 onMouseOver="ShowTip(event, 'tt121', 'link122')" onMouseOut="HideTip('tt121')" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" id=link123 onMouseOver="ShowTip(event, 'tt122', 'link123')" onMouseOut="HideTip('tt122')" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" id=link124 onMouseOver="ShowTip(event, 'tt123', 'link124')" onMouseOut="HideTip('tt123')" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" id=link125 onMouseOver="ShowTip(event, 'tt124', 'link125')" onMouseOut="HideTip('tt124')" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" id=link126 onMouseOver="ShowTip(event, 'tt125', 'link126')" onMouseOut="HideTip('tt125')" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" id=link127 onMouseOver="ShowTip(event, 'tt126', 'link127')" onMouseOut="HideTip('tt126')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" id=link128 onMouseOver="ShowTip(event, 'tt127', 'link128')" onMouseOut="HideTip('tt127')" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" id=link129 onMouseOver="ShowTip(event, 'tt128', 'link129')" onMouseOut="HideTip('tt128')" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" id=link130 onMouseOver="ShowTip(event, 'tt129', 'link130')" onMouseOut="HideTip('tt129')" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" id=link131 onMouseOver="ShowTip(event, 'tt130', 'link131')" onMouseOut="HideTip('tt130')" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" id=link132 onMouseOver="ShowTip(event, 'tt131', 'link132')" onMouseOut="HideTip('tt131')" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" id=link133 onMouseOver="ShowTip(event, 'tt132', 'link133')" onMouseOut="HideTip('tt132')" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" id=link134 onMouseOver="ShowTip(event, 'tt133', 'link134')" onMouseOut="HideTip('tt133')" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" id=link135 onMouseOver="ShowTip(event, 'tt134', 'link135')" onMouseOut="HideTip('tt134')" class=ISymbol>f_EPTF_LwM2M_setCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" id=link136 onMouseOver="ShowTip(event, 'tt135', 'link136')" onMouseOut="HideTip('tt135')" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" id=link137 onMouseOver="ShowTip(event, 'tt136', 'link137')" onMouseOut="HideTip('tt136')" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" id=link138 onMouseOver="ShowTip(event, 'tt137', 'link138')" onMouseOut="HideTip('tt137')" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" id=link139 onMouseOver="ShowTip(event, 'tt138', 'link139')" onMouseOut="HideTip('tt138')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" id=link140 onMouseOver="ShowTip(event, 'tt139', 'link140')" onMouseOut="HideTip('tt139')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" id=link141 onMouseOver="ShowTip(event, 'tt140', 'link141')" onMouseOut="HideTip('tt140')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" id=link142 onMouseOver="ShowTip(event, 'tt141', 'link142')" onMouseOut="HideTip('tt141')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" id=link143 onMouseOver="ShowTip(event, 'tt142', 'link143')" onMouseOut="HideTip('tt142')" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_updateMessageStatistics" id=link144 onMouseOver="ShowTip(event, 'tt143', 'link144')" onMouseOut="HideTip('tt143')" class=ISymbol>f_EPTF_LwM2M_updateMessageStatistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" id=link145 onMouseOver="ShowTip(event, 'tt144', 'link145')" onMouseOut="HideTip('tt144')" class=ISymbol>f_LwM2M_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" id=link146 onMouseOver="ShowTip(event, 'tt145', 'link146')" onMouseOut="HideTip('tt145')" class=ISymbol>f_LwM2M_createResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" id=link147 onMouseOver="ShowTip(event, 'tt146', 'link147')" onMouseOut="HideTip('tt146')" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" id=link148 onMouseOver="ShowTip(event, 'tt147', 'link148')" onMouseOut="HideTip('tt147')" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" id=link149 onMouseOver="ShowTip(event, 'tt148', 'link149')" onMouseOut="HideTip('tt148')" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" id=link150 onMouseOver="ShowTip(event, 'tt149', 'link150')" onMouseOut="HideTip('tt149')" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" id=link151 onMouseOver="ShowTip(event, 'tt150', 'link151')" onMouseOut="HideTip('tt150')" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" id=link152 onMouseOver="ShowTip(event, 'tt151', 'link152')" onMouseOut="HideTip('tt151')" class=ISymbol>f_LwM2M_eCtxBind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" id=link153 onMouseOver="ShowTip(event, 'tt152', 'link153')" onMouseOut="HideTip('tt152')" class=ISymbol>f_LwM2M_eCtxReset</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" id=link154 onMouseOver="ShowTip(event, 'tt153', 'link154')" onMouseOut="HideTip('tt153')" class=ISymbol>f_LwM2M_eCtxUnbind</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" id=link155 onMouseOver="ShowTip(event, 'tt154', 'link155')" onMouseOut="HideTip('tt154')" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" id=link156 onMouseOver="ShowTip(event, 'tt155', 'link156')" onMouseOut="HideTip('tt155')" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" id=link157 onMouseOver="ShowTip(event, 'tt156', 'link157')" onMouseOut="HideTip('tt156')" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" id=link158 onMouseOver="ShowTip(event, 'tt157', 'link158')" onMouseOut="HideTip('tt157')" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" id=link159 onMouseOver="ShowTip(event, 'tt158', 'link159')" onMouseOut="HideTip('tt158')" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" id=link160 onMouseOver="ShowTip(event, 'tt159', 'link160')" onMouseOut="HideTip('tt159')" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" id=link161 onMouseOver="ShowTip(event, 'tt160', 'link161')" onMouseOut="HideTip('tt160')" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" id=link162 onMouseOver="ShowTip(event, 'tt161', 'link162')" onMouseOut="HideTip('tt161')" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" id=link163 onMouseOver="ShowTip(event, 'tt162', 'link163')" onMouseOut="HideTip('tt162')" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" id=link164 onMouseOver="ShowTip(event, 'tt163', 'link164')" onMouseOut="HideTip('tt163')" class=ISymbol>f_LwM2M_ObjectDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" id=link165 onMouseOver="ShowTip(event, 'tt164', 'link165')" onMouseOut="HideTip('tt164')" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" id=link166 onMouseOver="ShowTip(event, 'tt165', 'link166')" onMouseOut="HideTip('tt165')" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" id=link167 onMouseOver="ShowTip(event, 'tt166', 'link167')" onMouseOut="HideTip('tt166')" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" id=link168 onMouseOver="ShowTip(event, 'tt167', 'link168')" onMouseOut="HideTip('tt167')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" id=link169 onMouseOver="ShowTip(event, 'tt168', 'link169')" onMouseOut="HideTip('tt168')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" id=link170 onMouseOver="ShowTip(event, 'tt169', 'link170')" onMouseOut="HideTip('tt169')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" id=link171 onMouseOver="ShowTip(event, 'tt170', 'link171')" onMouseOut="HideTip('tt170')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" id=link172 onMouseOver="ShowTip(event, 'tt171', 'link172')" onMouseOut="HideTip('tt171')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" id=link173 onMouseOver="ShowTip(event, 'tt172', 'link173')" onMouseOut="HideTip('tt172')" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_checkSpecification" id=link174 onMouseOver="ShowTip(event, 'tt173', 'link174')" onMouseOut="HideTip('tt173')" class=ISymbol>f_LwM2M_Resource_checkSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#f_LwM2M_Resource_decode" id=link175 onMouseOver="ShowTip(event, 'tt174', 'link175')" onMouseOut="HideTip('tt174')" class=ISymbol>f_LwM2M_Resource_decode</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_getSpecification" id=link176 onMouseOver="ShowTip(event, 'tt175', 'link176')" onMouseOut="HideTip('tt175')" class=ISymbol>f_LwM2M_Resource_getSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" id=link177 onMouseOver="ShowTip(event, 'tt176', 'link177')" onMouseOut="HideTip('tt176')" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" id=link178 onMouseOver="ShowTip(event, 'tt177', 'link178')" onMouseOut="HideTip('tt177')" class=ISymbol>f_LwM2M_resourceHash_forIds</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" id=link179 onMouseOver="ShowTip(event, 'tt178', 'link179')" onMouseOut="HideTip('tt178')" class=ISymbol>f_LwM2M_resourceHash_forResource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" id=link180 onMouseOver="ShowTip(event, 'tt179', 'link180')" onMouseOut="HideTip('tt179')" class=ISymbol>f_LwM2M_step_cleanupDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" id=link181 onMouseOver="ShowTip(event, 'tt180', 'link181')" onMouseOut="HideTip('tt180')" class=ISymbol>f_LwM2M_step_createDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" id=link182 onMouseOver="ShowTip(event, 'tt181', 'link182')" onMouseOut="HideTip('tt181')" class=ISymbol>f_LwM2M_step_createObject</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" id=link183 onMouseOver="ShowTip(event, 'tt182', 'link183')" onMouseOut="HideTip('tt182')" class=ISymbol>f_LwM2M_step_createObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" id=link184 onMouseOver="ShowTip(event, 'tt183', 'link184')" onMouseOut="HideTip('tt183')" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" id=link185 onMouseOver="ShowTip(event, 'tt184', 'link185')" onMouseOut="HideTip('tt184')" class=ISymbol>f_LwM2M_step_handleReadRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" id=link186 onMouseOver="ShowTip(event, 'tt185', 'link186')" onMouseOut="HideTip('tt185')" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" id=link187 onMouseOver="ShowTip(event, 'tt186', 'link187')" onMouseOut="HideTip('tt186')" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" id=link188 onMouseOver="ShowTip(event, 'tt187', 'link188')" onMouseOut="HideTip('tt187')" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" id=link189 onMouseOver="ShowTip(event, 'tt188', 'link189')" onMouseOut="HideTip('tt188')" class=ISymbol>f_LwM2M_step_logDevice</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" id=link190 onMouseOver="ShowTip(event, 'tt189', 'link190')" onMouseOut="HideTip('tt189')" class=ISymbol>f_LwM2M_step_send</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" id=link191 onMouseOver="ShowTip(event, 'tt190', 'link191')" onMouseOut="HideTip('tt190')" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" id=link192 onMouseOver="ShowTip(event, 'tt191', 'link192')" onMouseOut="HideTip('tt191')" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" id=link193 onMouseOver="ShowTip(event, 'tt192', 'link193')" onMouseOut="HideTip('tt192')" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" id=link194 onMouseOver="ShowTip(event, 'tt193', 'link194')" onMouseOut="HideTip('tt193')" class=ISymbol>f_LwM2M_step_setBootstrapState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" id=link195 onMouseOver="ShowTip(event, 'tt194', 'link195')" onMouseOut="HideTip('tt194')" class=ISymbol>f_LwM2M_step_setContentFormats</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" id=link196 onMouseOver="ShowTip(event, 'tt195', 'link196')" onMouseOut="HideTip('tt195')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" id=link197 onMouseOver="ShowTip(event, 'tt196', 'link197')" onMouseOut="HideTip('tt196')" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" id=link198 onMouseOver="ShowTip(event, 'tt197', 'link198')" onMouseOut="HideTip('tt197')" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" id=link199 onMouseOver="ShowTip(event, 'tt198', 'link199')" onMouseOut="HideTip('tt198')" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link200 onMouseOver="ShowTip(event, 'tt199', 'link200')" onMouseOut="HideTip('tt199')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link201 onMouseOver="ShowTip(event, 'tt200', 'link201')" onMouseOut="HideTip('tt200')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" id=link202 onMouseOver="ShowTip(event, 'tt201', 'link202')" onMouseOut="HideTip('tt201')" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt192"><div class=CFile>This module contains type definitions for LWM2M PDUs</div></div><div class=CToolTip id="tt193"><div class=CType>Block1 handling strategy of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt194"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt195"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt196"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt197"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt198"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt199"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt200"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt201"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt202"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt203"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt204"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt205"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt206"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt207"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt208"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt209"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt210"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt211"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt212"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt213"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt214"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt215"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt216"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt217"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt218"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt219"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt220"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt221"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt222"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt223"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt224"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt225"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><!--END_ND_TOOLTIPS-->
-
-
-<!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt226"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><div class=CToolTip id="tt227"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><!--END_ND_TOOLTIPS-->
-
-
-<!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt228"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt229"><div class=CModuleParameter>Enabled/disable the transport layer implementation</div></div><div class=CToolTip id="tt230"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt231"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt232"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt233"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt234"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt235"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt101"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_canEncode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_code,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Finds out if a list of resources can be encoded with a certain content format</div></div><div class=CToolTip id="tt102"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_CoapApplibTransport_cleanup() runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt103"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_eventIndication(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_EventDescriptor&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be registered into the COAP applib used as transport layer to receive EPTF_COAP_EventDescriptor EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_eventIndication</b> with type fcb_EPTF_COAP_eventIndication where this function can be registered in. </div></div><div class=CToolTip id="tt104"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>The main initialization function of the EPTF_LwM2M_CoapApplibTransport_CT component type</div></div><div class=CToolTip id="tt105"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_messageReceived(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_COAP_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_duplicate,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_autoHandled</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Handler function to be regsitered into the COAP applib used as transport layer to receive EPTF_COAP_PDU EPTF_COAP_LGen_CT component has a variable <b>vf_COAP_msgReceived</b> with type fcb_EPTF_COAP_messageReceived where this function can be registered in. </div></div><div class=CToolTip id="tt106"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_path</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>This function translates an ObjectPath to its charstring representation</div></div><div class=CToolTip id="tt107"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_CoapApplibTransport_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></td></tr></table></blockquote>Function to send out a EPTF_LwM2M_PDU message using the local transport. </div></div><div class=CToolTip id="tt108"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareEvents() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM events to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt109"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_declareSteps() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Declares the FSM steps to the CLL framework implemented by EPTF_LwM2M_LGen_CT</div></div><div class=CToolTip id="tt110"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Device&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_device</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt111"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt112"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_DeviceDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt113"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_locationHash(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return octetstring</td></tr></table></td></tr></table></blockquote>Hash function for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt114"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_remove(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Removes an element from the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database and frees up its reserved resources</div></div><div class=CToolTip id="tt115"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_DeviceDB_setLocationKey(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Location&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_location,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets the hashmap key for lookups used by the <b>v_LwM2M_DeviceDB</b> LwM2M_Device_DB database</div></div><div class=CToolTip id="tt116"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eventIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Wrapper for CLL&rsquo;s f_EPTF_LGenBase_postEvent to handle multi level event (generic, entity, FSM) reporting</div></div><div class=CToolTip id="tt117"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_dispatchEventsForPDU(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_fsmCtx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_reportedArgs</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter</div></div><div class=CToolTip id="tt118"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt119"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_EntityCtxDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB database</div></div><div class=CToolTip id="tt120"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getEncodingContentFormat(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Format_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_preferred,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>Integer_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_accepted,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource_List&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resources</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Negotiates an encoding format based on this side&rsquo;s preferred, the other side&rsquo;s accepted and the list of resources to be encoded</div></div><div class=CToolTip id="tt121"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_getIntValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_IntegerList&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_intList,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_number,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retreives an element of an EPTF_IntegerList if it exists</div></div><div class=CToolTip id="tt122"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_hasDevice(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_ctx</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Checks if the LwM2M_EntityCtx instance of the actual entity has an associated device or not</div></div><div class=CToolTip id="tt123"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_name</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The main initialization function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt124"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_LGen_initLogging() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializing CLL&rsquo;s logging feature on the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt125"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_isBootstrap(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_isBootstrap</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Sets p_isBootstrap true if the device is in bootstrapping state.</div></div><div class=CToolTip id="tt126"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_Event events to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt127"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_LGen_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The transport layer implementation EPTF_LwM2M_Transport_Provider_CT can report received EPTF_LwM2M_PDU message to the load generator layer EPTF_LwM2M_Transport_User_CT extended by EPTF_LwM2M_LGen_CT using this function.</div></div><div class=CToolTip id="tt128"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_DEBUG(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the DEBUG log level</div></div><div class=CToolTip id="tt129"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_ERROR(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the ERROR log level</div></div><div class=CToolTip id="tt130"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_VERBOSE(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the VERBOSE log level</div></div><div class=CToolTip id="tt131"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_Logging_WARNING(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in @lazy&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Logging functions for the WARNING log level</div></div><div class=CToolTip id="tt132"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_EPTF_LwM2M_PduToEventIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_pdu</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Maps a LWM2M_PDU to an event id (integer number) that represents the PDU&rsquo;s type</div></div><div class=CToolTip id="tt133"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_sendNotificationForResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>v_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the <b>pl_ptr</b> parameter</div></div><div class=CToolTip id="tt134"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_eIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_fsmIdx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt135"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_setStepCtx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This sets the instance pointers of LwM2M_StepCtx to the related instances of a simulated device (entity) calculated from the test step args EPTF_LGenBase_TestStepArgs</div></div><div class=CToolTip id="tt136"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromApp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_StepCtx&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_ctx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the application layer (e.g. </div></div><div class=CToolTip id="tt137"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_stack_fromEnv(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>This is the main entry point for the LwM2M stack realization of the EPTF_LwM2M_LGen_CT component that handles messages received from the environment layer (e.g. </div></div><div class=CToolTip id="tt138"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Template&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_template</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Adds a new element to the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt139"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Cleans up the reserved resources of the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt140"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_get(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_idx,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LWM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Retrieves an element from the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt141"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_EPTF_LwM2M_TemplateDB_init() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>Initializes the <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database by adding the templates given in tsp_EPTF_LwM2M_LGen_templates</div></div><div class=CToolTip id="tt142"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_TemplateDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Gets the index of an LwM2M_Template element in <b>v_LwM2M_templateDB</b> LwM2M_Template_DB database</div></div><div class=CToolTip id="tt143"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_EPTF_LwM2M_updateMessageStatistics(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Message_Statistics&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_stats,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_pdu</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Updates the message statistics based on the incoming PDU</div></div><div class=CToolTip id="tt144"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_LwM2M_cleanUp() runs on EPTF_LwM2M_LGen_CT</td></tr></table></blockquote>The main clean up function for the EPTF_LwM2M_LGen_CT component type</div></div><div class=CToolTip id="tt145"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_createResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_oi,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return LwM2M_Resource</td></tr></table></td></tr></table></blockquote>Function to create an LwM2M_Resource instance based on a LwM2M_ResourceSpecification and link it into an LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt146"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_samples</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_DataSamples element to a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt147"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt148"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_get(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_idx,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_samples</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on its internal index</div></div><div class=CToolTip id="tt149"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_DataSamples_DB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_name</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes a LwM2M_DataSamples_DB database</div></div><div class=CToolTip id="tt150"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_DataSamples_DB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>charstring&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_sampleName</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Looks up a LwM2M_DataSamples element from a LwM2M_DataSamples_DB database based on the samples&rsquo; name</div></div><div class=CToolTip id="tt151"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_eCtxBind(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_eIdx</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT return EPTF_IntegerList</td></tr></table></td></tr></table></blockquote>This function is called by the CLL for each entity instance created on a particular instace of EPTF_LwM2M_LGen_CT The function will allocate and initialize an instance of LwM2M_EntityCtx in <b>v_LwM2M_EntityCtxDB</b> LwM2M_EntityCtx_DB</div></div><div class=CToolTip id="tt152"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxReset(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The resources reserved during f_LwM2M_eCtxBind are reinitalized (reset). </div></div><div class=CToolTip id="tt153"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_eCtxUnbind(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>pl_eIdx</td><td class="PAfterParameters  prettyprint "nowrap>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The reverse operation of f_LwM2M_eCtxBind. </div></div><div class=CToolTip id="tt154"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_cleanUp(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt155"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Creates a new instance of a LwM2M_Object and adds it to the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt156"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_spec_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in boolean&nbsp;</td><td class="PType  prettyprint " nowrap>p_createResources&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> true</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return integer</td></tr></table></td></tr></table></blockquote>Creates an LwM2M_ObjectInstance of a LwM2M_Object in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt157"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObject(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Object&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_obj</td><td class="PAfterParameters  prettyprint "nowrap>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt158"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectIdx(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>) return integer</td></tr></table></td></tr></table></blockquote>Retrieves the index of an instance of a LwM2M_Object from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt159"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectInstance&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInst</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_ObjectInstance from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt160"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_getObjectPaths(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>ObjectPath_List&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_paths</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Retrieves all the object paths ObjectPath_List that are stored in the LwM2M_ObjectDB</div></div><div class=CToolTip id="tt161"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves an LwM2M_Resource from a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt162"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_getResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves the LwM2M_ResourceValue of a LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt163"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_ObjectDB_init(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_id</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt164"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resource</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Updates the contents of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt165"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=6>function f_LwM2M_ObjectDB_setResourceObserved(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resourceId,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>boolean&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_observed,</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%></td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in template integer&nbsp;</td><td class="PType  prettyprint " nowrap>p_contentFormat&nbsp;</td><td class="PParameter  prettyprint " nowrap>:</td><td class="PDefaultValuePrefix  prettyprint ">&nbsp;=&nbsp;</td><td class="PDefaultValue  prettyprint " width=100%> omit</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=6>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the observation flag of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt166"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectDB_setResourceValue(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objInstId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resourceId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceValue&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_value</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Sets the LwM2M_ResourceValue of an already linked in LwM2M_Resource in a LwM2M_ObjectDB database</div></div><div class=CToolTip id="tt167"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_add(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Adds a new LwM2M_ObjectSpecification element to the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt168"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_cleanUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Cleans up the reserved resources of the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt169"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Loads known OMA related LwM2M_ObjectSpecification elements into the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt170"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap></td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_resId,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Retrieves a LwM2M_ResourceSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt171"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_init(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_id</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>)</td></tr></table></td></tr></table></blockquote>Initializes the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt172"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_ObjectSpecificationDB_lookUp(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_objId</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return integer</td></tr></table></td></tr></table></blockquote>Gets the index of a LwM2M_ObjectSpecification element in the LwM2M_ObjectSpecificationDB database</div></div><div class=CToolTip id="tt173"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_checkSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>template&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to check the specification of a LwM2M_Resource instance against a template</div></div><div class=CToolTip id="tt174"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_decode(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_contentFormat</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Decodes a resource based on a contnet format and its spceification</div></div><div class=CToolTip id="tt175"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_Resource_getSpecification(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ObjectSpecificationDB&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec_db,</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_ResourceSpecification&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_spec</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return boolean</td></tr></table></td></tr></table></blockquote>Function to look up the specification of a LwM2M_Resource instance</div></div><div class=CToolTip id="tt176"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_Resource_setNextDataSample(</td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_res,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>inout&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_DataSamples_DB&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_db</td><td class="PAfterParameters  prettyprint "nowrap>)</td></tr></table></td></tr></table></blockquote>In case the LwM2M_Resource instance is associated with a LwM2M_DataSamples it will set its value to the next from the samples</div></div><div class=CToolTip id="tt177"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "nowrap>function f_LwM2M_resourceHash_forIds(</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_objInstId,</td></tr><tr><td></td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>integer&nbsp;</td><td class="PParameter  prettyprint " nowrap>p_resId</td><td class="PAfterParameters  prettyprint "nowrap>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for LwM2M_Resource IDs</div></div><div class=CToolTip id="tt178"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_resourceHash_forResource(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>LwM2M_Resource&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>p_res</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) return charstring</td></tr></table></td></tr></table></blockquote>Function to generate a unique key for the LwM2M_Resource instance</div></div><div class=CToolTip id="tt179"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_cleanupDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to free up the LwM2M_EntityCtx for the caller entity. </div></div><div class=CToolTip id="tt180"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to dynamically allocate and initialize a simulated LwM2M_Device and associate it to the caller entity&rsquo;s LwM2M_EntityCtx. </div></div><div class=CToolTip id="tt181"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObject(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_Object instance on the caller entity&rsquo;s associated LwM2M_Device</div></div><div class=CToolTip id="tt182"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_createObjectInstance(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to create an LwM2M_ObjectInstance instance on the caller entity&rsquo;s associated LwM2M_Device the instance will also created the LwM2M_Resource instances according to the object instance&rsquo;s LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt183"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleExecuteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. </div></div><div class=CToolTip id="tt184"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleReadRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M READ request. </div></div><div class=CToolTip id="tt185"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_handleWriteRequest(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step can be called from an FSM to handle a reported LWM2M WRITE request. </div></div><div class=CToolTip id="tt186"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byIntIdx(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt187"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_loadTemplate_byStringId(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to load a LwM2M_Template from tsp_EPTF_LwM2M_LGen_templates into <b>v_LwM2M_msgToSend</b> (which can be sent using the send test step). </div></div><div class=CToolTip id="tt188"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_logDevice(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to log the contents of the LwM2M_Device associated to the caller entity&rsquo;s LwM2M_EntityCtx</div></div><div class=CToolTip id="tt189"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_send(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to send out a LWM2M message from <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt190"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_sendNotificationForObservedResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will iterate through the observed resources of the caller entity&rsquo;s LwM2M_Device and creates and sends a NOTIFICATION for each.</div></div><div class=CToolTip id="tt191"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_atomic(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to atomic</div></div><div class=CToolTip id="tt192"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBlock1Handling_stateless(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the block1 handling strategy of the device to stateless</div></div><div class=CToolTip id="tt193"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setBootstrapState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to BOOTSTRAPPING. </div></div><div class=CToolTip id="tt194"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setContentFormats(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the preferred encoding content format for a LwM2M_Device</div></div><div class=CToolTip id="tt195"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateResult(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update result resource value.</div></div><div class=CToolTip id="tt196"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setFirmwareUpdateState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>The test step will set the firmware update state resource value.</div></div><div class=CToolTip id="tt197"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_setNotRegisteredState(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to set the state of the device to NOT_REGISTERED.</div></div><div class=CToolTip id="tt198"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_LwM2M_step_writeOrCreateObject_BS(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on EPTF_LwM2M_LGen_CT</td></tr></table></td></tr></table></blockquote>Test Step to handling the bootstrap write messge.</div></div><div class=CToolTip id="tt199"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveEvent(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_Event&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_event</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_Event LWM2M event</div></div><div class=CToolTip id="tt200"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_receiveMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_message</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for reporting received EPTF_LwM2M_PDU LwM2M messages</div></div><div class=CToolTip id="tt201"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>type function fcb_EPTF_LwM2M_Transport_sendMessage(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LwM2M_PDU&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_msg</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on self</td></tr></table></td></tr></table></blockquote>Call-back function type for sending a EPTF_LwM2M_PDU LwM2M message</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/General4.html b/apidoc/html/index/General4.html
new file mode 100644
index 0000000..b5b6ca1
--- /dev/null
+++ b/apidoc/html/index/General4.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
+
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
+
+
+
+
+<!--  Generated by Natural Docs, version 1.52 -->
+<!--  http://www.naturaldocs.org  -->
+
+<!-- saved from url=(0026)http://www.naturaldocs.org -->
+
+
+
+
+<div id=Index><div class=IPageTitle>Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; <a href="General.html#C">C</a> &middot; D &middot; <a href="General2.html#E">E</a> &middot; <a href="General3.html#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; <a href="#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; <a href="#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" id=link203 onMouseOver="ShowTip(event, 'tt202', 'link203')" onMouseOut="HideTip('tt202')" class=ISymbol>LightweightM2M_Types</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" id=link204 onMouseOver="ShowTip(event, 'tt203', 'link204')" onMouseOut="HideTip('tt203')" class=ISymbol>LwM2M_Block1_Handling</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Block1_Method" id=link205 onMouseOver="ShowTip(event, 'tt204', 'link205')" onMouseOut="HideTip('tt204')" class=ISymbol>LWM2M_Block1_Method</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" id=link206 onMouseOver="ShowTip(event, 'tt205', 'link206')" onMouseOut="HideTip('tt205')" class=ISymbol>LwM2M_DataSamples</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" id=link207 onMouseOver="ShowTip(event, 'tt206', 'link207')" onMouseOut="HideTip('tt206')" class=ISymbol>LwM2M_DataSamples_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" id=link208 onMouseOver="ShowTip(event, 'tt207', 'link208')" onMouseOut="HideTip('tt207')" class=ISymbol>LwM2M_DataSamples_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" id=link209 onMouseOver="ShowTip(event, 'tt208', 'link209')" onMouseOut="HideTip('tt208')" class=ISymbol>LwM2M_Device</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" id=link210 onMouseOver="ShowTip(event, 'tt209', 'link210')" onMouseOut="HideTip('tt209')" class=ISymbol>LwM2M_Device_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" id=link211 onMouseOver="ShowTip(event, 'tt210', 'link211')" onMouseOut="HideTip('tt210')" class=ISymbol>LwM2M_Device_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" id=link212 onMouseOver="ShowTip(event, 'tt211', 'link212')" onMouseOut="HideTip('tt211')" class=ISymbol>LwM2M_Device_State</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" id=link213 onMouseOver="ShowTip(event, 'tt212', 'link213')" onMouseOut="HideTip('tt212')" class=ISymbol>LwM2M_EntityCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" id=link214 onMouseOver="ShowTip(event, 'tt213', 'link214')" onMouseOut="HideTip('tt213')" class=ISymbol>LwM2M_EntityCtx_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" id=link215 onMouseOver="ShowTip(event, 'tt214', 'link215')" onMouseOut="HideTip('tt214')" class=ISymbol>LwM2M_EntityCtx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" id=link216 onMouseOver="ShowTip(event, 'tt215', 'link216')" onMouseOut="HideTip('tt215')" class=ISymbol>LWM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event_Block1" id=link217 onMouseOver="ShowTip(event, 'tt216', 'link217')" onMouseOut="HideTip('tt216')" class=ISymbol>LWM2M_Event_Block1</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Format_List" id=link218 onMouseOver="ShowTip(event, 'tt217', 'link218')" onMouseOut="HideTip('tt217')" class=ISymbol>LwM2M_Format_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" id=link219 onMouseOver="ShowTip(event, 'tt218', 'link219')" onMouseOut="HideTip('tt218')" class=ISymbol>LwM2M_InstanceTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" id=link220 onMouseOver="ShowTip(event, 'tt219', 'link220')" onMouseOut="HideTip('tt219')" class=ISymbol>LwM2M_Object</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" id=link221 onMouseOver="ShowTip(event, 'tt220', 'link221')" onMouseOut="HideTip('tt220')" class=ISymbol>LwM2M_Object_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" id=link222 onMouseOver="ShowTip(event, 'tt221', 'link222')" onMouseOut="HideTip('tt221')" class=ISymbol>LwM2M_ObjectDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" id=link223 onMouseOver="ShowTip(event, 'tt222', 'link223')" onMouseOut="HideTip('tt222')" class=ISymbol>LwM2M_ObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" id=link224 onMouseOver="ShowTip(event, 'tt223', 'link224')" onMouseOut="HideTip('tt223')" class=ISymbol>LwM2M_ObjectInstance_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" id=link225 onMouseOver="ShowTip(event, 'tt224', 'link225')" onMouseOut="HideTip('tt224')" class=ISymbol>LwM2M_ObjectSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" id=link226 onMouseOver="ShowTip(event, 'tt225', 'link226')" onMouseOut="HideTip('tt225')" class=ISymbol>LwM2M_ObjectSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" id=link227 onMouseOver="ShowTip(event, 'tt226', 'link227')" onMouseOut="HideTip('tt226')" class=ISymbol>LwM2M_ObjectSpecificationDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" id=link228 onMouseOver="ShowTip(event, 'tt227', 'link228')" onMouseOut="HideTip('tt227')" class=ISymbol>LwM2M_OperationTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" id=link229 onMouseOver="ShowTip(event, 'tt228', 'link229')" onMouseOut="HideTip('tt228')" class=ISymbol>LwM2M_Resource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" id=link230 onMouseOver="ShowTip(event, 'tt229', 'link230')" onMouseOut="HideTip('tt229')" class=ISymbol>LwM2M_Resource_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" id=link231 onMouseOver="ShowTip(event, 'tt230', 'link231')" onMouseOut="HideTip('tt230')" class=ISymbol>LwM2M_ResourceIdx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" id=link232 onMouseOver="ShowTip(event, 'tt231', 'link232')" onMouseOut="HideTip('tt231')" class=ISymbol>LwM2M_ResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" id=link233 onMouseOver="ShowTip(event, 'tt232', 'link233')" onMouseOut="HideTip('tt232')" class=ISymbol>LwM2M_ResourceSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" id=link234 onMouseOver="ShowTip(event, 'tt233', 'link234')" onMouseOut="HideTip('tt233')" class=ISymbol>LwM2M_ResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" id=link235 onMouseOver="ShowTip(event, 'tt234', 'link235')" onMouseOut="HideTip('tt234')" class=ISymbol>LwM2M_ResourceValue_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" id=link236 onMouseOver="ShowTip(event, 'tt235', 'link236')" onMouseOut="HideTip('tt235')" class=ISymbol>LwM2M_StepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" id=link237 onMouseOver="ShowTip(event, 'tt236', 'link237')" onMouseOut="HideTip('tt236')" class=ISymbol>LwM2M_Template</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" id=link238 onMouseOver="ShowTip(event, 'tt237', 'link238')" onMouseOut="HideTip('tt237')" class=ISymbol>LwM2M_Template_DB</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" id=link239 onMouseOver="ShowTip(event, 'tt238', 'link239')" onMouseOut="HideTip('tt238')" class=ISymbol>LwM2M_Template_List</a></td></tr><tr><td class=IHeading><a name="O"></a>O</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath" id=link240 onMouseOver="ShowTip(event, 'tt239', 'link240')" onMouseOut="HideTip('tt239')" class=ISymbol>ObjectPath</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath_List" id=link241 onMouseOver="ShowTip(event, 'tt240', 'link241')" onMouseOut="HideTip('tt240')" class=ISymbol>ObjectPath_List</a></td></tr><tr><td class=IHeading><a name="T"></a>T</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" id=link242 onMouseOver="ShowTip(event, 'tt241', 'link242')" onMouseOut="HideTip('tt241')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" id=link243 onMouseOver="ShowTip(event, 'tt242', 'link243')" onMouseOut="HideTip('tt242')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" id=link244 onMouseOver="ShowTip(event, 'tt243', 'link244')" onMouseOut="HideTip('tt243')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" id=link245 onMouseOver="ShowTip(event, 'tt244', 'link245')" onMouseOut="HideTip('tt244')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_defaultContentFormat" id=link246 onMouseOver="ShowTip(event, 'tt245', 'link246')" onMouseOut="HideTip('tt245')" class=ISymbol>tsp_EPTF_LwM2M_LGen_defaultContentFormat</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" id=link247 onMouseOver="ShowTip(event, 'tt246', 'link247')" onMouseOut="HideTip('tt246')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" id=link248 onMouseOver="ShowTip(event, 'tt247', 'link248')" onMouseOut="HideTip('tt247')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" id=link249 onMouseOver="ShowTip(event, 'tt248', 'link249')" onMouseOut="HideTip('tt248')" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" id=link250 onMouseOver="ShowTip(event, 'tt249', 'link250')" onMouseOut="HideTip('tt249')" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></td></tr></table>
+<!--START_ND_TOOLTIPS-->
+<div class=CToolTip id="tt202"><div class=CFile>This module contains type definitions for LWM2M PDUs</div></div><div class=CToolTip id="tt203"><div class=CType>Block1 handling strategy of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt204"><div class=CType>Block1 method types</div></div><div class=CToolTip id="tt205"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt206"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt207"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt208"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt209"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt210"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt211"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt212"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt213"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt214"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt215"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt216"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LWM2M_Event_Block1</td></tr></table></blockquote>Blcok1 event descriptor</div></div><div class=CToolTip id="tt217"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_Format_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt218"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt219"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt220"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt221"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt222"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt223"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt224"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt225"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt226"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt227"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt228"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt229"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt230"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt231"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt232"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt233"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt234"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt235"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt236"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt237"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt238"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><!--END_ND_TOOLTIPS-->
+
+
+<!--START_ND_TOOLTIPS-->
+<div class=CToolTip id="tt239"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><div class=CToolTip id="tt240"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><!--END_ND_TOOLTIPS-->
+
+
+<!--START_ND_TOOLTIPS-->
+<div class=CToolTip id="tt241"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt242"><div class=CModuleParameter>Enabled/disable the transport layer implementation</div></div><div class=CToolTip id="tt243"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt244"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt245"><div class=CModuleParameter>Setting the default content format code for encoding LwM2M payload</div></div><div class=CToolTip id="tt246"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt247"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt248"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt249"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><!--END_ND_TOOLTIPS-->
+
+</div><!--Index-->
+
+
+<script language=JavaScript><!--
+if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>
\ No newline at end of file
diff --git a/apidoc/html/index/ModuleParameters.html b/apidoc/html/index/ModuleParameters.html
index 6d83235..18f883a 100644
--- a/apidoc/html/index/ModuleParameters.html
+++ b/apidoc/html/index/ModuleParameters.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Module Parameter Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Module Parameter Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,9 +14,9 @@
 
 
 
-<div id=Index><div class=IPageTitle>Module Parameter Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; E &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; <a href="#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="T"></a>T</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Module Parameter Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; E &middot; F &middot; G &middot; H &middot; I &middot; J &middot; K &middot; L &middot; M &middot; N &middot; O &middot; P &middot; Q &middot; R &middot; S &middot; <a href="#T">T</a> &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="T"></a>T</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_defaultContentFormat" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>tsp_EPTF_LwM2M_LGen_defaultContentFormat</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt1"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt2"><div class=CModuleParameter>Enabled/disable the transport layer implementation</div></div><div class=CToolTip id="tt3"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt4"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt5"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt6"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt7"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt8"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt1"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt2"><div class=CModuleParameter>Enabled/disable the transport layer implementation</div></div><div class=CToolTip id="tt3"><div class=CModuleParameter>Enabled/disable debug logging</div></div><div class=CToolTip id="tt4"><div class=CModuleParameter>Enabled/disable verbose debug logging</div></div><div class=CToolTip id="tt5"><div class=CModuleParameter>Setting the default content format code for encoding LwM2M payload</div></div><div class=CToolTip id="tt6"><div class=CModuleParameter>Enabled/disable error logging</div></div><div class=CToolTip id="tt7"><div class=CModuleParameter>Enabled/disable warning logging</div></div><div class=CToolTip id="tt8"><div class=CModuleParameter>List of smart object specifications (needed for creating smart object instances)</div></div><div class=CToolTip id="tt9"><div class=CModuleParameter>List of LWM2M messages for sending</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/index/Types.html b/apidoc/html/index/Types.html
index 035a7ca..2d23dc5 100644
--- a/apidoc/html/index/Types.html
+++ b/apidoc/html/index/Types.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>LwM2M_Applib - Type Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Massive IoT Test Tools - Type Index</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script></head><body class="FramedIndexPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Type Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; <a href="#E">E</a> &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; <a href="#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>EPTF_LwM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>EPTF_LwM2M_LGen_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>EPTF_LwM2M_PDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></td></tr><tr><td class=IHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></td></tr><tr><td class=IHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>LwM2M_Block1_Handling</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>LwM2M_DataSamples</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>LwM2M_DataSamples_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>LwM2M_DataSamples_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>LwM2M_Device</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>LwM2M_Device_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>LwM2M_Device_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>LwM2M_Device_State</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>LwM2M_EntityCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>LwM2M_EntityCtx_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>LwM2M_EntityCtx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>LWM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>LwM2M_InstanceTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>LwM2M_Object</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>LwM2M_Object_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>LwM2M_ObjectDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>LwM2M_ObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>LwM2M_ObjectInstance_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>LwM2M_ObjectSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>LwM2M_ObjectSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>LwM2M_ObjectSpecificationDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>LwM2M_OperationTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>LwM2M_Resource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>LwM2M_Resource_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>LwM2M_ResourceIdx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>LwM2M_ResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>LwM2M_ResourceSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>LwM2M_ResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>LwM2M_ResourceValue_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>LwM2M_StepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>LwM2M_Template</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>LwM2M_Template_DB</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>LwM2M_Template_List</a></td></tr><tr><td class=IHeading><a name="O"></a>O</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>ObjectPath</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath_List" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>ObjectPath_List</a></td></tr></table>
+<div id=Index><div class=IPageTitle>Type Index</div><div class=INavigationBar>$#! &middot; 0-9 &middot; A &middot; B &middot; C &middot; D &middot; <a href="#E">E</a> &middot; <a href="#F">F</a> &middot; G &middot; H &middot; I &middot; J &middot; K &middot; <a href="#L">L</a> &middot; M &middot; N &middot; <a href="#O">O</a> &middot; P &middot; Q &middot; R &middot; S &middot; T &middot; U &middot; V &middot; W &middot; X &middot; Y &middot; Z</div><table border=0 cellspacing=0 cellpadding=0><tr><td class=IHeading id=IFirstHeading><a name="E"></a>E</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')" class=ISymbol>EPTF_LwM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')" class=ISymbol>EPTF_LwM2M_LGen_CT</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')" class=ISymbol>EPTF_LwM2M_PDU</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></td></tr><tr><td class=IHeading><a name="F"></a>F</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></td></tr><tr><td class=IHeading><a name="L"></a>L</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')" class=ISymbol>LwM2M_Block1_Handling</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Block1_Method" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')" class=ISymbol>LWM2M_Block1_Method</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')" class=ISymbol>LwM2M_DataSamples</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')" class=ISymbol>LwM2M_DataSamples_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')" class=ISymbol>LwM2M_DataSamples_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')" class=ISymbol>LwM2M_Device</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')" class=ISymbol>LwM2M_Device_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')" class=ISymbol>LwM2M_Device_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')" class=ISymbol>LwM2M_Device_State</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')" class=ISymbol>LwM2M_EntityCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')" class=ISymbol>LwM2M_EntityCtx_DB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')" class=ISymbol>LwM2M_EntityCtx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')" class=ISymbol>LWM2M_Event</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event_Block1" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')" class=ISymbol>LWM2M_Event_Block1</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Format_List" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')" class=ISymbol>LwM2M_Format_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')" class=ISymbol>LwM2M_InstanceTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')" class=ISymbol>LwM2M_Object</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')" class=ISymbol>LwM2M_Object_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')" class=ISymbol>LwM2M_ObjectDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')" class=ISymbol>LwM2M_ObjectInstance</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')" class=ISymbol>LwM2M_ObjectInstance_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')" class=ISymbol>LwM2M_ObjectSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')" class=ISymbol>LwM2M_ObjectSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')" class=ISymbol>LwM2M_ObjectSpecificationDB</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')" class=ISymbol>LwM2M_OperationTypeEnum</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')" class=ISymbol>LwM2M_Resource</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')" class=ISymbol>LwM2M_Resource_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')" class=ISymbol>LwM2M_ResourceIdx_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')" class=ISymbol>LwM2M_ResourceSpecification</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')" class=ISymbol>LwM2M_ResourceSpecification_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')" class=ISymbol>LwM2M_ResourceValue</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')" class=ISymbol>LwM2M_ResourceValue_List</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')" class=ISymbol>LwM2M_StepCtx</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')" class=ISymbol>LwM2M_Template</a></td></tr><tr><td class=ISymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')" class=ISymbol>LwM2M_Template_DB</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')" class=ISymbol>LwM2M_Template_List</a></td></tr><tr><td class=IHeading><a name="O"></a>O</td><td></td></tr><tr><td class=ISymbolPrefix id=IFirstSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath" id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')" class=ISymbol>ObjectPath</a></td></tr><tr><td class=ISymbolPrefix id=ILastSymbolPrefix>&nbsp;</td><td class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#ObjectPath_List" id=link50 onMouseOver="ShowTip(event, 'tt50', 'link50')" onMouseOut="HideTip('tt50')" class=ISymbol>ObjectPath_List</a></td></tr></table>
 <!--START_ND_TOOLTIPS-->
 <div class=CToolTip id="tt1"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_CoapApplibTransport_CT</td></tr></table></blockquote>LWM2M local transport component realized with EPTF_COAP_LGen_CT</div></div><div class=CToolTip id="tt2"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_CoapApplibTransport_Statistics</td></tr></table></blockquote>Storing counters for transport related statistics</div></div><div class=CToolTip id="tt3"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Event</td></tr></table></blockquote>Encapsulates a EPTF_LwM2M_Event with the corresponding entity</div></div><div class=CToolTip id="tt4"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT</td></tr></table></blockquote>LWM2M load generator component</div></div><div class=CToolTip id="tt5"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_LGen_Statistics</td></tr></table></blockquote>Storing counters for load generator related statistics</div></div><div class=CToolTip id="tt6"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_Message_Statistics</td></tr></table></blockquote>Storing counters for message related statistics</div></div><div class=CToolTip id="tt7"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record EPTF_LwM2M_PDU</td></tr></table></blockquote>Encapsulates a LWM2M_PDU with the corresponding entity (and FSM) indices</div></div><div class=CToolTip id="tt8"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_Provider_CT</td></tr></table></blockquote>Base component type for a LwM2M transport realization</div></div><div class=CToolTip id="tt9"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component EPTF_LwM2M_Transport_User_CT</td></tr></table></blockquote>Base component type for a LwM2M transport user realization</div></div><!--END_ND_TOOLTIPS-->
 
@@ -24,11 +24,11 @@
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt13"><div class=CType>Block1 handling strategy of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt14"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt15"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt16"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt17"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt18"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt19"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt20"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt21"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt22"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt23"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt24"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt25"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt26"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt27"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt28"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt29"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt30"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt31"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt32"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt33"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt34"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt35"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt36"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt37"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt38"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt39"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt40"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt41"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt42"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt43"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt44"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt45"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt13"><div class=CType>Block1 handling strategy of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt14"><div class=CType>Block1 method types</div></div><div class=CToolTip id="tt15"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples</td></tr></table></blockquote>Storing a list of resource values that can be played back to mimic resource value changes</div></div><div class=CToolTip id="tt16"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_DataSamples_DB</td></tr></table></blockquote>Storing LwM2M_DataSamples instances</div></div><div class=CToolTip id="tt17"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_DataSamples LwM2M_DataSamples_List</td></tr></table></blockquote>List of LwM2M_DataSamples</div></div><div class=CToolTip id="tt18"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device</td></tr></table></blockquote>Storing the state and smart object of a simulated LWM2M device</div></div><div class=CToolTip id="tt19"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Device_DB</td></tr></table></blockquote>Storing LwM2M_Device instances</div></div><div class=CToolTip id="tt20"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Device LwM2M_Device_List</td></tr></table></blockquote>List of LwM2M_Device</div></div><div class=CToolTip id="tt21"><div class=CType>States of a LwM2M_Device simulated LWM2M device</div></div><div class=CToolTip id="tt22"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx</td></tr></table></blockquote>A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity</div></div><div class=CToolTip id="tt23"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_EntityCtx_DB</td></tr></table></blockquote>Storing LWM2M entity contexts</div></div><div class=CToolTip id="tt24"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_EntityCtx LwM2M_EntityCtx_List</td></tr></table></blockquote>List of LwM2M_EntityCtx</div></div><div class=CToolTip id="tt25"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LWM2M_Event</td></tr></table></blockquote>A union of possible LwM2M events</div></div><div class=CToolTip id="tt26"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LWM2M_Event_Block1</td></tr></table></blockquote>Blcok1 event descriptor</div></div><div class=CToolTip id="tt27"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_Format_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt28"><div class=CType>Instantiation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt29"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Object</td></tr></table></blockquote>This structure models a LwM2M smart object</div></div><div class=CToolTip id="tt30"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Object LwM2M_Object_List</td></tr></table></blockquote>List of LwM2M_Object</div></div><div class=CToolTip id="tt31"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectDB</td></tr></table></blockquote>Storing LwM2M_Object instances</div></div><div class=CToolTip id="tt32"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectInstance</td></tr></table></blockquote>Models a smart object instance of a LwM2M_Object</div></div><div class=CToolTip id="tt33"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectInstance LwM2M_ObjectInstance_List</td></tr></table></blockquote>List of LwM2M_ObjectInstance</div></div><div class=CToolTip id="tt34"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecification</td></tr></table></blockquote>Defines a smart oject</div></div><div class=CToolTip id="tt35"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ObjectSpecification LwM2M_ObjectSpecification_List</td></tr></table></blockquote>List of LwM2M_ObjectSpecification</div></div><div class=CToolTip id="tt36"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ObjectSpecificationDB</td></tr></table></blockquote>Storing LwM2M_ObjectSpecification instances</div></div><div class=CToolTip id="tt37"><div class=CType>Operation types of a LwM2M_Resource</div></div><div class=CToolTip id="tt38"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Resource</td></tr></table></blockquote>Models a smart resource</div></div><div class=CToolTip id="tt39"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Resource LwM2M_Resource_List</td></tr></table></blockquote>List of LwM2M_Resource</div></div><div class=CToolTip id="tt40"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of integer LwM2M_ResourceIdx_List</td></tr></table></blockquote>List of <b>integer</b></div></div><div class=CToolTip id="tt41"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_ResourceSpecification</td></tr></table></blockquote>Defines a smart resource</div></div><div class=CToolTip id="tt42"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceSpecification LwM2M_ResourceSpecification_List</td></tr></table></blockquote>List of LwM2M_ResourceSpecification</div></div><div class=CToolTip id="tt43"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type union LwM2M_ResourceValue</td></tr></table></blockquote>Union for storing the value of a smart resource</div></div><div class=CToolTip id="tt44"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_ResourceValue LwM2M_ResourceValue_List</td></tr></table></blockquote>List of LwM2M_ResourceValue</div></div><div class=CToolTip id="tt45"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_StepCtx</td></tr></table></blockquote>Stores the most important pointers that are used from a test steps</div></div><div class=CToolTip id="tt46"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template</td></tr></table></blockquote>Grouping a LWM2M_PDU with an id so that the message can be loaded from an FSM later by using the id</div></div><div class=CToolTip id="tt47"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record LwM2M_Template_DB</td></tr></table></blockquote>Storing LwM2M_Template instances</div></div><div class=CToolTip id="tt48"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of LwM2M_Template LwM2M_Template_List</td></tr></table></blockquote>List of LwM2M_Template</div></div><!--END_ND_TOOLTIPS-->
 
 
 <!--START_ND_TOOLTIPS-->
-<div class=CToolTip id="tt46"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><div class=CToolTip id="tt47"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><!--END_ND_TOOLTIPS-->
+<div class=CToolTip id="tt49"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record ObjectPath</td></tr></table></blockquote>Models an access path up to a resource</div></div><div class=CToolTip id="tt50"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type record of ObjectPath ObjectPath_List</td></tr></table></blockquote>List of ObjectPath</div></div><!--END_ND_TOOLTIPS-->
 
 </div><!--Index-->
 
diff --git a/apidoc/html/javascript/searchdata.js b/apidoc/html/javascript/searchdata.js
index af16471..ac68c49 100644
--- a/apidoc/html/javascript/searchdata.js
+++ b/apidoc/html/javascript/searchdata.js
@@ -1,34 +1,4 @@
 var indexSectionsWithContent = {
-   "General": {
-      "Symbols": false,
-      "Numbers": false,
-      "A": false,
-      "B": false,
-      "C": true,
-      "D": false,
-      "E": true,
-      "F": true,
-      "G": false,
-      "H": false,
-      "I": false,
-      "J": false,
-      "K": false,
-      "L": true,
-      "M": false,
-      "N": false,
-      "O": true,
-      "P": false,
-      "Q": false,
-      "R": false,
-      "S": false,
-      "T": true,
-      "U": false,
-      "V": false,
-      "W": false,
-      "X": false,
-      "Y": false,
-      "Z": false
-      },
    "ModuleParameters": {
       "Symbols": false,
       "Numbers": false,
@@ -59,6 +29,36 @@
       "Y": false,
       "Z": false
       },
+   "Constants": {
+      "Symbols": false,
+      "Numbers": false,
+      "A": false,
+      "B": false,
+      "C": true,
+      "D": false,
+      "E": false,
+      "F": false,
+      "G": false,
+      "H": false,
+      "I": false,
+      "J": false,
+      "K": false,
+      "L": false,
+      "M": false,
+      "N": false,
+      "O": false,
+      "P": false,
+      "Q": false,
+      "R": false,
+      "S": false,
+      "T": false,
+      "U": false,
+      "V": false,
+      "W": false,
+      "X": false,
+      "Y": false,
+      "Z": false
+      },
    "Types": {
       "Symbols": false,
       "Numbers": false,
@@ -89,15 +89,15 @@
       "Y": false,
       "Z": false
       },
-   "Files": {
+   "General": {
       "Symbols": false,
       "Numbers": false,
       "A": false,
       "B": false,
-      "C": false,
+      "C": true,
       "D": false,
       "E": true,
-      "F": false,
+      "F": true,
       "G": false,
       "H": false,
       "I": false,
@@ -106,12 +106,12 @@
       "L": true,
       "M": false,
       "N": false,
-      "O": false,
+      "O": true,
       "P": false,
       "Q": false,
       "R": false,
       "S": false,
-      "T": false,
+      "T": true,
       "U": false,
       "V": false,
       "W": false,
@@ -149,21 +149,21 @@
       "Y": false,
       "Z": false
       },
-   "Constants": {
+   "Files": {
       "Symbols": false,
       "Numbers": false,
       "A": false,
       "B": false,
-      "C": true,
+      "C": false,
       "D": false,
-      "E": false,
+      "E": true,
       "F": false,
       "G": false,
       "H": false,
       "I": false,
       "J": false,
       "K": false,
-      "L": false,
+      "L": true,
       "M": false,
       "N": false,
       "O": false,
diff --git a/apidoc/html/menu.html b/apidoc/html/menu.html
index 036beec..49ebacb 100644
--- a/apidoc/html/menu.html
+++ b/apidoc/html/menu.html
@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
 
-<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Menu - LwM2M_Applib</title><base target="Content"><link rel="stylesheet" type="text/css" href="styles/main.css"><script language=JavaScript src="javascript/main.js"></script><script language=JavaScript src="javascript/searchdata.js"></script></head><body class="FramedMenuPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
+<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Menu - Massive IoT Test Tools</title><base target="Content"><link rel="stylesheet" type="text/css" href="styles/main.css"><script language=JavaScript src="javascript/main.js"></script><script language=JavaScript src="javascript/searchdata.js"></script></head><body class="FramedMenuPage" onLoad="NDOnLoad()"><script language=JavaScript><!--
 if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>
 
 <!--  Generated by Natural Docs, version 1.52 -->
@@ -11,12 +11,12 @@
 
 
 
-<div id=Menu><div class=MTitle>LwM2M_Applib<div class=MSubTitle>API Documentation</div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html">EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html">EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_LGen_Definitions-ttcn.html">EPTF_LwM2M_LGen_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_LGen_Functions-ttcn.html">EPTF_LwM2M_LGen_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Object_Definitions-ttcn.html">EPTF_LwM2M_Object_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Object_Functions-ttcn.html">EPTF_LwM2M_Object_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Transport_Definitions-ttcn.html">EPTF_LwM2M_Transport_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/LightweightM2M_Types-ttcn.html">LightweightM2M_Types</a></div></div><div class=MEntry><div class=MGroup><a href="javascript:ToggleMenu('MGroupContent1')" target="_self">Index</a><div class=MGroupContent id=MGroupContent1><div class=MEntry><div class=MIndex><a href="index/Constants.html">Constants</a></div></div><div class=MEntry><div class=MIndex><a href="index/General.html">Everything</a></div></div><div class=MEntry><div class=MIndex><a href="index/Files.html">Files</a></div></div><div class=MEntry><div class=MIndex><a href="index/Functions.html">Functions</a></div></div><div class=MEntry><div class=MIndex><a href="index/ModuleParameters.html">Module Parameters</a></div></div><div class=MEntry><div class=MIndex><a href="index/Types.html">Types</a></div></div></div></div></div><script type="text/javascript"><!--
+<div id=Menu><div class=MTitle>Massive IoT Test Tools<div class=MSubTitle>API Documentation</div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html">EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html">EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_LGen_Definitions-ttcn.html">EPTF_LwM2M_LGen_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_LGen_Functions-ttcn.html">EPTF_LwM2M_LGen_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Object_Definitions-ttcn.html">EPTF_LwM2M_Object_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Object_Decoders-ttcn.html">EPTF_LwM2M_Object_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Object_Functions-ttcn.html">EPTF_LwM2M_Object_Functions</a></div></div><div class=MEntry><div class=MFile><a href="files/EPTF_LwM2M_Transport_Definitions-ttcn.html">EPTF_LwM2M_Transport_Definitions</a></div></div><div class=MEntry><div class=MFile><a href="files/LightweightM2M_Types-ttcn.html">LightweightM2M_Types</a></div></div><div class=MEntry><div class=MGroup><a href="javascript:ToggleMenu('MGroupContent1')" target="_self">Index</a><div class=MGroupContent id=MGroupContent1><div class=MEntry><div class=MIndex><a href="index/Constants.html">Constants</a></div></div><div class=MEntry><div class=MIndex><a href="index/General.html">Everything</a></div></div><div class=MEntry><div class=MIndex><a href="index/Files.html">Files</a></div></div><div class=MEntry><div class=MIndex><a href="index/Functions.html">Functions</a></div></div><div class=MEntry><div class=MIndex><a href="index/ModuleParameters.html">Module Parameters</a></div></div><div class=MEntry><div class=MIndex><a href="index/Types.html">Types</a></div></div></div></div></div><script type="text/javascript"><!--
 var searchPanel = new SearchPanel("searchPanel", "FramedHTML", "search");
 --></script><div id=MSearchPanel class=MSearchPanelInactive><input type=text id=MSearchField value=Search onFocus="searchPanel.OnSearchFieldFocus(true)" onBlur="searchPanel.OnSearchFieldFocus(false)" onKeyUp="searchPanel.OnSearchFieldChange()"><select id=MSearchType onFocus="searchPanel.OnSearchTypeFocus(true)" onBlur="searchPanel.OnSearchTypeFocus(false)" onChange="searchPanel.OnSearchTypeChange()"><option  id=MSearchEverything selected value="General">Everything</option><option value="Constants">Constants</option><option value="Files">Files</option><option value="Functions">Functions</option><option value="ModuleParameters">Module Parameters</option><option value="Types">Types</option></select></div></div><!--Menu-->
 
 
-<div id=Footer><p>Copyright 2020 Test Competence Center</p><p>Generated on 2020-02-05</p><p><a href="http://www.naturaldocs.org">Generated by Natural Docs</a></p></div><!--Footer-->
+<div id=Footer><p>Copyright 2020 Test Competence Center</p><p>Generated on 2020-03-18</p><p><a href="http://www.naturaldocs.org">Generated by Natural Docs</a></p></div><!--Footer-->
 
 
 <script language=JavaScript><!--
diff --git a/apidoc/html/search/ConstantsC.html b/apidoc/html/search/ConstantsC.html
index 0ee42d9..c7b1780 100644
--- a/apidoc/html/search/ConstantsC.html
+++ b/apidoc/html/search/ConstantsC.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_c_undLwM2M_undbehaviorType><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" class=ISymbol>c_LwM2M_behaviorType</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" class=ISymbol>c_LwM2M_eventIdx_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" class=ISymbol>c_LwM2M_eventIdx_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" class=ISymbol>c_LwM2M_eventIdx_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" class=ISymbol>c_LwM2M_eventIdx_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" class=ISymbol>c_LwM2M_eventIdx_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" class=ISymbol>c_LwM2M_eventIdx_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" class=ISymbol>c_LwM2M_eventIdx_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" class=ISymbol>c_LwM2M_eventIdx_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" class=ISymbol>c_LwM2M_eventIdx_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" class=ISymbol>c_LwM2M_eventIdx_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" class=ISymbol>c_LwM2M_eventIdx_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" class=ISymbol>c_LwM2M_eventIdx_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" class=ISymbol>c_LwM2M_eventIdx_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" class=ISymbol>c_LwM2M_eventIdx_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" class=ISymbol>c_LwM2M_eventName_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" class=ISymbol>c_LwM2M_eventName_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" class=ISymbol>c_LwM2M_eventName_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" class=ISymbol>c_LwM2M_eventName_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" class=ISymbol>c_LwM2M_eventName_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" class=ISymbol>c_LwM2M_eventName_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" class=ISymbol>c_LwM2M_eventName_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" class=ISymbol>c_LwM2M_eventName_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" class=ISymbol>c_LwM2M_eventName_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" class=ISymbol>c_LwM2M_eventName_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" class=ISymbol>c_LwM2M_eventName_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" class=ISymbol>c_LwM2M_eventName_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" class=ISymbol>c_LwM2M_eventName_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" class=ISymbol>c_LwM2M_eventName_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" class=ISymbol>c_LwM2M_eventName_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=ISymbol>c_LwM2M_stepIdx_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=ISymbol>c_LwM2M_stepIdx_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=ISymbol>c_LwM2M_stepName_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=ISymbol>c_LwM2M_stepName_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=ISymbol>c_LwM2M_stepName_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=ISymbol>c_LwM2M_stepName_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_c_undLwM2M_undbehaviorType><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" class=ISymbol>c_LwM2M_behaviorType</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" class=ISymbol>c_LwM2M_eventIdx_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" class=ISymbol>c_LwM2M_eventIdx_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" class=ISymbol>c_LwM2M_eventIdx_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" class=ISymbol>c_LwM2M_eventIdx_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" class=ISymbol>c_LwM2M_eventIdx_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" class=ISymbol>c_LwM2M_eventIdx_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" class=ISymbol>c_LwM2M_eventIdx_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" class=ISymbol>c_LwM2M_eventIdx_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" class=ISymbol>c_LwM2M_eventIdx_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" class=ISymbol>c_LwM2M_eventIdx_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" class=ISymbol>c_LwM2M_eventIdx_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" class=ISymbol>c_LwM2M_eventIdx_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" class=ISymbol>c_LwM2M_eventIdx_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" class=ISymbol>c_LwM2M_eventIdx_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" class=ISymbol>c_LwM2M_eventName_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" class=ISymbol>c_LwM2M_eventName_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" class=ISymbol>c_LwM2M_eventName_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" class=ISymbol>c_LwM2M_eventName_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" class=ISymbol>c_LwM2M_eventName_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" class=ISymbol>c_LwM2M_eventName_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" class=ISymbol>c_LwM2M_eventName_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" class=ISymbol>c_LwM2M_eventName_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" class=ISymbol>c_LwM2M_eventName_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" class=ISymbol>c_LwM2M_eventName_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" class=ISymbol>c_LwM2M_eventName_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" class=ISymbol>c_LwM2M_eventName_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" class=ISymbol>c_LwM2M_eventName_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" class=ISymbol>c_LwM2M_eventName_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" class=ISymbol>c_LwM2M_eventName_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=ISymbol>c_LwM2M_stepIdx_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=ISymbol>c_LwM2M_stepIdx_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setContentFormats" class=ISymbol>c_LwM2M_stepIdx_setContentFormats</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=ISymbol>c_LwM2M_stepName_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=ISymbol>c_LwM2M_stepName_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=ISymbol>c_LwM2M_stepName_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=ISymbol>c_LwM2M_stepName_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setContentFormats" class=ISymbol>c_LwM2M_stepName_setContentFormats</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/FilesE.html b/apidoc/html/search/FilesE.html
index 99235fb..7e9bf34 100644
--- a/apidoc/html/search/FilesE.html
+++ b/apidoc/html/search/FilesE.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=ISymbol>EPTF_LwM2M_Object_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" class=ISymbol>EPTF_LwM2M_Object_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undDefinitions><div class=IEntry><a href="javascript:searchResults.Toggle('SR_EPTF_undLwM2M_undObject_undDefinitions')" class=ISymbol>EPTF_LwM2M_Object_Definitions</a><div class=ISubIndex><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#EPTF_LwM2M_Object_Definitions" class=IFile>EPTF_LwM2M_Object_Decoders.ttcn</a><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=IFile>EPTF_LwM2M_Object_Definitions.ttcn</a></div></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" class=ISymbol>EPTF_LwM2M_Object_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/FunctionsF.html b/apidoc/html/search/FunctionsF.html
index 044ba9b..5527f2e 100644
--- a/apidoc/html/search/FunctionsF.html
+++ b/apidoc/html/search/FunctionsF.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undcleanup><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undeventIndication><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undmessageReceived><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undObjectPath_undto_undresourceIdString><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareEvents><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareSteps><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undlocationHash><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undremove><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undsetLocationKey><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEventsForPDU><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetIntValue><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undhasDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinitLogging><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undisBootstrap><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undDEBUG><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undERROR><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undVERBOSE><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undWARNING><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undPduToEventIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsendNotificationForResource><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=ISymbol>f_EPTF_LwM2M_setCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromApp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromEnv><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=ISymbol>f_LwM2M_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcreateResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=ISymbol>f_LwM2M_createResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxBind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=ISymbol>f_LwM2M_eCtxBind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxReset><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=ISymbol>f_LwM2M_eCtxReset</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxUnbind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=ISymbol>f_LwM2M_eCtxUnbind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectIdx><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectPaths><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=ISymbol>f_LwM2M_ObjectDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceObserved><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undfillInOmaSpecs><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undsetNextDataSample><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforIds><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" class=ISymbol>f_LwM2M_resourceHash_forIds</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" class=ISymbol>f_LwM2M_resourceHash_forResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=ISymbol>f_LwM2M_step_cleanupDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=ISymbol>f_LwM2M_step_createDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=ISymbol>f_LwM2M_step_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=ISymbol>f_LwM2M_step_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=ISymbol>f_LwM2M_step_handleReadRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=ISymbol>f_LwM2M_step_logDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=ISymbol>f_LwM2M_step_send</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=ISymbol>f_LwM2M_step_setBootstrapState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undwriteOrCreateObject_undBS><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_f_undEPTF_undLwM2M_undcanEncode><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_canEncode" class=ISymbol>f_EPTF_LwM2M_canEncode</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undcleanup><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undeventIndication><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undmessageReceived><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undObjectPath_undto_undresourceIdString><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareEvents><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareSteps><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undlocationHash><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undremove><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undsetLocationKey><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEventsForPDU><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetEncodingContentFormat><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getEncodingContentFormat" class=ISymbol>f_EPTF_LwM2M_getEncodingContentFormat</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetIntValue><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undhasDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinitLogging><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undisBootstrap><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undDEBUG><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undERROR><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undVERBOSE><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undWARNING><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undPduToEventIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsendNotificationForResource><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=ISymbol>f_EPTF_LwM2M_setCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromApp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromEnv><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undupdateMessageStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_updateMessageStatistics" class=ISymbol>f_EPTF_LwM2M_updateMessageStatistics</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=ISymbol>f_LwM2M_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcreateResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=ISymbol>f_LwM2M_createResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxBind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=ISymbol>f_LwM2M_eCtxBind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxReset><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=ISymbol>f_LwM2M_eCtxReset</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxUnbind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=ISymbol>f_LwM2M_eCtxUnbind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectIdx><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectPaths><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=ISymbol>f_LwM2M_ObjectDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceObserved><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undfillInOmaSpecs><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undgetResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" class=ISymbol>f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undcheckSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_checkSpecification" class=ISymbol>f_LwM2M_Resource_checkSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_unddecode><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#f_LwM2M_Resource_decode" class=ISymbol>f_LwM2M_Resource_decode</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undgetSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_getSpecification" class=ISymbol>f_LwM2M_Resource_getSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undsetNextDataSample><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforIds><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" class=ISymbol>f_LwM2M_resourceHash_forIds</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" class=ISymbol>f_LwM2M_resourceHash_forResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=ISymbol>f_LwM2M_step_cleanupDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=ISymbol>f_LwM2M_step_createDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=ISymbol>f_LwM2M_step_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=ISymbol>f_LwM2M_step_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=ISymbol>f_LwM2M_step_handleReadRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=ISymbol>f_LwM2M_step_logDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=ISymbol>f_LwM2M_step_send</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=ISymbol>f_LwM2M_step_setBootstrapState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" class=ISymbol>f_LwM2M_step_setContentFormats</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undwriteOrCreateObject_undBS><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/GeneralC.html b/apidoc/html/search/GeneralC.html
index 0ee42d9..c7b1780 100644
--- a/apidoc/html/search/GeneralC.html
+++ b/apidoc/html/search/GeneralC.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_c_undLwM2M_undbehaviorType><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" class=ISymbol>c_LwM2M_behaviorType</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" class=ISymbol>c_LwM2M_eventIdx_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" class=ISymbol>c_LwM2M_eventIdx_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" class=ISymbol>c_LwM2M_eventIdx_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" class=ISymbol>c_LwM2M_eventIdx_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" class=ISymbol>c_LwM2M_eventIdx_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" class=ISymbol>c_LwM2M_eventIdx_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" class=ISymbol>c_LwM2M_eventIdx_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" class=ISymbol>c_LwM2M_eventIdx_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" class=ISymbol>c_LwM2M_eventIdx_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" class=ISymbol>c_LwM2M_eventIdx_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" class=ISymbol>c_LwM2M_eventIdx_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" class=ISymbol>c_LwM2M_eventIdx_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" class=ISymbol>c_LwM2M_eventIdx_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" class=ISymbol>c_LwM2M_eventIdx_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" class=ISymbol>c_LwM2M_eventName_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" class=ISymbol>c_LwM2M_eventName_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" class=ISymbol>c_LwM2M_eventName_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" class=ISymbol>c_LwM2M_eventName_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" class=ISymbol>c_LwM2M_eventName_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" class=ISymbol>c_LwM2M_eventName_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" class=ISymbol>c_LwM2M_eventName_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" class=ISymbol>c_LwM2M_eventName_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" class=ISymbol>c_LwM2M_eventName_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" class=ISymbol>c_LwM2M_eventName_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" class=ISymbol>c_LwM2M_eventName_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" class=ISymbol>c_LwM2M_eventName_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" class=ISymbol>c_LwM2M_eventName_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" class=ISymbol>c_LwM2M_eventName_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" class=ISymbol>c_LwM2M_eventName_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=ISymbol>c_LwM2M_stepIdx_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=ISymbol>c_LwM2M_stepIdx_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=ISymbol>c_LwM2M_stepName_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=ISymbol>c_LwM2M_stepName_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=ISymbol>c_LwM2M_stepName_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=ISymbol>c_LwM2M_stepName_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_c_undLwM2M_undbehaviorType><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_behaviorType" class=ISymbol>c_LwM2M_behaviorType</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_1xx" class=ISymbol>c_LwM2M_eventIdx_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_2xx" class=ISymbol>c_LwM2M_eventIdx_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xx" class=ISymbol>c_LwM2M_eventIdx_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_3xxto6xx" class=ISymbol>c_LwM2M_eventIdx_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_4xx" class=ISymbol>c_LwM2M_eventIdx_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_5xx" class=ISymbol>c_LwM2M_eventIdx_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_6xx" class=ISymbol>c_LwM2M_eventIdx_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventIdx_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Delete" class=ISymbol>c_LwM2M_eventIdx_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Discover" class=ISymbol>c_LwM2M_eventIdx_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_BS_Finish" class=ISymbol>c_LwM2M_eventIdx_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Create" class=ISymbol>c_LwM2M_eventIdx_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Delete" class=ISymbol>c_LwM2M_eventIdx_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Deregister" class=ISymbol>c_LwM2M_eventIdx_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Execute" class=ISymbol>c_LwM2M_eventIdx_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventIdx_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Observe" class=ISymbol>c_LwM2M_eventIdx_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Read" class=ISymbol>c_LwM2M_eventIdx_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Register" class=ISymbol>c_LwM2M_eventIdx_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventIdx_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Update" class=ISymbol>c_LwM2M_eventIdx_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_Write" class=ISymbol>c_LwM2M_eventIdx_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWPackage" class=ISymbol>c_LwM2M_eventIdx_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventIdx_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventIdx_WriteFWUri" class=ISymbol>c_LwM2M_eventIdx_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und1xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_1xx" class=ISymbol>c_LwM2M_eventName_1xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und2xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_2xx" class=ISymbol>c_LwM2M_eventName_2xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xx" class=ISymbol>c_LwM2M_eventName_3xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und3xxto6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_3xxto6xx" class=ISymbol>c_LwM2M_eventName_3xxto6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und4xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_4xx" class=ISymbol>c_LwM2M_eventName_4xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und5xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_5xx" class=ISymbol>c_LwM2M_eventName_5xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_und6xx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_6xx" class=ISymbol>c_LwM2M_eventName_6xx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undatomicBlock1Finished><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_atomicBlock1Finished" class=ISymbol>c_LwM2M_eventName_atomicBlock1Finished</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Delete" class=ISymbol>c_LwM2M_eventName_BS_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undDiscover><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Discover" class=ISymbol>c_LwM2M_eventName_BS_Discover</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undBS_undFinish><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_BS_Finish" class=ISymbol>c_LwM2M_eventName_BS_Finish</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undCreate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Create" class=ISymbol>c_LwM2M_eventName_Create</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDelete><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Delete" class=ISymbol>c_LwM2M_eventName_Delete</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undDeregister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Deregister" class=ISymbol>c_LwM2M_eventName_Deregister</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecute><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Execute" class=ISymbol>c_LwM2M_eventName_Execute</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undExecuteFWUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_ExecuteFWUpdate" class=ISymbol>c_LwM2M_eventName_ExecuteFWUpdate</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undObserve><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Observe" class=ISymbol>c_LwM2M_eventName_Observe</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRead><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Read" class=ISymbol>c_LwM2M_eventName_Read</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undRegister><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Register" class=ISymbol>c_LwM2M_eventName_Register</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undresourceNotObservedIndication><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_resourceNotObservedIndication" class=ISymbol>c_LwM2M_eventName_resourceNotObservedIndication</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undUpdate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Update" class=ISymbol>c_LwM2M_eventName_Update</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWrite><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_Write" class=ISymbol>c_LwM2M_eventName_Write</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWPackage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWPackage" class=ISymbol>c_LwM2M_eventName_WriteFWPackage</a></div></div><div class=SRResult id=SR_c_undLwM2M_undeventName_undWriteFWUri><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_eventName_WriteFWUri" class=ISymbol>c_LwM2M_eventName_WriteFWUri</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_cleanupDevice" class=ISymbol>c_LwM2M_stepIdx_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createDevice" class=ISymbol>c_LwM2M_stepIdx_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObject" class=ISymbol>c_LwM2M_stepIdx_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_createObjectInstance" class=ISymbol>c_LwM2M_stepIdx_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleExecuteRequest" class=ISymbol>c_LwM2M_stepIdx_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleReadRequest" class=ISymbol>c_LwM2M_stepIdx_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_handleWriteRequest" class=ISymbol>c_LwM2M_stepIdx_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepIdx_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_logDevice" class=ISymbol>c_LwM2M_stepIdx_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_send" class=ISymbol>c_LwM2M_stepIdx_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepIdx_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepIdx_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setBootstrapState" class=ISymbol>c_LwM2M_stepIdx_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setContentFormats" class=ISymbol>c_LwM2M_stepIdx_setContentFormats</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setFirmwareUpdateResult" class=ISymbol>c_LwM2M_stepIdx_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepIdx_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepIdx_setNotRegisteredState" class=ISymbol>c_LwM2M_stepIdx_setNotRegisteredState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_cleanupDevice" class=ISymbol>c_LwM2M_stepName_cleanupDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createDevice" class=ISymbol>c_LwM2M_stepName_createDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObject" class=ISymbol>c_LwM2M_stepName_createObject</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_createObjectInstance" class=ISymbol>c_LwM2M_stepName_createObjectInstance</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleExecuteRequest" class=ISymbol>c_LwM2M_stepName_handleExecuteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleReadRequest" class=ISymbol>c_LwM2M_stepName_handleReadRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_handleWriteRequest" class=ISymbol>c_LwM2M_stepName_handleWriteRequest</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byIntIdx" class=ISymbol>c_LwM2M_stepName_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_loadTemplate_byStringId" class=ISymbol>c_LwM2M_stepName_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_logDevice" class=ISymbol>c_LwM2M_stepName_logDevice</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_send" class=ISymbol>c_LwM2M_stepName_send</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_sendNotificationForObservedResources" class=ISymbol>c_LwM2M_stepName_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_atomic" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBlock1Handling_stateless" class=ISymbol>c_LwM2M_stepName_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setBootstrapState" class=ISymbol>c_LwM2M_stepName_setBootstrapState</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setContentFormats" class=ISymbol>c_LwM2M_stepName_setContentFormats</a></div></div><div class=SRResult id=SR_c_undLwM2M_undstepName_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#c_LwM2M_stepName_setFirmwareUpdateState" class=ISymbol>c_LwM2M_stepName_setFirmwareUpdateState</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/GeneralE.html b/apidoc/html/search/GeneralE.html
index b3d38ca..3f19815 100644
--- a/apidoc/html/search/GeneralE.html
+++ b/apidoc/html/search/GeneralE.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=ISymbol>EPTF_LwM2M_Event</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=ISymbol>EPTF_LwM2M_LGen_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undMessage_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=ISymbol>EPTF_LwM2M_Object_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" class=ISymbol>EPTF_LwM2M_Object_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undPDU><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=ISymbol>EPTF_LwM2M_PDU</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undProvider_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undUser_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_CT" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Definitions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Functions" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undCoapApplibTransport_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#EPTF_LwM2M_CoapApplibTransport_Statistics" class=ISymbol>EPTF_LwM2M_CoapApplibTransport_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Event" class=ISymbol>EPTF_LwM2M_Event</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_CT" class=ISymbol>EPTF_LwM2M_LGen_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Definitions" class=ISymbol>EPTF_LwM2M_LGen_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#EPTF_LwM2M_LGen_Functions" class=ISymbol>EPTF_LwM2M_LGen_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undLGen_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_LGen_Statistics" class=ISymbol>EPTF_LwM2M_LGen_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undMessage_undStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#EPTF_LwM2M_Message_Statistics" class=ISymbol>EPTF_LwM2M_Message_Statistics</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undDefinitions><div class=IEntry><a href="javascript:searchResults.Toggle('SR_EPTF_undLwM2M_undObject_undDefinitions')" class=ISymbol>EPTF_LwM2M_Object_Definitions</a><div class=ISubIndex><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#EPTF_LwM2M_Object_Definitions" class=IFile>EPTF_LwM2M_Object_Decoders.ttcn</a><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#EPTF_LwM2M_Object_Definitions" class=IFile>EPTF_LwM2M_Object_Definitions.ttcn</a></div></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undObject_undFunctions><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#EPTF_LwM2M_Object_Functions" class=ISymbol>EPTF_LwM2M_Object_Functions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undPDU><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_PDU" class=ISymbol>EPTF_LwM2M_PDU</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undDefinitions><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Definitions" class=ISymbol>EPTF_LwM2M_Transport_Definitions</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undProvider_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_Provider_CT" class=ISymbol>EPTF_LwM2M_Transport_Provider_CT</a></div></div><div class=SRResult id=SR_EPTF_undLwM2M_undTransport_undUser_undCT><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#EPTF_LwM2M_Transport_User_CT" class=ISymbol>EPTF_LwM2M_Transport_User_CT</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/GeneralF.html b/apidoc/html/search/GeneralF.html
index f349835..891b998 100644
--- a/apidoc/html/search/GeneralF.html
+++ b/apidoc/html/search/GeneralF.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undcleanup><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undeventIndication><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undmessageReceived><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undObjectPath_undto_undresourceIdString><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareEvents><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareSteps><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undlocationHash><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undremove><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undsetLocationKey><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEventsForPDU><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetIntValue><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undhasDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinitLogging><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undisBootstrap><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undDEBUG><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undERROR><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undVERBOSE><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undWARNING><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undPduToEventIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsendNotificationForResource><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=ISymbol>f_EPTF_LwM2M_setCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromApp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromEnv><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=ISymbol>f_LwM2M_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcreateResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=ISymbol>f_LwM2M_createResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxBind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=ISymbol>f_LwM2M_eCtxBind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxReset><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=ISymbol>f_LwM2M_eCtxReset</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxUnbind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=ISymbol>f_LwM2M_eCtxUnbind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectIdx><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectPaths><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=ISymbol>f_LwM2M_ObjectDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceObserved><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undfillInOmaSpecs><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undsetNextDataSample><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforIds><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" class=ISymbol>f_LwM2M_resourceHash_forIds</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" class=ISymbol>f_LwM2M_resourceHash_forResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=ISymbol>f_LwM2M_step_cleanupDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=ISymbol>f_LwM2M_step_createDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=ISymbol>f_LwM2M_step_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=ISymbol>f_LwM2M_step_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=ISymbol>f_LwM2M_step_handleReadRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=ISymbol>f_LwM2M_step_logDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=ISymbol>f_LwM2M_step_send</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=ISymbol>f_LwM2M_step_setBootstrapState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undwriteOrCreateObject_undBS><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undsendMessage><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_f_undEPTF_undLwM2M_undcanEncode><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_canEncode" class=ISymbol>f_EPTF_LwM2M_canEncode</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undcleanup><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_cleanup" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_cleanup</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undeventIndication><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_eventIndication" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_eventIndication</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_init" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undmessageReceived><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_messageReceived" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_messageReceived</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undObjectPath_undto_undresourceIdString><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_ObjectPath_to_resourceIdString</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undCoapApplibTransport_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#f_EPTF_LwM2M_CoapApplibTransport_send" class=ISymbol>f_EPTF_LwM2M_CoapApplibTransport_send</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareEvents><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareEvents" class=ISymbol>f_EPTF_LwM2M_declareEvents</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddeclareSteps><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_declareSteps" class=ISymbol>f_EPTF_LwM2M_declareSteps</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_add" class=ISymbol>f_EPTF_LwM2M_DeviceDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_DeviceDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_init" class=ISymbol>f_EPTF_LwM2M_DeviceDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undlocationHash><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_locationHash" class=ISymbol>f_EPTF_LwM2M_DeviceDB_locationHash</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undremove><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_remove" class=ISymbol>f_EPTF_LwM2M_DeviceDB_remove</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undDeviceDB_undsetLocationKey><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_DeviceDB_setLocationKey" class=ISymbol>f_EPTF_LwM2M_DeviceDB_setLocationKey</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEvent" class=ISymbol>f_EPTF_LwM2M_dispatchEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_unddispatchEventsForPDU><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_dispatchEventsForPDU" class=ISymbol>f_EPTF_LwM2M_dispatchEventsForPDU</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undEntityCtxDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_EntityCtxDB_init" class=ISymbol>f_EPTF_LwM2M_EntityCtxDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetEncodingContentFormat><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getEncodingContentFormat" class=ISymbol>f_EPTF_LwM2M_getEncodingContentFormat</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undgetIntValue><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_getIntValue" class=ISymbol>f_EPTF_LwM2M_getIntValue</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undhasDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_hasDevice" class=ISymbol>f_EPTF_LwM2M_hasDevice</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_init" class=ISymbol>f_EPTF_LwM2M_LGen_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undinitLogging><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_initLogging" class=ISymbol>f_EPTF_LwM2M_LGen_initLogging</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undisBootstrap><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_isBootstrap" class=ISymbol>f_EPTF_LwM2M_LGen_isBootstrap</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveEvent" class=ISymbol>f_EPTF_LwM2M_LGen_receiveEvent</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLGen_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_LGen_receiveMessage" class=ISymbol>f_EPTF_LwM2M_LGen_receiveMessage</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undDEBUG><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_DEBUG" class=ISymbol>f_EPTF_LwM2M_Logging_DEBUG</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undERROR><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_ERROR" class=ISymbol>f_EPTF_LwM2M_Logging_ERROR</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undVERBOSE><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_VERBOSE" class=ISymbol>f_EPTF_LwM2M_Logging_VERBOSE</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undLogging_undWARNING><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_Logging_WARNING" class=ISymbol>f_EPTF_LwM2M_Logging_WARNING</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undPduToEventIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_PduToEventIdx" class=ISymbol>f_EPTF_LwM2M_PduToEventIdx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsendNotificationForResource><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_sendNotificationForResource" class=ISymbol>f_EPTF_LwM2M_sendNotificationForResource</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setCtx" class=ISymbol>f_EPTF_LwM2M_setCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undsetStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_setStepCtx" class=ISymbol>f_EPTF_LwM2M_setStepCtx</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromApp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromApp" class=ISymbol>f_EPTF_LwM2M_stack_fromApp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undstack_undfromEnv><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_stack_fromEnv" class=ISymbol>f_EPTF_LwM2M_stack_fromEnv</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_add" class=ISymbol>f_EPTF_LwM2M_TemplateDB_add</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_cleanUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_get" class=ISymbol>f_EPTF_LwM2M_TemplateDB_get</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_init" class=ISymbol>f_EPTF_LwM2M_TemplateDB_init</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undTemplateDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_TemplateDB_lookUp" class=ISymbol>f_EPTF_LwM2M_TemplateDB_lookUp</a></div></div><div class=SRResult id=SR_f_undEPTF_undLwM2M_undupdateMessageStatistics><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_EPTF_LwM2M_updateMessageStatistics" class=ISymbol>f_EPTF_LwM2M_updateMessageStatistics</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_cleanUp" class=ISymbol>f_LwM2M_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undcreateResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_createResource" class=ISymbol>f_LwM2M_createResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_add" class=ISymbol>f_LwM2M_DataSamples_DB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_cleanUp" class=ISymbol>f_LwM2M_DataSamples_DB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undget><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_get" class=ISymbol>f_LwM2M_DataSamples_DB_get</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_init" class=ISymbol>f_LwM2M_DataSamples_DB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undDataSamples_undDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_DataSamples_DB_lookUp" class=ISymbol>f_LwM2M_DataSamples_DB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxBind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxBind" class=ISymbol>f_LwM2M_eCtxBind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxReset><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxReset" class=ISymbol>f_LwM2M_eCtxReset</a></div></div><div class=SRResult id=SR_f_undLwM2M_undeCtxUnbind><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_eCtxUnbind" class=ISymbol>f_LwM2M_eCtxUnbind</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_cleanUp" class=ISymbol>f_LwM2M_ObjectDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObject" class=ISymbol>f_LwM2M_ObjectDB_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_createObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObject" class=ISymbol>f_LwM2M_ObjectDB_getObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectIdx><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectIdx" class=ISymbol>f_LwM2M_ObjectDB_getObjectIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectInstance" class=ISymbol>f_LwM2M_ObjectDB_getObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetObjectPaths><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getObjectPaths" class=ISymbol>f_LwM2M_ObjectDB_getObjectPaths</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResource" class=ISymbol>f_LwM2M_ObjectDB_getResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undgetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_getResourceValue" class=ISymbol>f_LwM2M_ObjectDB_getResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_init" class=ISymbol>f_LwM2M_ObjectDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResource" class=ISymbol>f_LwM2M_ObjectDB_setResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceObserved><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceObserved" class=ISymbol>f_LwM2M_ObjectDB_setResourceObserved</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectDB_undsetResourceValue><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectDB_setResourceValue" class=ISymbol>f_LwM2M_ObjectDB_setResourceValue</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undadd><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_add" class=ISymbol>f_LwM2M_ObjectSpecificationDB_add</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undcleanUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_cleanUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_cleanUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undfillInOmaSpecs><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs" class=ISymbol>f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undgetResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_getResourceSpecification" class=ISymbol>f_LwM2M_ObjectSpecificationDB_getResourceSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undinit><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_init" class=ISymbol>f_LwM2M_ObjectSpecificationDB_init</a></div></div><div class=SRResult id=SR_f_undLwM2M_undObjectSpecificationDB_undlookUp><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_ObjectSpecificationDB_lookUp" class=ISymbol>f_LwM2M_ObjectSpecificationDB_lookUp</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undcheckSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_checkSpecification" class=ISymbol>f_LwM2M_Resource_checkSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_unddecode><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Decoders-ttcn.html#f_LwM2M_Resource_decode" class=ISymbol>f_LwM2M_Resource_decode</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undgetSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_getSpecification" class=ISymbol>f_LwM2M_Resource_getSpecification</a></div></div><div class=SRResult id=SR_f_undLwM2M_undResource_undsetNextDataSample><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_Resource_setNextDataSample" class=ISymbol>f_LwM2M_Resource_setNextDataSample</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforIds><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forIds" class=ISymbol>f_LwM2M_resourceHash_forIds</a></div></div><div class=SRResult id=SR_f_undLwM2M_undresourceHash_undforResource><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Functions-ttcn.html#f_LwM2M_resourceHash_forResource" class=ISymbol>f_LwM2M_resourceHash_forResource</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcleanupDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_cleanupDevice" class=ISymbol>f_LwM2M_step_cleanupDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createDevice" class=ISymbol>f_LwM2M_step_createDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObject><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObject" class=ISymbol>f_LwM2M_step_createObject</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undcreateObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_createObjectInstance" class=ISymbol>f_LwM2M_step_createObjectInstance</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleExecuteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleExecuteRequest" class=ISymbol>f_LwM2M_step_handleExecuteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleReadRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleReadRequest" class=ISymbol>f_LwM2M_step_handleReadRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undhandleWriteRequest><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_handleWriteRequest" class=ISymbol>f_LwM2M_step_handleWriteRequest</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyIntIdx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byIntIdx" class=ISymbol>f_LwM2M_step_loadTemplate_byIntIdx</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undloadTemplate_undbyStringId><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_loadTemplate_byStringId" class=ISymbol>f_LwM2M_step_loadTemplate_byStringId</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undlogDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_logDevice" class=ISymbol>f_LwM2M_step_logDevice</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsend><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_send" class=ISymbol>f_LwM2M_step_send</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsendNotificationForObservedResources><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_sendNotificationForObservedResources" class=ISymbol>f_LwM2M_step_sendNotificationForObservedResources</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undatomic><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_atomic" class=ISymbol>f_LwM2M_step_setBlock1Handling_atomic</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBlock1Handling_undstateless><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBlock1Handling_stateless" class=ISymbol>f_LwM2M_step_setBlock1Handling_stateless</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetBootstrapState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setBootstrapState" class=ISymbol>f_LwM2M_step_setBootstrapState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetContentFormats><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setContentFormats" class=ISymbol>f_LwM2M_step_setContentFormats</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateResult><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateResult" class=ISymbol>f_LwM2M_step_setFirmwareUpdateResult</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetFirmwareUpdateState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setFirmwareUpdateState" class=ISymbol>f_LwM2M_step_setFirmwareUpdateState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undsetNotRegisteredState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_setNotRegisteredState" class=ISymbol>f_LwM2M_step_setNotRegisteredState</a></div></div><div class=SRResult id=SR_f_undLwM2M_undstep_undwriteOrCreateObject_undBS><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Functions-ttcn.html#f_LwM2M_step_writeOrCreateObject_BS" class=ISymbol>f_LwM2M_step_writeOrCreateObject_BS</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undreceiveEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveEvent" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveEvent</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undreceiveMessage><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_receiveMessage" class=ISymbol>fcb_EPTF_LwM2M_Transport_receiveMessage</a></div></div><div class=SRResult id=SR_fcb_undEPTF_undLwM2M_undTransport_undsendMessage><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#fcb_EPTF_LwM2M_Transport_sendMessage" class=ISymbol>fcb_EPTF_LwM2M_Transport_sendMessage</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/GeneralL.html b/apidoc/html/search/GeneralL.html
index ea99e68..157bbdf 100644
--- a/apidoc/html/search/GeneralL.html
+++ b/apidoc/html/search/GeneralL.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_LightweightM2M_undTypes><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" class=ISymbol>LightweightM2M_Types</a></div></div><div class=SRResult id=SR_LwM2M_undBlock1_undHandling><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" class=ISymbol>LwM2M_Block1_Handling</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=ISymbol>LwM2M_DataSamples</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=ISymbol>LwM2M_DataSamples_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" class=ISymbol>LwM2M_DataSamples_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=ISymbol>LwM2M_Device</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=ISymbol>LwM2M_Device_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" class=ISymbol>LwM2M_Device_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" class=ISymbol>LwM2M_Device_State</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=ISymbol>LwM2M_EntityCtx</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=ISymbol>LwM2M_EntityCtx_DB</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" class=ISymbol>LwM2M_EntityCtx_List</a></div></div><div class=SRResult id=SR_LWM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" class=ISymbol>LWM2M_Event</a></div></div><div class=SRResult id=SR_LwM2M_undInstanceTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" class=ISymbol>LwM2M_InstanceTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=ISymbol>LwM2M_Object</a></div></div><div class=SRResult id=SR_LwM2M_undObject_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" class=ISymbol>LwM2M_Object_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=ISymbol>LwM2M_ObjectDB</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=ISymbol>LwM2M_ObjectInstance</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" class=ISymbol>LwM2M_ObjectInstance_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=ISymbol>LwM2M_ObjectSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=ISymbol>LwM2M_ObjectSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecificationDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=ISymbol>LwM2M_ObjectSpecificationDB</a></div></div><div class=SRResult id=SR_LwM2M_undOperationTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" class=ISymbol>LwM2M_OperationTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undResource><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=ISymbol>LwM2M_Resource</a></div></div><div class=SRResult id=SR_LwM2M_undResource_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=ISymbol>LwM2M_Resource_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceIdx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" class=ISymbol>LwM2M_ResourceIdx_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=ISymbol>LwM2M_ResourceSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" class=ISymbol>LwM2M_ResourceSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=ISymbol>LwM2M_ResourceValue</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=ISymbol>LwM2M_ResourceValue_List</a></div></div><div class=SRResult id=SR_LwM2M_undStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=ISymbol>LwM2M_StepCtx</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=ISymbol>LwM2M_Template</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=ISymbol>LwM2M_Template_DB</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" class=ISymbol>LwM2M_Template_List</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_LightweightM2M_undTypes><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LightweightM2M_Types" class=ISymbol>LightweightM2M_Types</a></div></div><div class=SRResult id=SR_LwM2M_undBlock1_undHandling><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" class=ISymbol>LwM2M_Block1_Handling</a></div></div><div class=SRResult id=SR_LWM2M_undBlock1_undMethod><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Block1_Method" class=ISymbol>LWM2M_Block1_Method</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=ISymbol>LwM2M_DataSamples</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=ISymbol>LwM2M_DataSamples_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" class=ISymbol>LwM2M_DataSamples_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=ISymbol>LwM2M_Device</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=ISymbol>LwM2M_Device_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" class=ISymbol>LwM2M_Device_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" class=ISymbol>LwM2M_Device_State</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=ISymbol>LwM2M_EntityCtx</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=ISymbol>LwM2M_EntityCtx_DB</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" class=ISymbol>LwM2M_EntityCtx_List</a></div></div><div class=SRResult id=SR_LWM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" class=ISymbol>LWM2M_Event</a></div></div><div class=SRResult id=SR_LWM2M_undEvent_undBlock1><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event_Block1" class=ISymbol>LWM2M_Event_Block1</a></div></div><div class=SRResult id=SR_LwM2M_undFormat_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Format_List" class=ISymbol>LwM2M_Format_List</a></div></div><div class=SRResult id=SR_LwM2M_undInstanceTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" class=ISymbol>LwM2M_InstanceTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=ISymbol>LwM2M_Object</a></div></div><div class=SRResult id=SR_LwM2M_undObject_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" class=ISymbol>LwM2M_Object_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=ISymbol>LwM2M_ObjectDB</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=ISymbol>LwM2M_ObjectInstance</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" class=ISymbol>LwM2M_ObjectInstance_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=ISymbol>LwM2M_ObjectSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=ISymbol>LwM2M_ObjectSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecificationDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=ISymbol>LwM2M_ObjectSpecificationDB</a></div></div><div class=SRResult id=SR_LwM2M_undOperationTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" class=ISymbol>LwM2M_OperationTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undResource><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=ISymbol>LwM2M_Resource</a></div></div><div class=SRResult id=SR_LwM2M_undResource_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=ISymbol>LwM2M_Resource_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceIdx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" class=ISymbol>LwM2M_ResourceIdx_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=ISymbol>LwM2M_ResourceSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" class=ISymbol>LwM2M_ResourceSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=ISymbol>LwM2M_ResourceValue</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=ISymbol>LwM2M_ResourceValue_List</a></div></div><div class=SRResult id=SR_LwM2M_undStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=ISymbol>LwM2M_StepCtx</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=ISymbol>LwM2M_Template</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=ISymbol>LwM2M_Template_DB</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" class=ISymbol>LwM2M_Template_List</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/GeneralT.html b/apidoc/html/search/GeneralT.html
index 7782314..0bab4c0 100644
--- a/apidoc/html/search/GeneralT.html
+++ b/apidoc/html/search/GeneralT.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_undenabled><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebugVerbose><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_underror><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_undwarning><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undobjectSpecifications><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undtemplates><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_undenabled><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebugVerbose><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddefaultContentFormat><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_defaultContentFormat" class=ISymbol>tsp_EPTF_LwM2M_LGen_defaultContentFormat</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_underror><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_undwarning><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undobjectSpecifications><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undtemplates><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/ModuleParametersT.html b/apidoc/html/search/ModuleParametersT.html
index 7782314..0bab4c0 100644
--- a/apidoc/html/search/ModuleParametersT.html
+++ b/apidoc/html/search/ModuleParametersT.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_undenabled><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebugVerbose><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_underror><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_undwarning><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undobjectSpecifications><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undtemplates><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Definitions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_debug" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undCoapApplibTransport_undenabled><div class=IEntry><a href="../files/EPTF_LwM2M_CoapApplibTransport_Functions-ttcn.html#tsp_EPTF_LwM2M_CoapApplibTransport_enabled" class=ISymbol>tsp_EPTF_LwM2M_CoapApplibTransport_enabled</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebug><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debug" class=ISymbol>tsp_EPTF_LwM2M_LGen_debug</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddebugVerbose><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_debugVerbose" class=ISymbol>tsp_EPTF_LwM2M_LGen_debugVerbose</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_unddefaultContentFormat><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_defaultContentFormat" class=ISymbol>tsp_EPTF_LwM2M_LGen_defaultContentFormat</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_underror><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_error" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_error</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undlog_undwarning><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_log_warning" class=ISymbol>tsp_EPTF_LwM2M_LGen_log_warning</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undobjectSpecifications><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_objectSpecifications" class=ISymbol>tsp_EPTF_LwM2M_LGen_objectSpecifications</a></div></div><div class=SRResult id=SR_tsp_undEPTF_undLwM2M_undLGen_undtemplates><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#tsp_EPTF_LwM2M_LGen_templates" class=ISymbol>tsp_EPTF_LwM2M_LGen_templates</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/apidoc/html/search/TypesL.html b/apidoc/html/search/TypesL.html
index 02c73db..33bc9fa 100644
--- a/apidoc/html/search/TypesL.html
+++ b/apidoc/html/search/TypesL.html
@@ -14,7 +14,7 @@
 
 
 
-<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_LwM2M_undBlock1_undHandling><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" class=ISymbol>LwM2M_Block1_Handling</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=ISymbol>LwM2M_DataSamples</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=ISymbol>LwM2M_DataSamples_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" class=ISymbol>LwM2M_DataSamples_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=ISymbol>LwM2M_Device</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=ISymbol>LwM2M_Device_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" class=ISymbol>LwM2M_Device_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" class=ISymbol>LwM2M_Device_State</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=ISymbol>LwM2M_EntityCtx</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=ISymbol>LwM2M_EntityCtx_DB</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" class=ISymbol>LwM2M_EntityCtx_List</a></div></div><div class=SRResult id=SR_LWM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" class=ISymbol>LWM2M_Event</a></div></div><div class=SRResult id=SR_LwM2M_undInstanceTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" class=ISymbol>LwM2M_InstanceTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=ISymbol>LwM2M_Object</a></div></div><div class=SRResult id=SR_LwM2M_undObject_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" class=ISymbol>LwM2M_Object_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=ISymbol>LwM2M_ObjectDB</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=ISymbol>LwM2M_ObjectInstance</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" class=ISymbol>LwM2M_ObjectInstance_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=ISymbol>LwM2M_ObjectSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=ISymbol>LwM2M_ObjectSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecificationDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=ISymbol>LwM2M_ObjectSpecificationDB</a></div></div><div class=SRResult id=SR_LwM2M_undOperationTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" class=ISymbol>LwM2M_OperationTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undResource><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=ISymbol>LwM2M_Resource</a></div></div><div class=SRResult id=SR_LwM2M_undResource_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=ISymbol>LwM2M_Resource_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceIdx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" class=ISymbol>LwM2M_ResourceIdx_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=ISymbol>LwM2M_ResourceSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" class=ISymbol>LwM2M_ResourceSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=ISymbol>LwM2M_ResourceValue</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=ISymbol>LwM2M_ResourceValue_List</a></div></div><div class=SRResult id=SR_LwM2M_undStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=ISymbol>LwM2M_StepCtx</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=ISymbol>LwM2M_Template</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=ISymbol>LwM2M_Template_DB</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" class=ISymbol>LwM2M_Template_List</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
+<div id=Index><div class=IPageTitle>Search Results</div><div class=SRStatus id=Loading>Loading...</div><table border=0 cellspacing=0 cellpadding=0><div class=SRResult id=SR_LwM2M_undBlock1_undHandling><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Block1_Handling" class=ISymbol>LwM2M_Block1_Handling</a></div></div><div class=SRResult id=SR_LWM2M_undBlock1_undMethod><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Block1_Method" class=ISymbol>LWM2M_Block1_Method</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples" class=ISymbol>LwM2M_DataSamples</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_DB" class=ISymbol>LwM2M_DataSamples_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDataSamples_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_DataSamples_List" class=ISymbol>LwM2M_DataSamples_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device" class=ISymbol>LwM2M_Device</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_DB" class=ISymbol>LwM2M_Device_DB</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_List" class=ISymbol>LwM2M_Device_List</a></div></div><div class=SRResult id=SR_LwM2M_undDevice_undState><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Device_State" class=ISymbol>LwM2M_Device_State</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx" class=ISymbol>LwM2M_EntityCtx</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_DB" class=ISymbol>LwM2M_EntityCtx_DB</a></div></div><div class=SRResult id=SR_LwM2M_undEntityCtx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_EntityCtx_List" class=ISymbol>LwM2M_EntityCtx_List</a></div></div><div class=SRResult id=SR_LWM2M_undEvent><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event" class=ISymbol>LWM2M_Event</a></div></div><div class=SRResult id=SR_LWM2M_undEvent_undBlock1><div class=IEntry><a href="../files/EPTF_LwM2M_Transport_Definitions-ttcn.html#LWM2M_Event_Block1" class=ISymbol>LWM2M_Event_Block1</a></div></div><div class=SRResult id=SR_LwM2M_undFormat_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Format_List" class=ISymbol>LwM2M_Format_List</a></div></div><div class=SRResult id=SR_LwM2M_undInstanceTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_InstanceTypeEnum" class=ISymbol>LwM2M_InstanceTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undObject><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object" class=ISymbol>LwM2M_Object</a></div></div><div class=SRResult id=SR_LwM2M_undObject_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_Object_List" class=ISymbol>LwM2M_Object_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectDB" class=ISymbol>LwM2M_ObjectDB</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance" class=ISymbol>LwM2M_ObjectInstance</a></div></div><div class=SRResult id=SR_LwM2M_undObjectInstance_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectInstance_List" class=ISymbol>LwM2M_ObjectInstance_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification" class=ISymbol>LwM2M_ObjectSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecification_List" class=ISymbol>LwM2M_ObjectSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undObjectSpecificationDB><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ObjectSpecificationDB" class=ISymbol>LwM2M_ObjectSpecificationDB</a></div></div><div class=SRResult id=SR_LwM2M_undOperationTypeEnum><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_OperationTypeEnum" class=ISymbol>LwM2M_OperationTypeEnum</a></div></div><div class=SRResult id=SR_LwM2M_undResource><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource" class=ISymbol>LwM2M_Resource</a></div></div><div class=SRResult id=SR_LwM2M_undResource_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_Resource_List" class=ISymbol>LwM2M_Resource_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceIdx_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceIdx_List" class=ISymbol>LwM2M_ResourceIdx_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification" class=ISymbol>LwM2M_ResourceSpecification</a></div></div><div class=SRResult id=SR_LwM2M_undResourceSpecification_undList><div class=IEntry><a href="../files/EPTF_LwM2M_Object_Definitions-ttcn.html#LwM2M_ResourceSpecification_List" class=ISymbol>LwM2M_ResourceSpecification_List</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue" class=ISymbol>LwM2M_ResourceValue</a></div></div><div class=SRResult id=SR_LwM2M_undResourceValue_undList><div class=IEntry><a href="../files/LightweightM2M_Types-ttcn.html#LwM2M_ResourceValue_List" class=ISymbol>LwM2M_ResourceValue_List</a></div></div><div class=SRResult id=SR_LwM2M_undStepCtx><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_StepCtx" class=ISymbol>LwM2M_StepCtx</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template" class=ISymbol>LwM2M_Template</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undDB><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_DB" class=ISymbol>LwM2M_Template_DB</a></div></div><div class=SRResult id=SR_LwM2M_undTemplate_undList><div class=IEntry><a href="../files/EPTF_LwM2M_LGen_Definitions-ttcn.html#LwM2M_Template_List" class=ISymbol>LwM2M_Template_List</a></div></div></table><div class=SRStatus id=Searching>Searching...</div><div class=SRStatus id=NoMatches>No Matches</div><script type="text/javascript"><!--
 document.getElementById("Loading").style.display="none";
 document.getElementById("NoMatches").style.display="none";
 var searchResults = new SearchResults("searchResults", "FramedHTML");
diff --git a/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn b/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn
index a44b885..86ae363 100644
--- a/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn
+++ b/src/EPTF_LwM2M_CoapApplibTransport_Definitions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2017-09-01
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn b/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn
index 9192003..3c34588 100644
--- a/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn
+++ b/src/EPTF_LwM2M_CoapApplibTransport_Functions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -260,7 +260,7 @@
       {
         @try
         {
-          f_decodePayload(
+          f_dec_LwM2M_Resources(
             v_event.event.atomicBlock1Finished.contentFormat, 
             pl_event.atomicBlock1Finished.content,
             v_event.event.atomicBlock1Finished.resources,
diff --git a/src/EPTF_LwM2M_LGen_Definitions.ttcn b/src/EPTF_LwM2M_LGen_Definitions.ttcn
index 93ccd20..e6529bb 100644
--- a/src/EPTF_LwM2M_LGen_Definitions.ttcn
+++ b/src/EPTF_LwM2M_LGen_Definitions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -36,6 +36,7 @@
 //    tsp_EPTF_LwM2M_LGen_debugVerbose - <tsp_EPTF_LwM2M_LGen_debugVerbose> - *boolean* - Enabled/disable verbose debug logging
 //    tsp_EPTF_LwM2M_LGen_templates - <tsp_EPTF_LwM2M_LGen_templates> - <LwM2M_Template_List> - LWM2M template definitions for sending
 //    tsp_EPTF_LwM2M_LGen_objectSpecifications - <tsp_EPTF_LwM2M_LGen_objectSpecifications> - <LwM2M_ObjectSpecification_List> - Additional smart object specifications to be loaded
+//    tsp_EPTF_LwM2M_LGen_defaultContentFormat - <tsp_EPTF_LwM2M_LGen_defaultContentFormat> - *integer* - default LwM@M payload content format
 //
 //  Events:
 //    LWM2M Register request - <c_LwM2M_eventIdx_Register>, <c_LwM2M_eventName_Register>
@@ -68,6 +69,13 @@
 //    LWM2M handle WRITE request - <f_LwM2M_step_handleWriteRequest>, <c_LwM2M_stepName_handleWriteRequest>, <c_LwM2M_stepIdx_handleWriteRequest>
 //    LWM2M handle EXECUTE request - <f_LwM2M_step_handleExecuteRequest>, <c_LwM2M_stepName_handleExecuteRequest>, <c_LwM2M_stepIdx_handleExecuteRequest>
 //    LWM2M send NOTIFICATION - <f_LwM2M_step_sendNotificationForObservedResources>, <c_LwM2M_stepName_sendNotificationForObservedResources>, <c_LwM2M_stepIdx_sendNotificationForObservedResources>
+//    LWM2M set firmware update state - <f_LwM2M_step_setFirmwareUpdateState>, <c_LwM2M_stepName_setFirmwareUpdateState>, <c_LwM2M_stepIdx_setFirmwareUpdateState>
+//    LWM2M set firmware update results - <f_LwM2M_step_setFirmwareUpdateResult>, <c_LwM2M_stepName_setFirmwareUpdateResult>, <c_LwM2M_stepIdx_setFirmwareUpdateResult>
+//    LWM2M set bootstrap state - <f_LwM2M_step_setBootstrapState>, <c_LwM2M_stepName_setBootstrapState>, <c_LwM2M_stepIdx_setBootstrapState>
+//    LWM2M set not_registered state - <f_LwM2M_step_setNotRegisteredState>, <c_LwM2M_stepName_setNotRegisteredState>, <c_LwM2M_stepIdx_setNotRegisteredState>
+//    LWM2M set block1 handling stateless - <f_LwM2M_step_setBlock1Handling_stateless>, <c_LwM2M_stepName_setBlock1Handling_stateless>, <c_LwM2M_stepIdx_setBlock1Handling_stateless>
+//    LWM2M set block1 handling atomic - <f_LwM2M_step_setBlock1Handling_atomic>, <c_LwM2M_stepName_setBlock1Handling_atomic>, <c_LwM2M_stepIdx_setBlock1Handling_atomic>
+//    LWM2M set content formats - <f_LwM2M_step_setContentFormats>, <c_LwM2M_stepName_setContentFormats>, <c_LwM2M_stepIdx_setContentFormats>
 //
 //  Class Diagram:
 //   (see EPTF_LwM2M_LGen_Definitions.classes.jpg)
@@ -167,6 +175,20 @@
   //     Empty list: {}
   ///////////////////////////////////////////////////////////
   modulepar LwM2M_ObjectSpecification_List tsp_EPTF_LwM2M_LGen_objectSpecifications := {};
+  
+  ///////////////////////////////////////////////////////////
+  //  Module parameter: tsp_EPTF_LwM2M_LGen_defaultContentFormat
+  // 
+  //  Purpose:
+  //    Setting the default content format code for encoding LwM2M payload
+  //
+  //  Type:
+  //     *integer*
+  //
+  //  Default value:
+  //     11543
+  ///////////////////////////////////////////////////////////
+  modulepar integer tsp_EPTF_LwM2M_LGen_defaultContentFormat := 11543;
 
   const integer c_LwM2M_LGen_Logging_WARNING := 0;
   const integer c_LwM2M_LGen_Logging_DEBUG := 1;
@@ -241,6 +263,8 @@
      class LwM2M_Device {
        Location registeredLocation
        LwM2M_ObjectDB objects
+       LwM2M_Block1_Handling block1Handling
+       EPTF_IntegerList contentFormats
        LwM2M_Device_State state
      }
 
@@ -358,6 +382,8 @@
      class LwM2M_Device {
        Location registeredLocation
        LwM2M_ObjectDB objects
+       LwM2M_Block1_Handling block1Handling
+       EPTF_IntegerList contentFormats
        LwM2M_Device_State state
      }
    @enduml
@@ -374,6 +400,8 @@
   //  Elements:
   //    registeredLocation  - <Location> - id acquired during registration
   //    objects  - <LwM2M_ObjectDB> - smart objects and their instances
+  //    block1Handling - <LwM2M_Block1_Handling> - block1 handling (atomic/stateless)
+  //    contentFormats - <EPTF_IntegerList> - preferred content formats for encoding payload
   //    state - <LwM2M_Device_State> - tracking the state of the device
   //
   //  Related Functions:
@@ -384,10 +412,19 @@
     Location 		   registeredLocation,
     LwM2M_ObjectDB	   objects,
     LwM2M_Block1_Handling  block1Handling,
+    LwM2M_Format_List      contentFormats,
     LwM2M_Device_State     state
   }
   
   ///////////////////////////////////////////////////////////
+  //  Type: LwM2M_Format_List
+  //
+  //  Purpose:
+  //    List of *integer*
+  ///////////////////////////////////////////////////////////
+  type record of integer LwM2M_Format_List;
+  
+  ///////////////////////////////////////////////////////////
   //  Enum: LwM2M_Device_State
   //
   //  Purpose:
@@ -425,6 +462,7 @@
     registeredLocation := {},
     objects := c_LwM2M_ObjectDB_init,
     block1Handling := STATELESS,
+    contentFormats := { 11543 },
     state := NOT_REGISTERED
   }
   
@@ -1556,5 +1594,27 @@
   ///////////////////////////////////////////////////////////
   const charstring c_LwM2M_stepName_setBlock1Handling_atomic := "LWM2M Applib: setBlock1Handling_atomic";
   
+  ///////////////////////////////////////////////////////////
+  //  const: c_LwM2M_stepIdx_setContentFormats
+  //
+  //  Purpose:
+  //    Integer constant for setting the preferred content formats
+  //
+  //  Related Function:
+  //    - <f_LwM2M_step_setContentFormats>
+  ///////////////////////////////////////////////////////////
+  const integer c_LwM2M_stepIdx_setContentFormats := 18;
+
+  ///////////////////////////////////////////////////////////
+  //  const: c_LwM2M_stepName_setContentFormats
+  //
+  //  Purpose:
+  //    Charstring constant for setting the preferred content format
+  //
+  //  Related Function:
+  //    - <f_LwM2M_step_setContentFormats>
+  ///////////////////////////////////////////////////////////
+  const charstring c_LwM2M_stepName_setContentFormats := "LWM2M Applib: setContentFormats";
+  
   const integer c_LwM2M_stepParam_createObjectInstance_DoNotAddResources := 0;
 }
diff --git a/src/EPTF_LwM2M_LGen_Functions.ttcn b/src/EPTF_LwM2M_LGen_Functions.ttcn
index f5fcf71..7c929ab 100644
--- a/src/EPTF_LwM2M_LGen_Functions.ttcn
+++ b/src/EPTF_LwM2M_LGen_Functions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -29,6 +29,7 @@
   import from EPTF_LwM2M_LGen_Definitions all;
   import from EPTF_LwM2M_Object_Definitions all;
   import from EPTF_LwM2M_Object_Functions all;
+  import from EPTF_LwM2M_Object_Decoders all;
   import from EPTF_LwM2M_Transport_Definitions all;
   import from LightweightM2M_Types all;
   
@@ -851,7 +852,8 @@
       c_LwM2M_stepIdx_setBootstrapState != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBootstrapState, refers(f_LwM2M_step_setBootstrapState)}) or
       c_LwM2M_stepIdx_setNotRegisteredState != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setNotRegisteredState, refers(f_LwM2M_step_setNotRegisteredState)}) or
       c_LwM2M_stepIdx_setBlock1Handling_stateless != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBlock1Handling_stateless, refers(f_LwM2M_step_setBlock1Handling_stateless)}) or
-      c_LwM2M_stepIdx_setBlock1Handling_atomic != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBlock1Handling_atomic, refers(f_LwM2M_step_setBlock1Handling_atomic)})
+      c_LwM2M_stepIdx_setBlock1Handling_atomic != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBlock1Handling_atomic, refers(f_LwM2M_step_setBlock1Handling_atomic)}) or
+      c_LwM2M_stepIdx_setContentFormats != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setContentFormats, refers(f_LwM2M_step_setContentFormats)})
       //c_LwM2M_stepIdx_writeOrCreateObject_BS != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_writeOrCreateObject_BS, refers(f_LwM2M_step_writeOrCreateObject_BS)})
    ){
       f_EPTF_LGenBase_log();
@@ -1133,8 +1135,7 @@
   //  Function: f_LwM2M_step_setNotRegisteredState
   //
   //  Purpose:
-  //    Test Step to set the state of the device to BOOTSTRAPPING. Consequently,
-  //  the bootstrap related LWM2M decoder functions will be used.
+  //    Test Step to set the state of the device to NOT_REGISTERED.
   //
   //  Parameters:
   //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
@@ -1285,93 +1286,138 @@
     if (ischosen(v_LwM2M_msgToProcess.pdu.Read_) and v_LwM2M_ctx.deviceIdx >= 0)
     {
       var LwM2M_Resource_List v_resources := {};
+      var integer vl_contentFormat := -1;
       var boolean vl_found := false;
 
       // Resource
-	  if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Read_.path))
+      if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Read_.path))
+      {
+        var LwM2M_Resource v_res := c_LwM2M_Resource_init;
+        f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource"));
+        vl_found := f_LwM2M_ObjectDB_getResource(
+          v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+          v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
+          v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
+          v_LwM2M_msgToProcess.pdu.Read_.path.resourceId,
+          v_res
+        );
+        if (vl_found) 
+        {
+          if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable))
 	  {
-	    var LwM2M_Resource v_res;
-	    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource"));
-	    vl_found := f_LwM2M_ObjectDB_getResource(
-  	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.resourceId,
-  	      v_res
-	    );
-	    if (vl_found) 
-	    {
-	      if (ispresent(v_LwM2M_msgToProcess.pdu.Read_.observe))
-	      {
-                f_LwM2M_ObjectDB_setResourceObserved(
-                  v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-                  v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
-                  v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
-                  v_LwM2M_msgToProcess.pdu.Read_.path.resourceId,
-                  true
-                );
-	      }
-              v_resources[sizeof(v_resources)] := v_res;
-              f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_resources));
-	    }
+            v_resources[sizeof(v_resources)] := v_res;
+            f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_resources));
+	    
+            if (ispresent(v_LwM2M_msgToProcess.pdu.Read_.observe))
+            {
+	      vl_contentFormat := 
+              f_EPTF_LwM2M_getEncodingContentFormat(
+                v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats,
+                v_LwM2M_msgToProcess.pdu.Read_.accept,
+                v_resources
+              );
+	      
+	      f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " setting resource observed with contentFormat: ", vl_contentFormat));
+	      
+              f_LwM2M_ObjectDB_setResourceObserved(
+                v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+                v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
+                v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
+                v_LwM2M_msgToProcess.pdu.Read_.path.resourceId,
+                true,
+		vl_contentFormat
+              );
+            }
 	  }
+	  else {
+            f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found, but not readable: ", v_LwM2M_msgToProcess.pdu.Read_.path));
+	  }
+        }
+      }
 
-	  // Object instance
-	  else if (f_LwM2M_ObjectPath_isObjectInstance(v_LwM2M_msgToProcess.pdu.Read_.path))
-	  {
-	    var LwM2M_ObjectInstance v_objInst;
-	    vl_found := f_LwM2M_ObjectDB_getObjectInstance(
-	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
-  	      v_objInst
-  	    );  	      	    
-  	    for (var integer i:=0; i<sizeof(v_objInst.resources); i:=i+1) {
-  	      v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]];
-  	    }
+      // Object instance
+      else if (f_LwM2M_ObjectPath_isObjectInstance(v_LwM2M_msgToProcess.pdu.Read_.path))
+      {
+        var LwM2M_ObjectInstance v_objInst := c_LwM2M_ObjectInstance_init;
+        vl_found := f_LwM2M_ObjectDB_getObjectInstance(
+          v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+          v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
+          v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId,
+          v_objInst
+        );
+	if (vl_found)
+	{
+          for (var integer i:=0; i<sizeof(v_objInst.resources); i:=i+1) {
+            if (f_LwM2M_Resource_checkSpecification(
+	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]],
+	      v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable))
+	    {	  
+              v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]];
+	    }
+          }
+	}
       }
 
       // Object
-	  else if (f_LwM2M_ObjectPath_isObject(v_LwM2M_msgToProcess.pdu.Read_.path))
+      else if (f_LwM2M_ObjectPath_isObject(v_LwM2M_msgToProcess.pdu.Read_.path))
+      {
+        var LwM2M_Object v_obj := c_LwM2M_Object_init;
+	
+        vl_found := f_LwM2M_ObjectDB_getObject(
+          v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+          v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
+	  v_obj
+	);
+	
+	if (vl_found)
+	{
+	  for (var integer v_inst:=0; v_inst<sizeof(v_obj.instances); v_inst:=v_inst+1)
 	  {
-	    var LwM2M_ObjectInstance v_objInst;
-
-	    vl_found := f_LwM2M_ObjectDB_getObjectInstance(
-	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-  	      v_LwM2M_msgToProcess.pdu.Read_.path.objectId,
-  	      0, // TODO: only for 0 object instance
-  	      v_objInst
-  	    );
-
-  	    for (var integer i:=0; i<sizeof(v_objInst.resources); i:=i+1) {
-  	      v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]];
-  	    }
+            for (var integer i:=0; i<sizeof(v_obj.instances[v_inst].resources); i:=i+1) {
+              if (f_LwM2M_Resource_checkSpecification(
+	        v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_obj.instances[v_inst].resources[i]],
+	        v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable))
+              {	  
+                v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_obj.instances[v_inst].resources[i]];
+              }
+	    }
+	  }	  
+	}
       }
 
       v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx;
       v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx;
 
-	  if (vl_found) 
-	  {
-	    //v_res.objId := -1; v_res.objInstId := -1; v_res.id := -1;
-
-	    v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init;
+      if (vl_found and sizeof(v_resources)>0)
+      {
+        if (vl_contentFormat == -1)
+	{
+          vl_contentFormat := 
+            f_EPTF_LwM2M_getEncodingContentFormat(
+              v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats,
+              v_LwM2M_msgToProcess.pdu.Read_.accept,
+              v_resources
+            );
+        }
+      
+        //v_res.objId := -1; v_res.objInstId := -1; v_res.id := -1;
+        v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init;
         v_LwM2M_msgToSend.pdu.Response.code := 205;
-        v_LwM2M_msgToSend.pdu.Response.contentFormat := 1543;
+        v_LwM2M_msgToSend.pdu.Response.contentFormat := vl_contentFormat;
         v_LwM2M_msgToSend.pdu.Response.resources := v_resources;
-	  }
-	  else
-	  {
+      }
+      else
+      {
         v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init;
         v_LwM2M_msgToSend.pdu.Response.code := 404;
         v_LwM2M_msgToSend.pdu.Response.contentFormat := omit;
         v_LwM2M_msgToSend.pdu.Response.resources := {};
       }
 
-          f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend);
-	  vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);
-	}	
-	else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not read pdu, or no device available, returning")); }
+      f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend);
+      vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);
+    }	
+    else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not read pdu, or no device available, returning")); }
   }
   
   ///////////////////////////////////////////////////////////
@@ -1420,34 +1466,51 @@
 
         if (vl_found)
         {
-          f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: true"));
-
           if (not vl_block1)
           {
-            // Value type matching
-            if (ischosen(v_res.val.boolValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.boolValue))
-            { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
-            else if (ischosen(v_res.val.strValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.strValue))
-            { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
-            else if (ischosen(v_res.val.floatValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue))
-            { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
-            else if (ischosen(v_res.val.intValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue))
-            { v_res.val.intValue := float2int(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue); vl_typeMatched := true; }
-            else if (ischosen(v_res.val.opaqueValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue))
-            { v_res.val.opaqueValue := v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue; vl_typeMatched := true; }
+	    // Decoding the incoming value if needed e.g. plain, opaque
+	    if (v_LwM2M_msgToProcess.pdu.Write.contentFormat == 0 or v_LwM2M_msgToProcess.pdu.Write.contentFormat == 42)
+	    {
+	      var LwM2M_ResourceSpecification v_spec;
+              if (f_LwM2M_Resource_getSpecification(v_res, v_LwM2M_ObjectSpecificationDB, v_spec))
+              {
+                f_LwM2M_Resource_decode(v_LwM2M_msgToProcess.pdu.Write.resources[0], v_spec, v_LwM2M_msgToProcess.pdu.Write.contentFormat);
+                f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource decoded: ", v_res.val));
+              }
+              else {
+                f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId, " no spec found for: ", v_LwM2M_msgToProcess))
+              }
+	    }
+	      
+            if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Writeable))
+	    {
+              // Value type matching
+              if (ischosen(v_res.val.boolValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.boolValue))
+              { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
+              else if (ischosen(v_res.val.strValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.strValue))
+              { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
+              else if (ischosen(v_res.val.floatValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue))
+              { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
+              else if (ischosen(v_res.val.intValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.intValue))
+              { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
+              else if (ischosen(v_res.val.opaqueValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue))
+              { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; }
 
-            if (vl_typeMatched)
-            {
-              f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: true"));
+              if (vl_typeMatched)
+              {
+                f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: true"));
 
-              f_LwM2M_ObjectDB_setResourceValue(
-                v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-                v_LwM2M_msgToProcess.pdu.Write.path.objectId,
-                v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId,
-                v_LwM2M_msgToProcess.pdu.Write.path.resourceId,
-                v_res.val
-              );
-            }
+                f_LwM2M_ObjectDB_setResourceValue(
+                  v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+                  v_LwM2M_msgToProcess.pdu.Write.path.objectId,
+                  v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId,
+                  v_LwM2M_msgToProcess.pdu.Write.path.resourceId,
+                  v_res.val
+                );
+              }
+	      else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: false")); }
+	    }
+	    else { f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId, " resource not writeable")); }
           }
           else // if block1 Write
           {
@@ -1519,35 +1582,66 @@
     {
       var LwM2M_Resource v_res;
       var boolean vl_found := false;
-	  if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Execute.path))
-	  {
-	    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource"));
-	    vl_found := f_LwM2M_ObjectDB_getResource(
-  	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
-  	      v_LwM2M_msgToProcess.pdu.Execute.path.objectId,
-  	      v_LwM2M_msgToProcess.pdu.Execute.path.objectInstanceId,
-  	      v_LwM2M_msgToProcess.pdu.Execute.path.resourceId,
-  	      v_res
-	    );
-	    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res));
+      var boolean vl_succExecute := false;
+      if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Execute.path))
+      {
+        f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource"));
+          vl_found := f_LwM2M_ObjectDB_getResource(
+            v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
+            v_LwM2M_msgToProcess.pdu.Execute.path.objectId,
+            v_LwM2M_msgToProcess.pdu.Execute.path.objectInstanceId,
+            v_LwM2M_msgToProcess.pdu.Execute.path.resourceId,
+            v_res
+          );
+        f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res));
+
+        if (vl_found)
+	{
+          var LwM2M_ResourceSpecification v_spec;
+          if (f_LwM2M_ObjectSpecificationDB_getResourceSpecification(
+                v_LwM2M_ObjectSpecificationDB,
+                v_LwM2M_msgToProcess.pdu.Execute.path.objectId,
+                v_LwM2M_msgToProcess.pdu.Execute.path.resourceId,
+                v_spec))
+          {
+	    if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Executable))
+	    {
+              //action("executed: ", v_res);
 	    
-	    action("executed: ", v_res);
-	    
+              v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx;
+              v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx;
+        
+              v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init;
+              v_LwM2M_msgToSend.pdu.Response.code := 204;
+              f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend);
+  	      vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);
+	      vl_succExecute := true;
+	      
+              if (v_LwM2M_msgToProcess.pdu.Execute.path.objectId == 5 and v_LwM2M_msgToProcess.pdu.Execute.path.resourceId == 2) 
+              {
+                f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_ExecuteFWUpdate, v_LwM2M_msgToProcess.eIdx, v_LwM2M_msgToProcess.fsmIdx, {});
+              }
+	    }
+	    else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource is not executable")); }
+	  }
+	  else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " could not get resource specification")); }
+	}
+	else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " could not find resource instance"));	}
+      }
+      else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Only resource can be executed, ignoring request")); }
+      
+      if (not vl_succExecute)
+      {
         v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx;
         v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx;
         
         v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init;
-        v_LwM2M_msgToSend.pdu.Response.code := 204;
-        if (v_LwM2M_msgToProcess.pdu.Execute.path.objectId == 5 and v_LwM2M_msgToProcess.pdu.Execute.path.resourceId == 2) 
-        {
-          f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_ExecuteFWUpdate, v_LwM2M_msgToProcess.eIdx, v_LwM2M_msgToProcess.fsmIdx, {});
-        }
-            f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend);
-  	    vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);	    
-	  }
-	  else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Only resource can be executed, ignoring request")); }
-	}
-	else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not execute pdu, or no device available, returning")); }
+        v_LwM2M_msgToSend.pdu.Response.code := 404;
+        f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend);
+        vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);
+      }
+    }
+    else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not execute pdu, or no device available, returning")); }
   }
 
   ///////////////////////////////////////////////////////////
@@ -1640,6 +1734,37 @@
     f_LwM2M_ObjectDB_setResourceValue(v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 5, 0, 5, vl_res);
     }
   }
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_LwM2M_step_setContentFormats
+  //
+  //  Purpose:
+  //    Test Step to set the preferred encoding content format for a <LwM2M_Device>
+  //
+  //  Parameters:
+  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
+  //    pl_ptr.refContext.fRefArgs[0] - *in integer* - content format code
+  //
+  //  Related Constants:
+  //    - <c_LwM2M_stepIdx_createObject>
+  //    - <c_LwM2M_stepName_createObject>
+  ///////////////////////////////////////////////////////////
+  function f_LwM2M_step_setContentFormats(in EPTF_LGenBase_TestStepArgs pl_ptr)
+  runs on EPTF_LwM2M_LGen_CT
+  {    
+    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
+    f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx);
+    
+    if (v_LwM2M_ctx.deviceIdx >= 0)
+    {
+      if (sizeof(pl_ptr.refContext.fRefArgs) > 0 and v_LwM2M_ctx.deviceIdx >= 0)
+      {
+        v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats := 
+	  pl_ptr.refContext.fRefArgs;
+      }
+      else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("parameter is not set for test step")); }
+    }
+  }
 
   ///////////////////////////////////////////////////////////
   //  Function: f_EPTF_LwM2M_setStepCtx
@@ -1873,8 +1998,15 @@
 	  v_LwM2M_msgToSend.pdu := c_LWM2M_Notification_init;
 	  v_LwM2M_msgToSend.pdu.Notification.path := { v_res.objId, v_res.objInstId, v_res.id };
 	  v_LwM2M_msgToSend.pdu.Notification.code := 205;
-	  v_LwM2M_msgToSend.pdu.Notification.contentFormat := 1543; // JSON format
-	  v_LwM2M_msgToSend.pdu.Notification.resources := { v_res }
+	  v_LwM2M_msgToSend.pdu.Notification.resources := { v_res }	  
+	  if (ispresent(v_res.contentFormat))
+	  {
+ 	    v_LwM2M_msgToSend.pdu.Notification.contentFormat := v_res.contentFormat;
+	  }
+	  else
+	  {
+            v_LwM2M_msgToSend.pdu.Notification.contentFormat := tsp_EPTF_LwM2M_LGen_defaultContentFormat;
+	  }	  
 	  f_LwM2M_step_send(pl_ptr);
     }
   }
@@ -2004,6 +2136,17 @@
     return false;
   }
 
+  ///////////////////////////////////////////////////////////
+  //  Function: f_EPTF_LwM2M_updateMessageStatistics
+  //
+  //  Purpose:
+  //    Updates the message statistics based on the incoming PDU
+  //
+  //  Parameters:
+  //    p_stats - *inout* <EPTF_LwM2M_Message_Statistics> - the updated statistics
+  //    p_pdu - *in* <EPTF_LwM2M_PDU> - the incoming PDU
+  //  
+  ///////////////////////////////////////////////////////////
   function f_EPTF_LwM2M_updateMessageStatistics(inout EPTF_LwM2M_Message_Statistics p_stats, in EPTF_LwM2M_PDU p_pdu)
   {
     if (ischosen(p_pdu.pdu.Register)) { p_stats.noRegister := p_stats.noRegister + 1 }
@@ -2021,4 +2164,98 @@
     else if (ischosen(p_pdu.pdu.Create)) { p_stats.noCreate := p_stats.noCreate + 1 }
     else if (ischosen(p_pdu.pdu.Delete)) { p_stats.noDelete := p_stats.noDelete + 1 }
   }
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_EPTF_LwM2M_getEncodingContentFormat
+  //
+  //  Purpose:
+  //    Negotiates an encoding format based on this side's preferred, the other side's accepted
+  //    and the list of resources to be encoded
+  //
+  //  Parameters:
+  //    p_preferred - *in* <LwM2M_Format_List> - this side's preferred format
+  //    p_accepted - *in* <Integer_List> - the other side's accepted list
+  //    p_resources - *in* <LwM2M_Resource_List> - resources to be encoded
+  //
+  //  Returns:
+  //    *integer* - the negotiated content format
+  //  
+  ///////////////////////////////////////////////////////////
+  function f_EPTF_LwM2M_getEncodingContentFormat(
+    in LwM2M_Format_List   p_preferred,
+    in Integer_List        p_accepted,
+    in LwM2M_Resource_List p_resources
+  )
+  return integer
+  {
+    for (var integer i:=0; i<sizeof(p_preferred); i:=i+1)
+    {
+      if (f_EPTF_LwM2M_isInList(p_preferred[i], p_accepted))
+      {
+        if (f_EPTF_LwM2M_canEncode(p_preferred[i], p_resources))
+	{
+	  return p_preferred[i];
+	}
+      }
+    }
+    
+    return tsp_EPTF_LwM2M_LGen_defaultContentFormat;
+  }
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_EPTF_LwM2M_canEncode
+  //
+  //  Purpose:
+  //    Finds out if a list of resources can be encoded with a certain content format
+  //
+  //  Parameters:
+  //    p_code - *in integer* - content format code
+  //    p_resources - *in* <LwM2M_Resource_List> - resources to be encoded
+  //
+  //  Returns:
+  //    *boolean* - true if they can be encoded with that content format
+  //  
+  ///////////////////////////////////////////////////////////
+  function f_EPTF_LwM2M_canEncode(in integer p_code, in LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    // LwM2M JSON
+    if (p_code == 11543) { return true; }
+    
+    // SenML JSON
+    else if (p_code == 110) { return true; }
+    
+    // TLV encode is not yet supported in codec
+    //if (p_code == 11542) { return true; }
+    
+    // Plain Text
+    else if (p_code == 0)
+    {
+      if (
+        sizeof(p_resources)==1 and 
+	(ischosen(p_resources[0].val.intValue) or ischosen(p_resources[0].val.floatValue) or ischosen(p_resources[0].val.strValue))
+      )
+      { return true; }
+      else { return false; }
+    }
+    
+    // Opaque
+    else if (p_code == 42)
+    {
+      if (sizeof(p_resources)==1 and ischosen(p_resources[0].val.opaqueValue)) { return true; }
+      else { return false; }
+    }
+    
+    return false;
+  }
+  
+  function f_EPTF_LwM2M_isInList(in integer p_i, in Integer_List p_list)
+  return boolean
+  {
+    for (var integer i:=0; i<sizeof(p_list); i:=i+1)
+    {
+      if (p_i == p_list[i]) { return true; }
+    }
+    return false;
+  }
 }
diff --git a/src/EPTF_LwM2M_Object_Decoders.ttcn b/src/EPTF_LwM2M_Object_Decoders.ttcn
new file mode 100644
index 0000000..125a2d6
--- /dev/null
+++ b/src/EPTF_LwM2M_Object_Decoders.ttcn
@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2020 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v2.0
+// which accompanies this distribution, and is available at
+// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+///////////////////////////////////////////////////////////////////////////////
+//  File:               EPTF_LwM2M_Object_Decoders.ttcn
+//  Description:
+//  Rev:                R1A
+//  Prodnr:             CNL 113 859
+//  Updated:            2020-03-04
+//  Contact:            http://ttcn.ericsson.se
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////
+//  Module: EPTF_LwM2M_Object_Definitions
+// 
+//  Purpose:
+//    This module contains the smart object decoder functions
+//
+///////////////////////////////////////////////////////////////
+module EPTF_LwM2M_Object_Decoders
+{
+  import from EPTF_LwM2M_Object_Definitions all;
+  import from LightweightM2M_Types all;
+  import from TCCConversion_Functions all;  
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_LwM2M_Resource_decode
+  //
+  //  Purpose:
+  //    Decodes a resource based on a contnet format and its spceification
+  //
+  //  Parameters:
+  //    p_res - *inout* <LwM2M_Resource> - the resource to be decoded (it will be updated)
+  //    p_spec - *in* <LwM2M_ResourceSpecification> - the specification of the resource
+  //    p_contentFormat - *in integer* - the content format code
+  //
+  //  Related Type:
+  //    <LwM2M_Resource>
+  ///////////////////////////////////////////////////////////
+  function f_LwM2M_Resource_decode(
+    inout LwM2M_Resource p_res,
+    in LwM2M_ResourceSpecification p_spec,
+    in integer p_contentFormat
+  )
+  return boolean
+  {
+    @try
+    {
+      // Plain text
+      if (p_contentFormat == 0 and ischosen(p_res.val.strValue))
+      {
+        var charstring v_incoming := p_res.val.strValue;
+        if (p_spec.type_ == STRING)
+        {
+          // No change needed
+          return true;
+        }
+        else if (p_spec.type_ == FLOAT)
+        {
+          p_res.val.floatValue := str2float(v_incoming);
+          return true;
+        }
+        else if (p_spec.type_ == INTEGER)
+        {
+          p_res.val.intValue := str2int(v_incoming);
+          return true;
+        }
+        else if (p_spec.type_ == OPAQUE)
+        {
+          p_res.val.opaqueValue := str2oct(v_incoming);
+          return true;
+        }
+        return false;
+      }
+    
+      // Opaque
+      else if (p_contentFormat == 42 and ischosen(p_res.val.opaqueValue))
+      {
+        if (p_spec.type_ == OPAQUE)
+        {
+          // No change needed
+          return true;
+        }
+      }
+    }
+    @catch(err) {}
+    
+    return false;
+  }
+}
diff --git a/src/EPTF_LwM2M_Object_Definitions.ttcn b/src/EPTF_LwM2M_Object_Definitions.ttcn
index 6f2826c..2bf9600 100644
--- a/src/EPTF_LwM2M_Object_Definitions.ttcn
+++ b/src/EPTF_LwM2M_Object_Definitions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2017-09-01
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -102,6 +102,7 @@
        f_LwM2M_ObjectSpecificationDB_cleanUp(inout LwM2M_ObjectSpecificationDB p_db)
        f_LwM2M_ObjectSpecificationDB_add(inout LwM2M_ObjectSpecificationDB p_db, LwM2M_ObjectSpecification p_spec)
        f_LwM2M_ObjectSpecificationDB_lookUp(in LwM2M_ObjectSpecificationDB p_db, in integer p_objId)
+       f_LwM2M_ObjectSpecificationDB_getResourceSpecification(LwM2M_ObjectSpecificationDB p_spec_db, integer p_objId, integer p_resId, inout LwM2M_ResourceSpecification p_spec)
        f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(inout LwM2M_ObjectSpecificationDB p_db)
      }
      LwM2M_ObjectSpecificationDB "1" --> "*\n.specs[]" LwM2M_ObjectSpecification
@@ -332,6 +333,7 @@
        f_LwM2M_ObjectSpecificationDB_cleanUp(inout LwM2M_ObjectSpecificationDB p_db)
        f_LwM2M_ObjectSpecificationDB_add(inout LwM2M_ObjectSpecificationDB p_db, LwM2M_ObjectSpecification p_spec)
        f_LwM2M_ObjectSpecificationDB_lookUp(in LwM2M_ObjectSpecificationDB p_db, in integer p_objId)
+       f_LwM2M_ObjectSpecificationDB_getResourceSpecification(LwM2M_ObjectSpecificationDB p_spec_db, integer p_objId, integer p_resId, inout LwM2M_ResourceSpecification p_spec)
        f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(inout LwM2M_ObjectSpecificationDB p_db)
      }
    @enduml
@@ -355,6 +357,7 @@
   //    - <f_LwM2M_ObjectSpecificationDB_cleanUp> (*inout* <LwM2M_ObjectSpecificationDB> p_db)
   //    - <f_LwM2M_ObjectSpecificationDB_add> (*inout* <LwM2M_ObjectSpecificationDB> p_db, <LwM2M_ObjectSpecification> p_spec)
   //    - <f_LwM2M_ObjectSpecificationDB_lookUp> (*in* <LwM2M_ObjectSpecificationDB> p_db, *in integer* p_objId)
+  //    - <f_LwM2M_ObjectSpecificationDB_getResourceSpecification> (<LwM2M_ObjectSpecificationDB> p_spec_db, *integer* p_objId, *integer* p_resId, *inout* <LwM2M_ResourceSpecification> p_spec)
   //    - <f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs> (*inout* <LwM2M_ObjectSpecificationDB> p_db)
   ///////////////////////////////////////////////////////////
   type record LwM2M_ObjectSpecificationDB
@@ -1164,11 +1167,11 @@
       },
       {
         id := 3,
-        name := "Uncertainty",
+        name := "Radius",
         operations := R,
         instancetype := SINGLE,
         mandatory := false,
-        type_ := STRING,
+        type_ := FLOAT,
         range := "",
         units := "m",
         description := ""
@@ -1591,4 +1594,43 @@
     hashRef := -1
   }
   
+  template LwM2M_ResourceSpecification t_LwM2M_ResourceSpecification_Readable :=
+  {
+    id := ?,
+    name := ?,
+    operations := (R, RW, RE, RWE),
+    instancetype := ?,
+    mandatory := ?,
+    type_ := ?,
+    range := ?,
+    units := ?,
+    description := ?
+  }
+  
+  template LwM2M_ResourceSpecification t_LwM2M_ResourceSpecification_Writeable :=
+  {
+    id := ?,
+    name := ?,
+    operations := (W, RW, RWE),
+    instancetype := ?,
+    mandatory := ?,
+    type_ := ?,
+    range := ?,
+    units := ?,
+    description := ?
+  }
+  
+  template LwM2M_ResourceSpecification t_LwM2M_ResourceSpecification_Executable :=
+  {
+    id := ?,
+    name := ?,
+    operations := (E, RE),
+    instancetype := ?,
+    mandatory := ?,
+    type_ := ?,
+    range := ?,
+    units := ?,
+    description := ?
+  }
+  
 }
diff --git a/src/EPTF_LwM2M_Object_Functions.ttcn b/src/EPTF_LwM2M_Object_Functions.ttcn
index cefc5b8..1f1ff8d 100644
--- a/src/EPTF_LwM2M_Object_Functions.ttcn
+++ b/src/EPTF_LwM2M_Object_Functions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2017-09-01
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -119,6 +119,50 @@
       return vl_idx;
     }
     return -1;
+  }  
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_LwM2M_ObjectSpecificationDB_getResourceSpecification
+  //
+  //  Purpose:
+  //    Retrieves a <LwM2M_ResourceSpecification> element in the <LwM2M_ObjectSpecificationDB> database
+  //
+  //  Parameters:
+  //    p_spec_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
+  //    p_objId - *integer* - obj id of the <LwM2M_ResourceSpecification> to be retrieved
+  //    p_resId - *integer* - resource id of the <LwM2M_ResourceSpecification> to be retrieved
+  //    p_spec - *inout* <LwM2M_ResourceSpecification> - the returned specification
+  //
+  //  Returns:
+  //    *boolean* - true, in case the specification was found
+  //
+  //  Related Type:
+  //    <LwM2M_ObjectSpecificationDB>
+  ///////////////////////////////////////////////////////////
+  function f_LwM2M_ObjectSpecificationDB_getResourceSpecification(
+    LwM2M_ObjectSpecificationDB p_spec_db,
+    integer p_objId,
+    integer p_resId,
+    inout LwM2M_ResourceSpecification p_spec
+  )
+  return boolean
+  {
+    if (p_objId >=0 and p_resId >= 0)
+    {
+      var integer p_objSpecIdx := f_LwM2M_ObjectSpecificationDB_lookUp(p_spec_db, p_objId);
+      if (p_objSpecIdx >=0)
+      {
+        for (var integer i:=0; i<sizeof(p_spec_db.specs[p_objSpecIdx].resourcedefs); i:=i+1)
+        {
+          if (p_spec_db.specs[p_objSpecIdx].resourcedefs[i].id == p_resId)
+          {
+            p_spec := p_spec_db.specs[p_objSpecIdx].resourcedefs[i];
+	    return true;
+          }
+	}
+      }
+    }
+    return false;
   }
   
   ///////////////////////////////////////////////////////////
@@ -316,6 +360,8 @@
           for (var integer i:=0; i<sizeof(p_spec_db.specs[vl_objSpecIdx].resourcedefs); i:=i+1)
           {
 	    v_res := f_LwM2M_createResource(p_db.objs[vl_objIdx].instances[vl_objInstIdx], p_spec_db.specs[vl_objSpecIdx].resourcedefs[i]);
+	    v_res.spec.objSpecIdx := vl_objSpecIdx;
+	    v_res.spec.resSpecIdx := i;
 	    f_LwM2M_ObjectDB_addResource(p_db, v_res);
 	  }
 	}
@@ -535,6 +581,7 @@
   //    p_objInstId - *in integer* - object instance id
   //    p_resourceId - *in integer* - resource id
   //    p_observed - *in boolean* - observation flag
+  //    p_contentFormat - *in integer optional* - preferred content format
   //
   //  Returns:
   //    boolean - if the instance was found
@@ -543,13 +590,21 @@
   //    <LwM2M_ObjectDB>
   ///////////////////////////////////////////////////////////
   function f_LwM2M_ObjectDB_setResourceObserved(inout LwM2M_ObjectDB p_db, 
-    in integer p_objId, in integer p_objInstId, in integer p_resourceId, in boolean p_observed)
+    in integer p_objId, in integer p_objInstId, in integer p_resourceId, in boolean p_observed, in template integer p_contentFormat := omit)
   return boolean
   {
     var integer vl_resIdx;
     if (f_EPTF_str2int_HashMap_Find(p_db.resHashRef, f_LwM2M_resourceHash_forIds(p_objId, p_objInstId, p_resourceId), vl_resIdx))
     {
       p_db.resources[vl_resIdx].observed := p_observed;
+      if (ispresent(p_contentFormat))
+      {
+        p_db.resources[vl_resIdx].contentFormat := valueof(p_contentFormat);
+      }
+      else
+      {
+        p_db.resources[vl_resIdx].contentFormat := omit;
+      }
       return true;
     }
     return false;
@@ -666,7 +721,7 @@
     v_ret.objId := p_oi.objId;
     v_ret.objInstId := p_oi.id;
 	  
-    if (p_spec.type_ == FLOAT) {
+    if (p_spec.type_ == FLOAT or p_spec.type_ == TIME) {
       v_ret.val.floatValue := 0.0;
     }
     else if (p_spec.type_ == INTEGER) {
@@ -686,6 +741,70 @@
   }
   
   ///////////////////////////////////////////////////////////
+  //  Function: f_LwM2M_Resource_getSpecification
+  //
+  //  Purpose:
+  //    Function to look up the specification of a <LwM2M_Resource> instance
+  //
+  //  Parameters:
+  //    p_res - *in* <LwM2M_Resource> - the resource
+  //    p_spec_db - *in* <LwM2M_ObjectSpecificationDB> - object specification database
+  //    p_spec - *inout* <LwM2M_ResourceSpecification> - resource specification for the instantiation
+  //
+  //  Returns:
+  //    *boolean* - true if the specification was found
+  //
+  //  Related Type:
+  //    <LwM2M_Resource>
+  ///////////////////////////////////////////////////////////
+  function f_LwM2M_Resource_getSpecification(in LwM2M_Resource p_res, in LwM2M_ObjectSpecificationDB p_spec_db, inout LwM2M_ResourceSpecification p_spec)
+  return boolean
+  {
+    if (p_res.spec.objSpecIdx >=0 and sizeof(p_spec_db.specs) > p_res.spec.objSpecIdx)
+    {
+      if (p_res.spec.resSpecIdx >= 0 and sizeof(p_spec_db.specs[p_res.spec.objSpecIdx].resourcedefs) > p_res.spec.resSpecIdx)
+      {
+        p_spec := p_spec_db.specs[p_res.spec.objSpecIdx].resourcedefs[p_res.spec.resSpecIdx]
+	return true;
+      }
+    }
+    return false;
+  }
+  
+  ///////////////////////////////////////////////////////////
+  //  Function: f_LwM2M_Resource_checkSpecification
+  //
+  //  Purpose:
+  //    Function to check the specification of a <LwM2M_Resource> instance against a template
+  //
+  //  Parameters:
+  //    p_res - *in* <LwM2M_Resource> - the resource
+  //    p_spec_db - *in* <LwM2M_ObjectSpecificationDB> - object specification database
+  //    p_spec - *in* <LwM2M_ResourceSpecification> - resource specification for the instantiation
+  //
+  //  Returns:
+  //    *boolean* - true if the specifications were matching
+  //
+  //  Related Type:
+  //    <LwM2M_Resource>
+  ///////////////////////////////////////////////////////////
+  function f_LwM2M_Resource_checkSpecification(in LwM2M_Resource p_res, in LwM2M_ObjectSpecificationDB p_spec_db, template LwM2M_ResourceSpecification p_spec)
+  return boolean
+  {
+    if (p_res.spec.objSpecIdx >=0 and sizeof(p_spec_db.specs) > p_res.spec.objSpecIdx)
+    {
+      if (p_res.spec.resSpecIdx >= 0 and sizeof(p_spec_db.specs[p_res.spec.objSpecIdx].resourcedefs) > p_res.spec.resSpecIdx)
+      {
+        if (match(p_spec_db.specs[p_res.spec.objSpecIdx].resourcedefs[p_res.spec.resSpecIdx], p_spec))
+	{
+	  return true;
+	}
+      }
+    }
+    return false;
+  }
+ 
+  ///////////////////////////////////////////////////////////
   //  Function: f_LwM2M_Resource_setNextDataSample
   //
   //  Purpose:
diff --git a/src/EPTF_LwM2M_Transport_Definitions.ttcn b/src/EPTF_LwM2M_Transport_Definitions.ttcn
index 0869473..689c522 100644
--- a/src/EPTF_LwM2M_Transport_Definitions.ttcn
+++ b/src/EPTF_LwM2M_Transport_Definitions.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -130,6 +130,18 @@
     LWM2M_Event_Block1  atomicBlock1Finished
   }
 
+  ///////////////////////////////////////////////////////////
+  //  Type: LWM2M_Event_Block1
+  //
+  //  Purpose:
+  //    Blcok1 event descriptor
+  //
+  //  Elements:
+  //    path - <ObjectPath> - path uri
+  //    method - <LWM2M_Block1_Method> - method of the request
+  //    contentFormat - integer - content format code
+  //    resources - <LwM2M_Resource_List> - resource list
+  ///////////////////////////////////////////////////////////
   type record LWM2M_Event_Block1
   {
     ObjectPath	        path,
@@ -138,6 +150,16 @@
     LwM2M_Resource_List resources
   }
 
+  ///////////////////////////////////////////////////////////
+  //  Enum: LWM2M_Block1_Method
+  //
+  //  Purpose:
+  //    Block1 method types
+  //
+  //  Elements:
+  //    - UNMAPPED
+  //    - WRITE
+  ///////////////////////////////////////////////////////////
   type enumerated LWM2M_Block1_Method
   {
     UNMAPPED,
diff --git a/src/LWM2M_JSON_EncDec.ttcn b/src/LWM2M_JSON_EncDec.ttcn
new file mode 100644
index 0000000..43f99ef
--- /dev/null
+++ b/src/LWM2M_JSON_EncDec.ttcn
@@ -0,0 +1,407 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2020 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v2.0
+// which accompanies this distribution, and is available at
+// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+///////////////////////////////////////////////////////////////////////////////
+//  File:               LWM2M_JSON_EncDec.ttcn
+//  Description:
+//  Rev:                R1A
+//  Prodnr:             CNL 113 859
+//  Updated:            2020-03-04
+//  Contact:            http://ttcn.ericsson.se
+///////////////////////////////////////////////////////////////////////////////
+module LWM2M_JSON_EncDec
+{
+  import from LWM2M_JSON_Types all;
+  import from LightweightM2M_Types all;
+  import from TCCConversion_Functions all;
+
+  modulepar boolean tsp_LWM2M_JSON_EncDec_debug := false;
+  const boolean c_LWM2M_JSON_debugSwitch := false;
+
+  external function f_enc_LwM2M_JSON_Resources(in LwM2M_JSON_Resources p_res) return octetstring
+  with { extension "prototype(convert) encode(JSON) printing(pretty)" }
+	
+  external function f_dec_LwM2M_JSON_Resources(in octetstring p_res) return LwM2M_JSON_Resources
+  with { extension "prototype(convert) decode(JSON)" }
+  
+  external function f_enc_SenML_JSON_Resources(in SenML_JSON_Resources p_res) return octetstring
+  with { extension "prototype(convert) encode(JSON) printing(pretty)" }
+	
+  external function f_dec_SenML_JSON_Resources(in octetstring p_res) return SenML_JSON_Resources
+  with { extension "prototype(convert) decode(JSON)" }
+
+  /////////////////// ENCODING
+  
+  function f_enc_LwM2M_Resources_to_LwM2M_JSON(in LwM2M_Resource_List p_res_list) return octetstring
+  {
+    var charstring v_result :=
+    "{\"bn\":\"/\",\n"&
+    "\"e\":[\n";
+
+    for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+    {
+      v_result := v_result & f_enc_LwM2M_Resource_to_LwM2M_JSON(p_res_list[i]);
+      if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+      else { v_result := v_result & "\n"}
+    }
+
+    v_result := v_result & "]}";
+ 
+    return char2oct(v_result);
+  }
+
+  function f_enc_LwM2M_Resource_to_LwM2M_JSON(in LwM2M_Resource p_res) return charstring
+  {
+    var charstring v_ret := "";
+
+    // "n":"65/3/3"
+    var charstring v_name := "";
+
+    if (p_res.objId != -1) { 	    
+      v_name := v_name & int2str(p_res.objId) 
+    }
+    if (p_res.objInstId != -1) {
+      if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.objInstId)  }
+      else { v_name := int2str(p_res.objInstId) }
+    }
+    if (p_res.id != -1) {
+      if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.id)  }
+      else { v_name := int2str(p_res.id) }
+    }
+    v_name := "\"n\":\"" & v_name & "\"";
+
+    var charstring v_value := "";
+
+    if (ischosen(p_res.val.intValue)) { 
+      v_value := "\"v\":" & int2str(p_res.val.intValue);
+    }
+    else if (ischosen(p_res.val.floatValue)) { 
+      v_value := "\"v\":" & float2str(p_res.val.floatValue);
+    }
+    else if (ischosen(p_res.val.strValue)) { 
+      v_value := "\"sv\":" & "\"" & p_res.val.strValue & "\"";
+    }
+    else if (ischosen(p_res.val.boolValue)) { 
+      //v_value := "\"bv\":" & "\"" & f_bool2str(p_res.val.boolValue) & "\"";
+      v_value := "\"bv\":" &  f_bool2str(p_res.val.boolValue);
+    }
+    else if (ischosen(p_res.val.opaqueValue)) { 
+      v_value := "\"ov\":" & "\"" & oct2str(p_res.val.opaqueValue) & "\"";
+    }
+
+    v_ret := "{" & v_name & ", " & v_value & "}";
+
+    return v_ret;
+  }
+  
+  function f_enc_LwM2M_Resources_to_JSON_create(in LwM2M_Resource_List p_res_list) return octetstring
+  {
+    var charstring v_result := "{\"bn\":\"/";
+	  
+    if(sizeof(p_res_list) == 1)
+    {
+      v_result := 
+        v_result & int2str(p_res_list[0].objId)  
+        & "/" & int2str(p_res_list[0].objInstId) & "/" 
+        & int2str(p_res_list[0].id) & "\"\n" & "\"e\":[\n";
+
+      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+      {
+        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_create(p_res_list[i], FULL_PATH);
+        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+      	else { v_result := v_result & "\n"}
+      }
+    }
+    else if(f_match_instanceIds(p_res_list))
+    {
+      v_result := 
+        v_result & int2str(p_res_list[0].objId)  
+        & "/" & int2str(p_res_list[0].objInstId) & "/" & "\n" & "\"e\":[\n";
+
+      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+      {
+        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_create(p_res_list[i], OBJECT_OBJECTINSTANCE);
+        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+        else { v_result := v_result & "\n"}
+      }
+    }
+    else if(f_match_objIds(p_res_list))
+    {
+      v_result := 
+        v_result & int2str(p_res_list[0].objId) & "/" & "\n" & "\"e\":[\n";
+      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+      {
+        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_create(p_res_list[i], JUST_OBJECT);
+        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+        else { v_result := v_result & "\n"}
+      }
+    }
+    else
+    {
+      v_result := v_result & "\n" & "\"e\":[\n";
+      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+      {
+        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_create(p_res_list[i], EMPTY);
+        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+        else { v_result := v_result & "\n"}
+      }
+    }
+    v_result := v_result & "]}";
+	  
+    //log("v_result_str: ", v_result, "v_result_oct: ", char2oct(v_result));
+  
+    return char2oct(v_result);
+  }
+
+  function f_enc_LwM2M_Resource_to_JSON_create(in LwM2M_Resource p_res, in JSON_BaseName_Type p_t) return charstring
+  {
+    var charstring v_ret := "";
+    if(p_t == FULL_PATH) {
+      v_ret := "\"n\":\"\"";
+    }
+    else if(p_t == OBJECT_OBJECTINSTANCE) {
+      v_ret := "\"n\":\"" & int2str(p_res.id) & "\""
+    }
+    else if(p_t == JUST_OBJECT){
+      v_ret := "\"n\":\"" & int2str(p_res.id) & "/" 
+        & int2str(p_res.objInstId) & "\""
+    }
+    else {
+      v_ret := "\"n\":\"" & int2str(p_res.objId) & "/" 
+        & int2str(p_res.objInstId) & "/"
+        & int2str(p_res.id) & "\""
+    }
+	  
+    var charstring v_value := "";
+	  
+    if (ischosen(p_res.val.intValue)) { 
+      v_value := "\"v\":" & int2str(p_res.val.intValue);
+    }
+    else if (ischosen(p_res.val.floatValue)) { 
+      v_value := "\"v\":" & float2str(p_res.val.floatValue);
+    }
+    else if (ischosen(p_res.val.strValue)) { 
+      v_value := "\"sv\":" & "\"" & p_res.val.strValue & "\"";
+    }
+    else if (ischosen(p_res.val.boolValue)) { 
+      v_value := "\"bv\":" & "\"" & f_bool2str(p_res.val.boolValue) & "\"";
+    }
+    else if (ischosen(p_res.val.opaqueValue)) { 
+      v_value := "\"ov\":" & "\"" & oct2str(p_res.val.opaqueValue) & "\"";
+    }
+    else { return "" }
+	  
+    v_ret := "{" & v_ret & ", " & v_value & "}";
+	  
+    return v_ret;
+  }
+  
+  function f_enc_LwM2M_Resources_to_SenML_JSON(in LwM2M_Resource_List p_res_list) return octetstring
+  {
+    var charstring v_result :=
+    "[";
+
+    for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
+    {
+      v_result := v_result & f_enc_LwM2M_Resource_to_SenML_JSON(p_res_list[i]);
+      if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
+      else { v_result := v_result & "\n"}
+    }
+
+    v_result := v_result & "]";
+ 
+    return char2oct(v_result);
+  }
+
+  function f_enc_LwM2M_Resource_to_SenML_JSON(in LwM2M_Resource p_res) return charstring
+  {
+    var charstring v_ret := "";
+
+    // "n":"/65/3/3"
+    var charstring v_name := "/";
+
+    if (p_res.objId != -1) { 	    
+      v_name := v_name & int2str(p_res.objId) 
+    }
+    if (p_res.objInstId != -1) {
+      if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.objInstId)  }
+      else { v_name := int2str(p_res.objInstId) }
+    }
+    if (p_res.id != -1) {
+      if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.id)  }
+      else { v_name := int2str(p_res.id) }
+    }
+    v_name := "\"n\":\"" & v_name & "\"";
+
+    var charstring v_value := "";
+
+    if (ischosen(p_res.val.intValue)) { 
+      v_value := "\"v\":" & int2str(p_res.val.intValue);
+    }
+    else if (ischosen(p_res.val.floatValue)) { 
+      v_value := "\"v\":" & float2str(p_res.val.floatValue);
+    }
+    else if (ischosen(p_res.val.strValue)) { 
+      v_value := "\"vs\":" & "\"" & p_res.val.strValue & "\"";
+    }
+    else if (ischosen(p_res.val.boolValue)) { 
+      //v_value := "\"bv\":" & "\"" & f_bool2str(p_res.val.boolValue) & "\"";
+      v_value := "\"vb\":" &  f_bool2str(p_res.val.boolValue);
+    }
+    else if (ischosen(p_res.val.opaqueValue)) { 
+      v_value := "\"vd\":" & "\"" & oct2str(p_res.val.opaqueValue) & "\"";
+    }
+    else { return "" }
+
+    v_ret := "{" & v_name & ", " & v_value & "}";
+
+    return v_ret;
+  }
+
+  function f_bool2str(in boolean p_b) return charstring { if (p_b) {return "true"} else {return "false" }}
+  
+  
+  /////////////////// DECODING
+  
+  function f_dec_LwM2M_Resources_from_LwM2M_JSON(in octetstring p_payload, inout LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    var LwM2M_JSON_Resources v_decoded_json := f_dec_LwM2M_JSON_Resources(p_payload);
+    //f_JSON_debug(log2str("Decoded json: ", v_decoded_json));
+    p_resources := f_LwM2M_JSON_Resources_toResources(v_decoded_json);
+    return true;
+  }
+  
+  function f_LwM2M_JSON_Resources_toResources(in LwM2M_JSON_Resources p_json_res_list)
+  return LwM2M_Resource_List
+  {
+    var LwM2M_Resource_List v_ret := {};
+    var charstring v_bn := "";
+    
+    if (ispresent(p_json_res_list.bn)) { v_bn := p_json_res_list.bn; }
+	  
+    for (var integer i:=0; i<sizeof(p_json_res_list.e); i:=i+1) {
+      v_ret[sizeof(v_ret)] := f_LwM2M_JSON_Resource_toResource(p_json_res_list.e[i], v_bn);
+    }
+	  
+    return v_ret;
+  }
+	
+  function f_LwM2M_JSON_Resource_toResource(in LwM2M_JSON_Resource p_json_res, in charstring p_bn)
+  return LwM2M_Resource
+  {
+    var LwM2M_Resource v_ret := c_LwM2M_Resource_init;
+    
+    var charstring vl_id := p_bn & p_json_res.n & "/";    
+    var TCC_Conversion_ch_list vl_ids := f_substr_all_tokens(vl_id, "", "/");    
+    
+    if (sizeof(vl_ids)>=4)
+    {
+      f_isNumber(vl_ids[1], v_ret.objId);
+      f_isNumber(vl_ids[2], v_ret.objInstId);
+      f_isNumber(vl_ids[3], v_ret.id);
+    }
+    	  
+    if (ispresent(p_json_res.bv)) { v_ret.val.boolValue := p_json_res.bv; }
+    if (ispresent(p_json_res.sv)) { v_ret.val.strValue := p_json_res.sv; }
+    if (ispresent(p_json_res.v)) {
+      if (ischosen(p_json_res.v.f)) { v_ret.val.floatValue := p_json_res.v.f; }
+      else if (ischosen(p_json_res.v.i)) { v_ret.val.intValue := p_json_res.v.i; }
+    }
+    if (ispresent(p_json_res.ov)) { v_ret.val.opaqueValue := str2oct(p_json_res.ov); }
+	  
+    return v_ret;
+  }
+  
+  function f_dec_LwM2M_Resources_from_SenML_JSON(in octetstring p_payload, inout LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    var SenML_JSON_Resources v_decoded_json := f_dec_SenML_JSON_Resources(p_payload);
+    //f_JSON_debug(log2str("Decoded json: ", v_decoded_json));
+    p_resources := f_SenML_JSON_Resources_toResources(v_decoded_json);
+    return true;
+  }
+  
+  function f_SenML_JSON_Resources_toResources(in SenML_JSON_Resources p_json_res_list)
+  return LwM2M_Resource_List
+  {
+    var LwM2M_Resource_List v_ret := {};
+    
+    var charstring v_bn := "";
+	  
+    for (var integer i:=0; i<sizeof(p_json_res_list); i:=i+1) {
+      v_ret[sizeof(v_ret)] := f_SenML_JSON_Resource_toResource(p_json_res_list[i], v_bn);
+    }
+	  
+    return v_ret;
+  }
+	
+  function f_SenML_JSON_Resource_toResource(in SenML_JSON_Resource p_json_res, inout charstring p_bn)
+  return LwM2M_Resource
+  {
+    var LwM2M_Resource v_ret := c_LwM2M_Resource_init;
+    
+    if (ispresent(p_json_res.bn))
+    {
+      p_bn := p_json_res.bn;
+    }
+    
+    var charstring vl_id := p_bn & p_json_res.n & "/";    
+    var TCC_Conversion_ch_list vl_ids := f_substr_all_tokens(vl_id, "", "/");    
+    
+    if (sizeof(vl_ids)>=4)
+    {
+      f_isNumber(vl_ids[1], v_ret.objId);
+      f_isNumber(vl_ids[2], v_ret.objInstId);
+      f_isNumber(vl_ids[3], v_ret.id);
+    }
+    	  
+    if (ispresent(p_json_res.vb)) { v_ret.val.boolValue := p_json_res.vb; }
+    if (ispresent(p_json_res.vs)) { v_ret.val.strValue := p_json_res.vs; }
+    if (ispresent(p_json_res.v)) {
+      if (ischosen(p_json_res.v.f)) { v_ret.val.floatValue := p_json_res.v.f; }
+      else if (ischosen(p_json_res.v.i)) { v_ret.val.intValue := p_json_res.v.i; }
+    }
+    if (ispresent(p_json_res.vd)) { v_ret.val.opaqueValue := str2oct(p_json_res.vd); }
+	  
+    return v_ret;
+  }
+  
+  function f_match_instanceIds(in LwM2M_Resource_List p_res_list) return boolean
+  {
+    var integer firstObjId := p_res_list[0].objId;
+    var integer firstObjInstId := p_res_list[0].objInstId;
+	  
+    for (var integer i:=1; i<sizeof(p_res_list); i:=i+1){
+      if(p_res_list[i].objId != firstObjId or p_res_list[i].objInstId != firstObjInstId) {
+        return false;
+      }
+    }
+	  
+    return true;
+  }
+	
+  function f_match_objIds(in LwM2M_Resource_List p_res_list) return boolean
+  {
+    var integer firstObjId := p_res_list[0].objId;
+	  
+    for (var integer i:=1; i<sizeof(p_res_list); i:=i+1){
+      if(p_res_list[i].objId != firstObjId) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  function f_JSON_debug(in @lazy charstring pl_message)
+  {
+    if (c_LWM2M_JSON_debugSwitch) {
+      if (tsp_LWM2M_JSON_EncDec_debug) { log(pl_message); }
+    }
+  }
+}
diff --git a/src/LWM2M_JSON_Types.ttcn b/src/LWM2M_JSON_Types.ttcn
new file mode 100644
index 0000000..d0c69c3
--- /dev/null
+++ b/src/LWM2M_JSON_Types.ttcn
@@ -0,0 +1,79 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2020 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v2.0
+// which accompanies this distribution, and is available at
+// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+///////////////////////////////////////////////////////////////////////////////
+//  File:               LWM2M_JSON_Types.ttcn
+//  Description:
+//  Rev:                R1A
+//  Prodnr:             CNL 113 859
+//  Updated:            2020-03-04
+//  Contact:            http://ttcn.ericsson.se
+///////////////////////////////////////////////////////////////////////////////
+module LWM2M_JSON_Types
+{
+  type record LwM2M_JSON_Resources
+  {
+    charstring bn optional,
+    LwM2M_JSON_Resource_List e
+  }
+  with { 
+    encode "JSON" 
+    optional "implicit omit"
+  }
+	
+  type record of LwM2M_JSON_Resource LwM2M_JSON_Resource_List	
+  with { encode "JSON" }
+	
+  type record LwM2M_JSON_Resource
+  {
+    charstring n,
+    JSON_Numeric v optional,
+    boolean bv optional,
+    charstring sv optional,
+    charstring ov optional
+  }
+  with {
+    encode "JSON"
+    optional "implicit omit"
+  }
+  
+  type union JSON_Numeric
+  {
+    integer i,
+    float f
+  }
+  with {
+    encode "JSON"
+    variant "JSON : as value"
+  }
+  
+  type record of SenML_JSON_Resource SenML_JSON_Resources
+  with { encode "JSON" }  
+  
+  type record SenML_JSON_Resource
+  {
+    charstring bn optional,
+    charstring n,
+    JSON_Numeric v optional,
+    boolean vb optional,
+    charstring vs optional,
+    charstring vd optional
+  }
+  with {
+    encode "JSON" 
+    optional "implicit omit"
+  }
+  
+  type enumerated JSON_BaseName_Type
+  {
+    FULL_PATH,
+    OBJECT_OBJECTINSTANCE,
+    JUST_OBJECT,
+    EMPTY
+  }
+}
diff --git a/src/LWM2M_Opaque_EncDec.ttcn b/src/LWM2M_Opaque_EncDec.ttcn
new file mode 100644
index 0000000..e1d4aa4
--- /dev/null
+++ b/src/LWM2M_Opaque_EncDec.ttcn
@@ -0,0 +1,53 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2020 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v2.0
+// which accompanies this distribution, and is available at
+// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+///////////////////////////////////////////////////////////////////////////////
+//  File:               LWM2M_Opaque_EncDec.ttcn
+//  Description:
+//  Rev:                R1A
+//  Prodnr:             CNL 113 859
+//  Updated:            2020-03-04
+//  Contact:            http://ttcn.ericsson.se
+///////////////////////////////////////////////////////////////////////////////
+module LWM2M_Opaque_EncDec
+{
+  import from LightweightM2M_Types all;
+
+  function f_enc_LwM2M_Resources_to_Opaque(in LwM2M_Resource_List p_res_list) return octetstring
+  {
+    var octetstring v_result := ''O;
+    
+    if (sizeof(p_res_list) >= 1)
+    {
+      if (ischosen(p_res_list[0].val.intValue)) { 
+        v_result := int2oct(p_res_list[0].val.intValue, 4);
+      }
+      else if (ischosen(p_res_list[0].val.floatValue)) { 
+        v_result := int2oct(float2int(p_res_list[0].val.floatValue), 4);
+      }
+      else if (ischosen(p_res_list[0].val.strValue)) { 
+        v_result := str2oct(p_res_list[0].val.strValue);
+      }
+      else if (ischosen(p_res_list[0].val.opaqueValue)) { 
+        v_result := p_res_list[0].val.opaqueValue;
+      }
+    }
+ 
+    return v_result;
+  }
+  
+  function f_dec_LwM2M_Resources_from_Opaque(in octetstring p_payload, inout LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    p_resources[0] := c_LwM2M_Resource_init;
+    
+    p_resources[0].val.opaqueValue := p_payload;
+
+    return true;
+  }
+}
diff --git a/src/LWM2M_Plain_EncDec.ttcn b/src/LWM2M_Plain_EncDec.ttcn
new file mode 100644
index 0000000..ba64689
--- /dev/null
+++ b/src/LWM2M_Plain_EncDec.ttcn
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2000-2020 Ericsson Telecom AB
+//
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v2.0
+// which accompanies this distribution, and is available at
+// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+///////////////////////////////////////////////////////////////////////////////
+//  File:               LWM2M_Plain_EncDec.ttcn
+//  Description:
+//  Rev:                R1A
+//  Prodnr:             CNL 113 859
+//  Updated:            2020-03-04
+//  Contact:            http://ttcn.ericsson.se
+///////////////////////////////////////////////////////////////////////////////
+module LWM2M_Plain_EncDec
+{
+  import from LightweightM2M_Types all;
+
+  function f_enc_LwM2M_Resources_to_Plain(in LwM2M_Resource_List p_res_list) return octetstring
+  {
+    var charstring v_result := "";
+    
+    if (sizeof(p_res_list) >= 1)
+    {
+      if (ischosen(p_res_list[0].val.intValue)) { 
+        v_result := int2str(p_res_list[0].val.intValue);
+      }
+      else if (ischosen(p_res_list[0].val.floatValue)) { 
+        v_result := float2str(p_res_list[0].val.floatValue);
+      }
+      else if (ischosen(p_res_list[0].val.strValue)) { 
+        v_result := p_res_list[0].val.strValue;
+      }
+      else if (ischosen(p_res_list[0].val.boolValue)) { 
+        v_result := f_bool2str(p_res_list[0].val.boolValue);
+      }
+      else if (ischosen(p_res_list[0].val.opaqueValue)) { 
+        v_result := oct2str(p_res_list[0].val.opaqueValue);
+      }
+    }
+ 
+    return char2oct(v_result);
+  }
+  
+  function f_dec_LwM2M_Resources_from_Plain(in octetstring p_payload, inout LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    p_resources[0] := c_LwM2M_Resource_init;
+    
+    p_resources[0].val.strValue := oct2char(p_payload);
+
+    return true;
+  }
+  
+  function f_bool2str(in boolean p_b) return charstring { if (p_b) {return "true"} else {return "false" }}
+}
diff --git a/src/LWM2M_TLV_EncDec.ttcn b/src/LWM2M_TLV_EncDec.ttcn
index 3d4651c..97ea945 100644
--- a/src/LWM2M_TLV_EncDec.ttcn
+++ b/src/LWM2M_TLV_EncDec.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 module LWM2M_TLV_EncDec
@@ -22,6 +22,18 @@
   modulepar boolean tsp_LWM2M_TLV_EncDec_debug := false;
   const boolean c_LWM2M_TLV_debugSwitch := false;
   
+  function f_LwM2M_TLV_decode(in octetstring p_coapPayload, in Location p_loc, inout LwM2M_Resource_List p_resources)
+  return boolean
+  {
+    var LWM2M_TLV_Resources v_decoded_tlv := f_dec_LwM2M_TLV_Resources(p_coapPayload);
+    //f_TLV_debug(log2str("Decoded TLV resources: ", resources));
+    
+    p_resources := f_LwM2M_TLV_Resources_toResources(v_decoded_tlv, p_loc);
+    //f_TLV_debug(log2str("Decoded resources: ", resources));
+    
+    return true;
+  }
+  
   function f_dec_LwM2M_TLV_Resources(in octetstring p_raw_msg) return LWM2M_TLV_Resources {
     var integer v_procedBits := 0;
     var bitstring v_msgInBits := oct2bit(p_raw_msg);
@@ -134,6 +146,7 @@
     {
       var LWM2M_TLV_Resource v_tmpTLV := p_tlv_res[i];
 	    
+      v_resource_list[i] := c_LwM2M_Resource_init;
       v_resource_list[i].objId := str2int(oct2char(unichar2oct(p_loc[0])));
       if(sizeof(p_loc) >= 2){
         v_resource_list[i].objInstId := str2int(oct2char(unichar2oct(p_loc[1])));
diff --git a/src/LWM2M_TLV_Types.ttcn b/src/LWM2M_TLV_Types.ttcn
index 96cd896..dd138cd 100644
--- a/src/LWM2M_TLV_Types.ttcn
+++ b/src/LWM2M_TLV_Types.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             CNL 113 859
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 module LWM2M_TLV_Types
@@ -118,12 +118,4 @@
     {5, INTEGER},
     {6, STRING}
   }
-	
-  type enumerated JSON_BaseName_Type
-  {
-    FULL_PATH,
-    OBJECT_OBJECTINSTANCE,
-    JUST_OBJECT,
-    EMPTY
-  }
 }
diff --git a/src/LightweightM2M_CoAP_Binding.ttcn b/src/LightweightM2M_CoAP_Binding.ttcn
index 272af9d..b9ab6fb 100644
--- a/src/LightweightM2M_CoAP_Binding.ttcn
+++ b/src/LightweightM2M_CoAP_Binding.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,15 +11,19 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             LPA 108 661
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 module LightweightM2M_CoAP_Binding {
 
   import from LightweightM2M_Types all;
   import from CoAP_Types all;
-  import from LWM2M_TLV_Types all;
   import from LWM2M_TLV_EncDec all;
+  import from LWM2M_JSON_EncDec all;
+  import from LWM2M_Opaque_EncDec all;
+  import from LWM2M_Plain_EncDec all;
+  
+  modulepar integer tsp_LightweightM2M_CoAP_Binding_defaultContentFormat := 11543;
 	
   function f_enc_LWM2M_to_COAP(in LWM2M_PDU p_lwm2m, inout CoAP_ReqResp p_coap)
   return boolean
@@ -80,21 +84,25 @@
       {
         p_coap := valueof(t_coap_base(f_int2Code(p_lwm2m.Response.code), ACKNOWLEDGEMENT));	    
         f_addLocation(p_coap, p_lwm2m.Response.location);
-        if (ispresent(p_lwm2m.Response.contentFormat)) {
+        if (sizeof(p_lwm2m.Response.resources)>0) 
+	{
+          if (not ispresent(p_lwm2m.Response.contentFormat)) {
+            p_lwm2m.Response.contentFormat := tsp_LightweightM2M_CoAP_Binding_defaultContentFormat;
+          }
           f_addContentFormat(p_coap, p_lwm2m.Response.contentFormat);
-        }
-        if (sizeof(p_lwm2m.Response.resources)>0) {
-          p_coap.payload := f_enc_LwM2M_Resources_to_JSON(p_lwm2m.Response.resources);
+          p_coap.payload := f_enc_LwM2M_Resources(p_lwm2m.Response.resources, p_lwm2m.Response.contentFormat);
         }
       }
       else if (ischosen(p_lwm2m.Notification))
       {
-        p_coap := valueof(t_coap_base(f_int2Code(p_lwm2m.Notification.code), ACKNOWLEDGEMENT));     
-        if (ispresent(p_lwm2m.Notification.contentFormat)) {
+        p_coap := valueof(t_coap_base(f_int2Code(p_lwm2m.Notification.code), ACKNOWLEDGEMENT));
+        if (sizeof(p_lwm2m.Notification.resources)>0) 
+	{
+          if (not ispresent(p_lwm2m.Notification.contentFormat)) {
+            p_lwm2m.Notification.contentFormat := tsp_LightweightM2M_CoAP_Binding_defaultContentFormat;
+          }
           f_addContentFormat(p_coap, p_lwm2m.Notification.contentFormat);
-        }        
-        if (sizeof(p_lwm2m.Notification.resources)>0) {
-          p_coap.payload := f_enc_LwM2M_Resources_to_JSON(p_lwm2m.Notification.resources);
+          p_coap.payload := f_enc_LwM2M_Resources(p_lwm2m.Notification.resources, p_lwm2m.Notification.contentFormat);
         }
       }
       else if (ischosen(p_lwm2m.Read_))
@@ -129,9 +137,11 @@
         if(ispresent(p_lwm2m.Write.path.resourceId)) {
           f_addOption(p_coap, { uri_path := int2str(p_lwm2m.Write.path.resourceId) });
         }
-        if (ispresent(p_lwm2m.Write.contentFormat)) {
-  	  f_addContentFormat(p_coap, p_lwm2m.Write.contentFormat);
-	}
+        if (not ispresent(p_lwm2m.Write.contentFormat)) {
+            p_lwm2m.Write.contentFormat := tsp_LightweightM2M_CoAP_Binding_defaultContentFormat;
+        }
+        f_addContentFormat(p_coap, p_lwm2m.Write.contentFormat);
+	  
         if (ispresent(p_lwm2m.Write.block1)) {
           f_addOption(p_coap, { block1 := p_lwm2m.Write.block1.option });
           p_coap.payload := p_lwm2m.Write.block1.content;
@@ -139,7 +149,7 @@
 
         if (not ispresent(p_lwm2m.Write.block1))
         {
-          p_coap.payload := f_enc_LwM2M_Resources_to_JSON_alt(p_lwm2m.Write.resources);
+          p_coap.payload := f_enc_LwM2M_Resources(p_lwm2m.Write.resources, p_lwm2m.Write.contentFormat);
         }
       }
       else if(ischosen(p_lwm2m.Create))
@@ -155,7 +165,7 @@
         }
         else 
         {
-          p_coap.payload := f_enc_LwM2M_Resources_to_JSON_alt(p_lwm2m.Create.resources);
+          p_coap.payload := f_enc_LwM2M_Resources_to_JSON_create(p_lwm2m.Create.resources);
         }
       }
       else if(ischosen(p_lwm2m.Delete) or ischosen(p_lwm2m.BS_Delete))
@@ -203,133 +213,6 @@
     return true;
   }
 
-  function f_enc_LwM2M_Resources_to_JSON_alt(in LwM2M_Resource_List p_res_list) return octetstring
-  {
-    var charstring v_result := "{\"bn\":\"/";
-	  
-    if(sizeof(p_res_list) == 1)
-    {
-      v_result := 
-        v_result & int2str(p_res_list[0].objId)  
-        & "/" & int2str(p_res_list[0].objInstId) & "/" 
-        & int2str(p_res_list[0].id) & "\"\n" & "\"e\":[\n";
-
-      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-      {
-        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_alt(p_res_list[i], FULL_PATH);
-        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
-      	else { v_result := v_result & "\n"}
-      }
-    }
-    else if(f_match_instanceIds(p_res_list))
-    {
-      v_result := 
-        v_result & int2str(p_res_list[0].objId)  
-        & "/" & int2str(p_res_list[0].objInstId) & "/" & "\n" & "\"e\":[\n";
-
-      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-      {
-        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_alt(p_res_list[i], OBJECT_OBJECTINSTANCE);
-        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
-        else { v_result := v_result & "\n"}
-      }
-    }
-    else if(f_match_objIds(p_res_list))
-    {
-      v_result := 
-        v_result & int2str(p_res_list[0].objId) & "/" & "\n" & "\"e\":[\n";
-      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-      {
-        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_alt(p_res_list[i], JUST_OBJECT);
-        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
-        else { v_result := v_result & "\n"}
-      }
-    }
-    else
-    {
-      v_result := v_result & "\n" & "\"e\":[\n";
-      for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-      {
-        v_result := v_result & f_enc_LwM2M_Resource_to_JSON_alt(p_res_list[i], EMPTY);
-        if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
-        else { v_result := v_result & "\n"}
-      }
-    }
-    v_result := v_result & "]}";
-	  
-    //log("v_result_str: ", v_result, "v_result_oct: ", char2oct(v_result));
-  
-    return char2oct(v_result);
-  }
-
-  function f_enc_LwM2M_Resource_to_JSON_alt(in LwM2M_Resource p_res, in JSON_BaseName_Type p_t) return charstring
-  {
-    var charstring v_ret := "";
-    if(p_t == FULL_PATH) {
-      v_ret := "\"n\":\"\"";
-    }
-    else if(p_t == OBJECT_OBJECTINSTANCE) {
-      v_ret := "\"n\":\"" & int2str(p_res.id) & "\""
-    }
-    else if(p_t == JUST_OBJECT){
-      v_ret := "\"n\":\"" & int2str(p_res.id) & "/" 
-        & int2str(p_res.objInstId) & "\""
-    }
-    else {
-      v_ret := "\"n\":\"" & int2str(p_res.objId) & "/" 
-        & int2str(p_res.objInstId) & "/"
-        & int2str(p_res.id) & "\""
-    }
-	  
-    var charstring v_value := "";
-	  
-    if (ischosen(p_res.val.intValue)) { 
-      v_value := "\"v\":" & int2str(p_res.val.intValue);
-    }
-    else if (ischosen(p_res.val.floatValue)) { 
-      v_value := "\"v\":" & float2str(p_res.val.floatValue);
-    }
-    else if (ischosen(p_res.val.strValue)) { 
-      v_value := "\"sv\":" & "\"" & p_res.val.strValue & "\"";
-    }
-    else if (ischosen(p_res.val.boolValue)) { 
-      v_value := "\"bv\":" & "\"" & f_bool2str(p_res.val.boolValue) & "\"";
-    }
-    else if (ischosen(p_res.val.opaqueValue)) { 
-      v_value := "\"ov\":" & "\"" & oct2str(p_res.val.opaqueValue) & "\"";
-    }
-	  
-    v_ret := "{" & v_ret & ", " & v_value & "}";
-	  
-    return v_ret;
-  }
-
-  function f_match_instanceIds(in LwM2M_Resource_List p_res_list) return boolean
-  {
-    var integer firstObjId := p_res_list[0].objId;
-    var integer firstObjInstId := p_res_list[0].objInstId;
-	  
-    for (var integer i:=1; i<sizeof(p_res_list); i:=i+1){
-      if(p_res_list[i].objId != firstObjId or p_res_list[i].objInstId != firstObjInstId) {
-        return false;
-      }
-    }
-	  
-    return true;
-  }
-	
-  function f_match_objIds(in LwM2M_Resource_List p_res_list) return boolean
-  {
-    var integer firstObjId := p_res_list[0].objId;
-	  
-    for (var integer i:=1; i<sizeof(p_res_list); i:=i+1){
-      if(p_res_list[i].objId != firstObjId) {
-        return false;
-      }
-    }
-    return true;
-  }
-	
   function f_dec_COAP_to_LWM2M(in CoAP_ReqResp p_coap, inout LWM2M_PDU p_lwm2m)
   return boolean
   {
@@ -347,7 +230,7 @@
           f_fetchContentFormat(p_coap.options, p_lwm2m.Response.contentFormat);
         }
 	if(ispresent(p_coap.payload)) {
-          f_decodePayload(p_lwm2m.Response.contentFormat, p_coap.payload, p_lwm2m.Response.resources, p_lwm2m.Response.location);
+          f_dec_LwM2M_Resources(p_lwm2m.Response.contentFormat, p_coap.payload, p_lwm2m.Response.resources, p_lwm2m.Response.location);
 	}
         return true;
       }
@@ -380,7 +263,7 @@
 
         if (not ispresent(p_lwm2m.Write.block1))
         {
-          f_decodePayload(p_lwm2m.Write.contentFormat, p_coap.payload, p_lwm2m.Write.resources, v_loc);
+          f_dec_LwM2M_Resources(p_lwm2m.Write.contentFormat, p_coap.payload, p_lwm2m.Write.resources, v_loc);
         }
         else
         {
@@ -404,7 +287,7 @@
           p_lwm2m := c_LWM2M_Create_init;
           f_LocationToObjectPath(v_loc, p_lwm2m.Create.path);
           f_fetchContentFormat(p_coap.options, p_lwm2m.Create.contentFormat);
-          f_decodePayload(p_lwm2m.Create.contentFormat, p_coap.payload, p_lwm2m.Create.resources, v_loc);
+          f_dec_LwM2M_Resources(p_lwm2m.Create.contentFormat, p_coap.payload, p_lwm2m.Create.resources, v_loc);
         }
         return true;
       }
@@ -464,7 +347,7 @@
       f_fetchContentFormat(p_coap.options, p_lwm2m.Write.contentFormat);
 
       if(ispresent(p_coap.payload)){
-        f_decodePayload(p_lwm2m.Write.contentFormat, p_coap.payload, p_lwm2m.Write.resources, v_loc);
+        f_dec_LwM2M_Resources(p_lwm2m.Write.contentFormat, p_coap.payload, p_lwm2m.Write.resources, v_loc);
       }
 	    
       return true;
@@ -500,30 +383,61 @@
     }
   }
 
-  function f_decodePayload(in integer p_contentFormat, in octetstring p_coapPayload, inout LwM2M_Resource_List resources, in Location p_loc)
+  function f_enc_LwM2M_Resources(in LwM2M_Resource_List p_res_list, in integer p_contentFormat)
+  return octetstring
+  {
+    if (p_contentFormat == 11543)
+    {
+      return f_enc_LwM2M_Resources_to_LwM2M_JSON(p_res_list);
+    }
+    else if (p_contentFormat == 110)
+    {
+      return f_enc_LwM2M_Resources_to_SenML_JSON(p_res_list);
+    }
+    else if (p_contentFormat == 0)
+    {
+      return f_enc_LwM2M_Resources_to_Plain(p_res_list);
+    }
+    else if (p_contentFormat == 42)
+    {
+      return f_enc_LwM2M_Resources_to_Opaque(p_res_list);
+    }
+    else
+    {
+      if (sizeof(p_res_list)>0)
+      {
+        log(%definitionId, " WARNING: Content format unknown for encoding: ", p_contentFormat);
+      }
+    }
+    return ''O
+  }
+
+  function f_dec_LwM2M_Resources(in integer p_contentFormat, in octetstring p_coapPayload, inout LwM2M_Resource_List resources, in Location p_loc)
   return boolean
   {
     // JSON
     if (p_contentFormat == 11543) 
     {
-      var LwM2M_JSON_Resources v_decoded_json := f_dec_LwM2M_JSON_Resources(p_coapPayload);
-      //action("Decoded json: ", v_decoded_json);
-      resources := f_LwM2M_JSON_Resources_toResources(v_decoded_json);
-      return true
+      return f_dec_LwM2M_Resources_from_LwM2M_JSON(p_coapPayload, resources);
+    }
+    else if (p_contentFormat == 110) 
+    {
+      return f_dec_LwM2M_Resources_from_SenML_JSON(p_coapPayload, resources);
     }
     //TLV
     else if(p_contentFormat == 11542) 
     {
-      var LWM2M_TLV_Resources v_decoded_tlv := f_dec_LwM2M_TLV_Resources(p_coapPayload);
-	    
-      resources := f_LwM2M_TLV_Resources_toResources(v_decoded_tlv, p_loc);
-      //log("Decoded TLV resources: ", resources)
-     
-      return true; 
+      return f_LwM2M_TLV_decode(p_coapPayload, p_loc, resources);
     }
-    else if(p_contentFormat == 40)
+    //Plain
+    else if (p_contentFormat == 0)
     {
-      return true;
+      return f_dec_LwM2M_Resources_from_Plain(p_coapPayload, resources);
+    }
+    //Opaque
+    else if (p_contentFormat == 42)
+    {
+      return f_dec_LwM2M_Resources_from_Opaque(p_coapPayload, resources);
     }
     else {
      log(%definitionId," Unrecognized content format: ", p_contentFormat );
diff --git a/src/LightweightM2M_Types.ttcn b/src/LightweightM2M_Types.ttcn
index fe19c3e..049714b 100644
--- a/src/LightweightM2M_Types.ttcn
+++ b/src/LightweightM2M_Types.ttcn
@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2000-2019 Ericsson Telecom AB
+// Copyright (c) 2000-2020 Ericsson Telecom AB
 //
 // All rights reserved. This program and the accompanying materials
 // are made available under the terms of the Eclipse Public License v2.0
@@ -11,7 +11,7 @@
 //  Description:
 //  Rev:                R1A
 //  Prodnr:             LPA 108 661
-//  Updated:            2019-08-27
+//  Updated:            2020-03-04
 //  Contact:            http://ttcn.ericsson.se
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -325,8 +325,22 @@
     integer objInstId,
     boolean observed,
     LwM2M_DataSample_Information dataSample optional,
+    LwM2M_Specification_Indices spec,
+    integer contentFormat optional,
     LwM2M_ResourceValue val
   }
+  
+  type record LwM2M_Specification_Indices
+  {
+    integer objSpecIdx,
+    integer resSpecIdx
+  }
+  
+  const LwM2M_Specification_Indices c_LwM2M_Specification_Indices_init :=
+  {
+    objSpecIdx := -1,
+    resSpecIdx := -1
+  }
 	
   type record LwM2M_Observe_Information
   {
@@ -361,7 +375,26 @@
     objInstId := -1,
     observed := false,
     dataSample := omit,
-    val := { boolValue := false }
+    spec := c_LwM2M_Specification_Indices_init,
+    contentFormat := omit,
+    val := { noValue := false }
+  }
+  
+  template LwM2M_Resource t_LwM2M_Resource_init(
+    integer p_id,
+    integer p_objId,
+    integer p_objInstId,
+    LwM2M_ResourceValue p_val
+  ) :=
+  {
+    id := p_id,
+    objId := p_objId,
+    objInstId := p_objInstId,
+    observed := false,
+    dataSample := omit,
+    spec := c_LwM2M_Specification_Indices_init,
+    contentFormat := omit,
+    val := p_val
   }
 	
   ///////////////////////////////////////////////////////////
@@ -383,7 +416,8 @@
     charstring    strValue,
     float	  floatValue,
     octetstring   opaqueValue,
-    boolean	  boolValue
+    boolean	  boolValue,
+    boolean       noValue
   }
 	
   ///////////////////////////////////////////////////////////
@@ -419,162 +453,4 @@
 	{
 	  return not ispresent(p_path.objectInstanceId) and not ispresent(p_path.resourceId)
 	}
-	
-	///////////////////////////////////////
-	// JSON representation and enc/dec
-	///////////////////////////////////////
-	function f_enc_LwM2M_Resources_to_JSON(in LwM2M_Resource_List p_res_list) return octetstring
-	{
-	  var charstring v_result :=
-	  "{\"bn\":\"/\",\n"&
-	  "\"e\":[\n";
-	  
-	  for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-	  {
-	    v_result := v_result & f_enc_LwM2M_Resource_to_JSON(p_res_list[i]);
-	    if (i != sizeof(p_res_list)-1) { v_result := v_result & ",\n"}
-	    else { v_result := v_result & "\n"}
-	  }
-	  
-	  v_result := v_result & "]}";
-	  
-	  return char2oct(v_result);
-	}
-	
-	function f_enc_LwM2M_Resource_to_JSON(in LwM2M_Resource p_res) return charstring
-	{
-	  var charstring v_ret := "";
-	  
-	  // "n":"65/3/3"
-	  var charstring v_name := "";
-	  
-	  if (p_res.objId != -1) { 	    
-  	    v_name := v_name & int2str(p_res.objId) 
-      }
-	  if (p_res.objInstId != -1) {
-	    if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.objInstId)  }
-	    else { v_name := int2str(p_res.objInstId) }
-	  }
-	  if (p_res.id != -1) {
-	    if (lengthof(v_name) > 0) { v_name := v_name & "/" & int2str(p_res.id)  }
-	    else { v_name := int2str(p_res.id) }
-	  }
-	  v_name := "\"n\":\"" & v_name & "\"";
-	  
-	  var charstring v_value := "";
-	  
-	  if (ischosen(p_res.val.intValue)) { 
-	    v_value := "\"v\":" & int2str(p_res.val.intValue);
-	  }
-	  else if (ischosen(p_res.val.floatValue)) { 
-	    v_value := "\"v\":" & float2str(p_res.val.floatValue);
-	  }
-	  else if (ischosen(p_res.val.strValue)) { 
-	    v_value := "\"sv\":" & "\"" & p_res.val.strValue & "\"";
-	  }
-	  else if (ischosen(p_res.val.boolValue)) { 
-	    v_value := "\"bv\":" & "\"" & f_bool2str(p_res.val.boolValue) & "\"";
-	  }
-	  else if (ischosen(p_res.val.opaqueValue)) { 
-	    v_value := "\"ov\":" & "\"" & oct2str(p_res.val.opaqueValue) & "\"";
-	  }
-	  
-	  v_ret := "{" & v_name & ", " & v_value & "}";
-	  
-	  return v_ret;
-	}
-	
-	function f_bool2str(in boolean p_b) return charstring { if (p_b) {return "true"} else {return "false" }}
-	
-	function f_enc_LwM2M_Resources_to_JSON_old(in LwM2M_Resource_List p_res_list) return octetstring
-	{
-	  var LwM2M_JSON_Resources v_json_res_list;
-	  v_json_res_list.e := {};
-	  
-	  for (var integer i:=0; i<sizeof(p_res_list); i:=i+1)
-	  {
-	   v_json_res_list.e[sizeof(v_json_res_list.e)] := f_LwM2M_Resource_toJSONStructure(p_res_list[i]);
-	  }
-	  
-	  return f_enc_LwM2M_JSON_Resources(v_json_res_list);
-	}
-	
-	function f_LwM2M_Resource_toJSONStructure(in LwM2M_Resource p_in)
-	return LwM2M_JSON_Resource
-	{
-	  var LwM2M_JSON_Resource v_out;
-	  
-	  v_out.n := "";
-	  
-	  if (p_in.objId != -1) { 	    
-  	    v_out.n := int2str(p_in.objId) 
-      }
-	  if (p_in.objInstId != -1) {
-	    if (lengthof(v_out.n) > 0) { v_out.n := v_out.n & "/" & int2str(p_in.objInstId)  }
-	    else { v_out.n := int2str(p_in.objInstId) }
-	  }
-	  if (p_in.id != -1) {
-	    if (lengthof(v_out.n) > 0) { v_out.n := v_out.n & "/" & int2str(p_in.id)  }
-	    else { v_out.n := int2str(p_in.id) }
-	  }
-	  
-	  if (ischosen(p_in.val.intValue)) { v_out.v := int2float(p_in.val.intValue) }
-	  else if (ischosen(p_in.val.floatValue)) { v_out.v := p_in.val.floatValue }
-	  else if (ischosen(p_in.val.strValue)) { v_out.sv := p_in.val.strValue }
-	  else if (ischosen(p_in.val.boolValue)) { v_out.bv := p_in.val.boolValue }
-	  else if (ischosen(p_in.val.opaqueValue)) { v_out.sv := oct2str(p_in.val.opaqueValue) }
-	  
-	  return v_out;
-	}	
-	
-	function f_LwM2M_JSON_Resources_toResources(in LwM2M_JSON_Resources p_json_res_list)
-	return LwM2M_Resource_List
-	{
-	  var LwM2M_Resource_List v_ret := {};
-	  
-	  for (var integer i:=0; i<sizeof(p_json_res_list.e); i:=i+1) {
-	    v_ret[sizeof(v_ret)] := f_LwM2M_JSON_Resource_toResource(p_json_res_list.e[i]);
-	  }
-	  
-	  return v_ret;
-	}
-	
-	function f_LwM2M_JSON_Resource_toResource(in LwM2M_JSON_Resource p_json_res)
-	return LwM2M_Resource
-	{
-	  var LwM2M_Resource v_ret := c_LwM2M_Resource_init;
-	  
-	  if (ispresent(p_json_res.bv)) { v_ret.val.boolValue := p_json_res.bv; }
-	  if (ispresent(p_json_res.sv)) { v_ret.val.strValue := p_json_res.sv; }
-	  if (ispresent(p_json_res.v)) { v_ret.val.floatValue := p_json_res.v; }
-	  
-	  return v_ret;
-	}
-	
-	external function f_enc_LwM2M_JSON_Resources(in LwM2M_JSON_Resources p_res) return octetstring
-	with { extension "prototype(convert) encode(JSON) printing(pretty)" }
-	
-	external function f_dec_LwM2M_JSON_Resources(in octetstring p_res) return LwM2M_JSON_Resources
-	with { extension "prototype(convert) decode(JSON)" }
-	
-	type record LwM2M_JSON_Resources
-	{
-	  LwM2M_JSON_Resource_List e
-	}
-	with { encode "JSON" }
-	
-	type record of LwM2M_JSON_Resource LwM2M_JSON_Resource_List	
-	with { encode "JSON" }
-	
-	type record LwM2M_JSON_Resource
-	{
-	  charstring n,
-  	  float v optional,
-	  boolean bv optional,
-	  charstring sv optional
-	}
-	with {
-	  encode "JSON" 
-	  optional "implicit omit"
-	}
 }
diff --git a/test/EPTF_LwM2M_Tests.cfg b/test/EPTF_LwM2M_Tests.cfg
index 83c6b3d..2b3c889 100644
--- a/test/EPTF_LwM2M_Tests.cfg
+++ b/test/EPTF_LwM2M_Tests.cfg
@@ -29,6 +29,7 @@
 tsp_EPTF_COAP_LocalTransport_debugVerbose := true;
 tsp_EPTF_LwM2M_LGen_debug := true;
 tsp_EPTF_LwM2M_LGen_debugVerbose := true;
+tsp_EPTF_LwM2M_CoapApplibTransport_debug := true;
 tsp_LWM2M_TLV_EncDec_debug := true;
 
 tsp_SUT_localHost := "127.0.0.1";
@@ -66,22 +67,56 @@
 //*.IPL4_PCO.DTLSv1 := "NO"
 
 [EXECUTE]
-// ALL
-//EPTF_LwM2M_Tests.control
-// Basic
+/////////////////////
+// Component tests
+/////////////////////
+// Encdec
+EPTF_LwM2M_Tests.tc_tlv_decoding_string
+EPTF_LwM2M_Tests.tc_encdec_LwM2M_JSON_Resources_to_oct
+EPTF_LwM2M_Tests.tc_encdec_SenML_JSON_Resources_to_oct
+EPTF_LwM2M_Tests.tc_encdec_LwM2M_Resources_to_oct_using_LwM2M_JSON
+EPTF_LwM2M_Tests.tc_encdec_LwM2M_Resources_to_oct_using_SenML_JSON
+// Register-deregister
 EPTF_LwM2M_Tests.tc_initialization
 EPTF_LwM2M_Tests.tc_registration
-//EPTF_LwM2M_Tests.tc_registration_dtls  // NOK OK
 EPTF_LwM2M_Tests.tc_deregistration
-EPTF_LwM2M_Tests.tc_read_resource
-EPTF_LwM2M_Tests.tc_write_resource
+// Read
+EPTF_LwM2M_Tests.tc_read_resource_float_using_text
+EPTF_LwM2M_Tests.tc_read_resource_float_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_read_resource_float_using_senml_json
+EPTF_LwM2M_Tests.tc_read_resource_int_using_text
+EPTF_LwM2M_Tests.tc_read_resource_int_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_read_resource_int_using_senml_json
+EPTF_LwM2M_Tests.tc_read_resource_string_using_text
+EPTF_LwM2M_Tests.tc_read_resource_string_lwm2m_json
+EPTF_LwM2M_Tests.tc_read_resource_string_senlm_json
+EPTF_LwM2M_Tests.tc_read_object_instance_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_read_object_instance_using_senml_json
+EPTF_LwM2M_Tests.tc_read_object_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_read_object_using_senml_json
+// Write
+EPTF_LwM2M_Tests.tc_write_resource_float_using_text
+EPTF_LwM2M_Tests.tc_write_resource_float_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_write_resource_float_using_senml_json
+EPTF_LwM2M_Tests.tc_write_resource_int_using_text
+EPTF_LwM2M_Tests.tc_write_resource_int_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_write_resource_int_using_senml_json
+EPTF_LwM2M_Tests.tc_write_resource_string_using_text
+EPTF_LwM2M_Tests.tc_write_resource_string_using_lwm2m_json
+EPTF_LwM2M_Tests.tc_write_resource_string_using_senml_json
+EPTF_LwM2M_Tests.tc_write_resource_block1_stateless_succ
+EPTF_LwM2M_Tests.tc_write_resource_block1_atomic_succ
+// Execute
 EPTF_LwM2M_Tests.tc_execute_resource
+// Observe
 EPTF_LwM2M_Tests.tc_observe_subscription
 EPTF_LwM2M_Tests.tc_observe_notification
 EPTF_LwM2M_Tests.tc_observe_unsubscribe
-//EPTF_LwM2M_Tests.tc_regDereg_againstLeshan
-//EPTF_LwM2M_Tests.tc_regDereg_againstLeshan_dtls // NOT OK
-//EPTF_LwM2M_Tests.tc_regDereg_againstLeshan_psk
-EPTF_LwM2M_Tests.tc_tlv_decoding_string
-EPTF_LwM2M_Tests.tc_write_resource_block1_stateless_succ
-EPTF_LwM2M_Tests.tc_write_block1_firmware_upgrade
+
+/*
+/////////////////////
+// Interop against Leshan
+/////////////////////
+EPTF_LwM2M_Tests.tc_regDereg_againstLeshan
+EPTF_LwM2M_Tests.tc_regDereg_againstLeshan_psk
+*/
diff --git a/test/EPTF_LwM2M_Tests.ttcn b/test/EPTF_LwM2M_Tests.ttcn
index 4975f5a..e837446 100644
--- a/test/EPTF_LwM2M_Tests.ttcn
+++ b/test/EPTF_LwM2M_Tests.ttcn
@@ -49,11 +49,13 @@
   import from LightweightM2M_Types all;
   import from LWM2M_TLV_Types all;
   import from LWM2M_TLV_EncDec all;
+  import from LWM2M_JSON_Types all;
+  import from LWM2M_JSON_EncDec all;
   import from IoT_FT_Framework_Definitions all;
   import from IoT_FT_Framework_Functions all;
   import from IFW_CoAP_Peer_Definitions all;
   import from IFW_CoAP_Peer_TestSteps all;
-  import from Socket_API_Definitions all;
+  import from EPTF_COAP_Transport_Definitions all;
   
   modulepar charstring tsp_SUT_localHost := "127.0.0.1";
   modulepar integer    tsp_SUT_localPort := 31111;
@@ -150,10 +152,10 @@
     vf_EPTF_LwM2M_Transport_receiveEvent := refers(f_EPTF_LwM2M_LGen_receiveEvent);
     
     var integer vl_addrIdx;
-    var ProtoTuple vl_proto := { udp := {} };
+    var EPTF_COAP_Transport vl_proto := { ip := { udp := {} } };
     
     if (p_useDTLS) {
-      vl_proto := { dtls := { udp := {} } };
+      vl_proto := { ip := { dtls := { udp := {} } } };
     }    
     
     f_EPTF_COAP_transportEndpointDB_add({ socket := {tsp_SUT_localHost, tsp_SUT_localPort}, proto := vl_proto }, vl_addrIdx);
@@ -261,6 +263,20 @@
     payload := *
   }
   
+  template CoAP_ReqResp tr_COAP_payload(Code p_code, template octetstring p_payload) :=
+  {  
+    header := 
+    {
+      version := 1,
+      msg_type := ?,
+      code := p_code,
+      message_id := ?
+    },
+    token := ?,
+    options := *,
+    payload := p_payload
+  }
+  
   template CoAP_ReqResp t_COAP_registered   :=
   {  
     header := 
@@ -293,7 +309,7 @@
     payload := omit
   }
   
-  template CoAP_ReqResp t_COAP_read :=
+  template CoAP_ReqResp t_COAP_read_resource_3303_0_5700(in integer p_accept) :=
   {
     header := 
     {
@@ -308,12 +324,89 @@
       { uri_path := "3303" },
       { uri_path := "0" },
       { uri_path := "5700" },
-      { accept := 11542 }
+      { accept := p_accept }
     },
     payload := omit
   }
   
-  template CoAP_ReqResp t_COAP_write :=
+  template CoAP_ReqResp t_COAP_read_resource_5_0_3(in integer p_accept) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_GET,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "5" },
+      { uri_path := "0" },
+      { uri_path := "3" },
+      { accept := p_accept }
+    },
+    payload := omit
+  }
+  
+  template CoAP_ReqResp t_COAP_read_resource_1_0_7(in integer p_accept) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_GET,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "1" },
+      { uri_path := "0" },
+      { uri_path := "7" },
+      { accept := p_accept }
+    },
+    payload := omit
+  }
+  
+  template CoAP_ReqResp t_COAP_read_object_instance(in integer p_accept) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_GET,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "5" },
+      { uri_path := "0" },
+      { accept := p_accept }
+    },
+    payload := omit
+  }
+  
+  template CoAP_ReqResp t_COAP_read_object(in integer p_accept) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_GET,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "5" },
+      { accept := p_accept }
+    },
+    payload := omit
+  }
+  
+  template CoAP_ReqResp t_COAP_write_3305_0_5806(integer p_format, octetstring p_payload) :=
   {
     header := 
     {
@@ -325,14 +418,52 @@
     token := ''O,
     options :=  
     {
-      { uri_path := "3303" },
+      { uri_path := "3305" },
       { uri_path := "0" },
-      { uri_path := "5700" },
-      { content_format := 11543 }
+      { uri_path := "5806" },
+      { content_format := p_format }
     },
-    payload := char2oct(
-    "{\"e\":[ {\"n\":\"\", \"v\": 36.2 } ] }"
-    )
+    payload := p_payload
+  }
+  
+  template CoAP_ReqResp t_COAP_write_1_0_1(integer p_format, octetstring p_payload) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_PUT,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "1" },
+      { uri_path := "0" },
+      { uri_path := "1" },
+      { content_format := p_format }
+    },
+    payload := p_payload
+  }
+  
+  template CoAP_ReqResp t_COAP_write_1_0_7(integer p_format, octetstring p_payload) :=
+  {
+    header := 
+    {
+      version := 1,
+      msg_type := CONFIRMABLE,
+      code := METHOD_PUT,
+      message_id := 0
+    },
+    token := ''O,
+    options :=  
+    {
+      { uri_path := "1" },
+      { uri_path := "0" },
+      { uri_path := "7" },
+      { content_format := p_format }
+    },
+    payload := p_payload
   }
   
   template CoAP_ReqResp t_COAP_execute :=
@@ -538,10 +669,17 @@
     f_MBT_execute(c_COAP_stepName_reportCoapEventForEntity, valueof(t_addr(0, 0)), {c_COAP_stepParam_false}, false);
     
     f_MBT_execute(c_LwM2M_stepName_createDevice, valueof(t_addr(0, 0)), {}, false);
-    f_MBT_execute(c_LwM2M_stepName_createObject, valueof(t_addr(0, 0)), {c_LwM2M_Temperature_obj_id}, false);
-    f_MBT_execute(c_LwM2M_stepName_createObjectInstance, valueof(t_addr(0, 0)), {c_LwM2M_Temperature_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObject, valueof(t_addr(0, 0)), {c_LwM2M_Server_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObjectInstance, valueof(t_addr(0, 0)), {c_LwM2M_Server_obj_id}, false);
     f_MBT_execute(c_LwM2M_stepName_createObject, valueof(t_addr(0, 0)), {c_LwM2M_FirmwareUpdate_obj_id}, false);
     f_MBT_execute(c_LwM2M_stepName_createObjectInstance, valueof(t_addr(0, 0)), {c_LwM2M_FirmwareUpdate_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObject, valueof(t_addr(0, 0)), {c_LwM2M_Temperature_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObjectInstance, valueof(t_addr(0, 0)), {c_LwM2M_Temperature_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObject, valueof(t_addr(0, 0)), {c_LwM2M_PowerMeasurement_obj_id}, false);
+    f_MBT_execute(c_LwM2M_stepName_createObjectInstance, valueof(t_addr(0, 0)), {c_LwM2M_PowerMeasurement_obj_id}, false);
+    
+    // content formats: text, senml json, lwm2m json:
+    f_MBT_execute(c_LwM2M_stepName_setContentFormats, valueof(t_addr(0, 0)), {0, 110, 11543}, false);
   }
   
   function f_registration(integer peer) runs on LWM2M_FSM_CT
@@ -668,16 +806,6 @@
     f_LWM2M_Tests_end();
   }
 
-  ///////////////////////////////////////////////////////////
-  //
-  // Testcase: tc_registration_dtls
-  //
-  // Purpose:
-  //     Testcase for registering an LWM2M device using DTLS
-  //
-  // Action:
-  //     (see EPTF_LwM2M_Tests.tc_registration_dtls.jpg)
-  ///////////////////////////////////////////////////////////
   /*****************************************************************
   *     @startuml EPTF_LwM2M_Tests.tc_registration_dtls.jpg
   *     ref over Applib, Peer: tc_initialization
@@ -692,6 +820,7 @@
   *     FSM -> Applib: c_COAP_stepName_cleanUp()
   *     @enduml
   ******************************************************************/
+  /*
   testcase tc_registration_dtls() runs on LWM2M_FSM_CT
   {
     f_LWM2M_Tests_begin(p_useDTLS := true);
@@ -714,6 +843,7 @@
 
     f_LWM2M_Tests_end();
   }
+  */
 
   ///////////////////////////////////////////////////////////
   //
@@ -757,27 +887,27 @@
 
   ///////////////////////////////////////////////////////////
   //
-  // Testcase: tc_read_resource
+  // Testcase: tc_read_resource_float_using_text
   //
   // Purpose:
-  //     Testcase for reading a resource value
+  //     Testcase for reading a float resource value with LwM2M JSON encoding
   //
   // Action:
-  //     (see EPTF_LwM2M_Tests.tc_read_resource.jpg)
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_float_using_text.jpg)
   ///////////////////////////////////////////////////////////
   /*****************************************************************
-  *     @startuml EPTF_LwM2M_Tests.tc_read_resource.jpg
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_float_using_text.jpg
   *     ref over Applib, Peer: tc_initialization
   *     ref over Applib, Peer: tc_registration
-  *     Peer -> Applib: COAP GET 3303/0/5700
+  *     Peer -> Applib: COAP GET 3303/0/5700 (plain/text)
   *     FSM <- Applib: c_LwM2M_eventName_Read
   *     FSM -> Applib: c_COAP_stepName_handleRequest
   *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
-  *     Peer <- Applib: COAP 205 content
+  *     Peer <- Applib: COAP 205 content (float, plain/text)
   *     FSM -> Applib: c_COAP_stepName_cleanUp()
   *     @enduml
   ******************************************************************/
-  testcase tc_read_resource() runs on LWM2M_FSM_CT
+  testcase tc_read_resource_float_using_text() runs on LWM2M_FSM_CT
   {
     f_LWM2M_Tests_begin();
 
@@ -788,7 +918,301 @@
     f_initialization();
     f_registration(peer);
 
-    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_3303_0_5700(0)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_float_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for reading a float resource value with LwM2M JSON encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_float_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_float_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 3303/0/5700 (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (float, LwM2M JSON)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_float_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_3303_0_5700(11543)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_float_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for reading a float resource value with SenML JSON encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_float_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_float_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 3303/0/5700 (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (float, SenML JSON)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_float_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_3303_0_5700(110)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_int_using_text
+  //
+  // Purpose:
+  //     Testcase for reading an integer resource value with text encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_int_using_text.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_int_using_text.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 5/0/3 (plain/text)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (int, plain/text)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_int_using_text() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_5_0_3(0)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, char2oct("0"))));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_int_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for reading an integer resource value with lwm2m json encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_int_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_int_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 5/0/3 (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (int, LwM2M JSON)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_int_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_5_0_3(11543)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_int_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for reading an integer resource value with SenML json encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_int_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_int_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 5/0/3 (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (int, SenML JSON)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_int_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_5_0_3(110)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_string_using_text
+  //
+  // Purpose:
+  //     Testcase for reading a string resource value with text/plain encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_string_using_text.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_string_using_text.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 1/0/7 (text plain)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (string, text plain)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_string_using_text() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_1_0_7(0)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
     f_IFW_CoapPeer_send(peer);
 
     f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
@@ -806,27 +1230,27 @@
 
   ///////////////////////////////////////////////////////////
   //
-  // Testcase: tc_write_resource
+  // Testcase: tc_read_resource_string_lwm2m_json
   //
   // Purpose:
-  //     Testcase for writing a resource value
+  //     Testcase for reading a string resource value with LwM2M JSON encoding
   //
   // Action:
-  //     (see EPTF_LwM2M_Tests.tc_write_resource.jpg)
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_string_lwm2m_json.jpg)
   ///////////////////////////////////////////////////////////
   /*****************************************************************
-  *     @startuml EPTF_LwM2M_Tests.tc_write_resource.jpg
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_string_lwm2m_json.jpg
   *     ref over Applib, Peer: tc_initialization
   *     ref over Applib, Peer: tc_registration
-  *     Peer -> Applib: COAP PUT 3303/0/5700 200 (JSON)
-  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     Peer -> Applib: COAP GET 1/0/7 (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
   *     FSM -> Applib: c_COAP_stepName_handleRequest
-  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
-  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (string, LwM2M JSON)
   *     FSM -> Applib: c_COAP_stepName_cleanUp()
   *     @enduml
   ******************************************************************/
-  testcase tc_write_resource() runs on LWM2M_FSM_CT
+  testcase tc_read_resource_string_lwm2m_json() runs on LWM2M_FSM_CT
   {
     f_LWM2M_Tests_begin();
 
@@ -837,7 +1261,524 @@
     f_initialization();
     f_registration(peer);
 
-    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_1_0_7(11543)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_resource_string_senlm_json
+  //
+  // Purpose:
+  //     Testcase for reading a string resource value with SenML JSON encoding
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_resource_string_senlm_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_resource_string_senlm_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 1/0/7 (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content (string, SenML JSON)
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_resource_string_senlm_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_resource_1_0_7(110)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_float_using_text
+  //
+  // Purpose:
+  //     Testcase for writing a float resource value using plain/text
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_float_using_text.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_float_using_text.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 3305/0/5806 36.2 (text)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_float_using_text() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_3305_0_5806(
+    0,
+    char2oct("36.2")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_float_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for writing a float resource value using LwM2M JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_float_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_float_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 3305/0/5806 36.2 (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_float_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_3305_0_5806(
+    11543,
+    char2oct("{\"e\":[ {\"n\":\"\", \"v\": 36.2 } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_float_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for writing a float resource value using SenML JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_float_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_float_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 3305/0/5806 36.2 (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_float_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_3305_0_5806(
+    110,
+    char2oct("[{\"n\":\"/3305/0/5806\", \"v\": 36.2 } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_int_using_text
+  //
+  // Purpose:
+  //     Testcase for writing an integer resource value using plain/text
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_int_using_text.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_int_using_text.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/1 60 (text)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_int_using_text() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_1(
+    0,
+    char2oct("60")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_int_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for writing an int resource value using LwM2M JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_int_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_int_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/1 60 (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_int_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_1(
+    11543,
+    char2oct("{\"e\":[ {\"n\":\"\", \"v\": 60 } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_int_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for writing an int resource value using SenML JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_int_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_int_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/1 60 (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_int_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_1(
+    110,
+    char2oct("[{\"n\":\"/1/0/1\", \"v\": 60 } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_string_using_text
+  //
+  // Purpose:
+  //     Testcase for writing a string resource value using plain/text
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_string_using_text.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_string_using_text.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/7 UQ (text)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_string_using_text() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_7(
+    0,
+    char2oct("UQ")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_string_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for writing a string resource value using LwM2M JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_string_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_string_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/7 UQ (LwM2M JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_string_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_7(
+    11543,
+    char2oct("{\"e\":[ {\"n\":\"\", \"sv\": \"UQ\" } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleWriteRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP(RESPONSE_CODE_Changed)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_write_resource_string_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for writing a string resource value using SenML JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_string_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_string_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP PUT 1/0/7 UQ (SenML JSON)
+  *     FSM <- Applib: c_LwM2M_eventName_Write
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleWriteRequest
+  *     Peer <- Applib: COAP Response 204 changed
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_write_resource_string_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_write_1_0_7(
+    110,
+    char2oct("[{\"n\":\"/1/0/7\", \"vs\": \"UQ\" } ] }")
+    )), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
     f_IFW_CoapPeer_send(peer);
 
     f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Write, t_addr(0, ?), 3.0));
@@ -904,6 +1845,202 @@
 
   ///////////////////////////////////////////////////////////
   //
+  // Testcase: tc_read_object_instance_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for reading an object instance using LwM2M JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_object_instance_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_object_instance_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 5/0
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_object_instance_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_object_instance(11543)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_object_instance_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for reading an object instance using SenML JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_object_instance_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_object_instance_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET 5/0
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_object_instance_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_object_instance(110)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_object_using_lwm2m_json
+  //
+  // Purpose:
+  //     Testcase for reading an object using LwM2M JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_object_using_lwm2m_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_object_using_lwm2m_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET /5
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_object_using_lwm2m_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_object(11543)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
+  // Testcase: tc_read_object_using_senml_json
+  //
+  // Purpose:
+  //     Testcase for reading an object using SenML JSON
+  //
+  // Action:
+  //     (see EPTF_LwM2M_Tests.tc_read_object_using_senml_json.jpg)
+  ///////////////////////////////////////////////////////////
+  /*****************************************************************
+  *     @startuml EPTF_LwM2M_Tests.tc_read_object_using_senml_json.jpg
+  *     ref over Applib, Peer: tc_initialization
+  *     ref over Applib, Peer: tc_registration
+  *     Peer -> Applib: COAP GET /5
+  *     FSM <- Applib: c_LwM2M_eventName_Read
+  *     FSM -> Applib: c_COAP_stepName_handleRequest
+  *     FSM -> Applib: c_LwM2M_stepName_handleReadRequest
+  *     Peer <- Applib: COAP 205 content
+  *     FSM -> Applib: c_COAP_stepName_cleanUp()
+  *     @enduml
+  ******************************************************************/
+  testcase tc_read_object_using_senml_json() runs on LWM2M_FSM_CT
+  {
+    f_LWM2M_Tests_begin();
+
+    var integer peer := f_IFW_addComponent(COAP_PEER, "tester");
+    f_IFW_CoapPeer_setRemote(peer, "sut");
+    f_IFW_initComponents();
+
+    f_initialization();
+    f_registration(peer);
+
+    f_IFW_CoapPeer_setMessageToSend(peer, valueof(t_COAP_read_object(110)), GENERATE_NEW_MID, GENERATE_NEW_TOKEN);
+    f_IFW_CoapPeer_send(peer);
+
+    f_handleVerdict(f_MBT_waitFor(c_LwM2M_behaviorType, c_LwM2M_eventName_Read, t_addr(0, ?), 3.0));
+
+    f_MBT_execute(c_COAP_stepName_handleRequest, valueof(t_addr(0, 0)), {}, false);
+    f_MBT_execute(c_LwM2M_stepName_handleReadRequest, valueof(t_addr(0, 0)), {}, false);
+
+    f_IFW_CoapPeer_receive(peer);
+    f_handleVerdict(f_IFW_CoapPeer_check(peer, tr_COAP_payload(RESPONSE_CODE_Content, ?)));
+
+    f_MBT_execute(c_COAP_stepName_cleanUp, valueof(t_addr(0, 0)), {}, false);
+
+    f_LWM2M_Tests_end();
+  }
+
+  ///////////////////////////////////////////////////////////
+  //
   // Testcase: tc_observe_subscription
   //
   // Purpose:
@@ -1111,16 +2248,6 @@
     f_LWM2M_Tests_end();
   }
 
-  ///////////////////////////////////////////////////////////
-  //
-  // Testcase: tc_regDereg_againstLeshan_dtls
-  //
-  // Purpose:
-  //     Testcase for registering and then deregistering an LWM2M device using an external Leshan LwM2M server (DTLS transport)
-  //
-  // Action:
-  //     (see EPTF_LwM2M_Tests.tc_regDereg_againstLeshan.jpg)
-  ///////////////////////////////////////////////////////////
   /*****************************************************************
   *     @startuml EPTF_LwM2M_Tests.tc_regDereg_againstLeshan.jpg
   *     ref over Applib, Peer: tc_initialization(c_LeshanCoapsAddr)
@@ -1141,6 +2268,7 @@
   *     FSM -> Applib: c_COAP_stepName_cleanUp()
   *     @enduml
   ******************************************************************/
+  /*
   testcase tc_regDereg_againstLeshan_dtls() runs on LWM2M_FSM_CT
   {
     f_LWM2M_Tests_begin(p_useDTLS := true);
@@ -1158,6 +2286,7 @@
 
     f_LWM2M_Tests_end();
   }
+  */
 
   ///////////////////////////////////////////////////////////
   //
@@ -1214,28 +2343,6 @@
     f_LWM2M_Tests_end();
   }
   
-  testcase tc_tlv_decoding_string() runs on LWM2M_FSM_CT
-  {
-    var octetstring v_oct :=
-    'C801D568747470733A2F2F6D65617339756B37766F706966656C686E2E626C6F622E636F72652E77696E646F77732E6E65742F6677732F34313137383832392D333634312D343234372D623637352D3739393934643666316639313F73763D323031362D30352D33312673723D63267369673D43475833253246415A79786B66675A79474970716D474161595763526D436B5563476A4A42446A377138314F342533442673743D323031382D31302D30325430303A30303A30305A2673653D323031382D31302D30345430303A30303A30305A2673703D72'O;
-
-    var LWM2M_TLV_Resources v_tlv_resources := {};
-    v_tlv_resources := f_dec_LwM2M_TLV_Resources(v_oct);
-    log("v_tlv_resources: ", v_tlv_resources);
-    
-    var LwM2M_Resource_List v_resources := {}
-    v_resources := f_LwM2M_TLV_Resources_toResources(v_tlv_resources, {"5","0","1"});    
-    
-    log("decoded resources", v_resources);
-    
-    if (match(v_resources[0], t_lwm2m_str_resource(5,0,1)))
-    { setverdict(pass) }
-    else { setverdict(fail)}
-  }
-  
-  template LwM2M_Resource t_lwm2m_str_resource(integer p_obj, integer p_inst, integer p_id) :=
-  { id := p_id, objId := p_obj, objInstId := p_inst, observed := ?, dataSample := omit, val := { strValue := ? } }
-
 /*
   SUT: Block1 server
     - recv: Write (block1) stateless, succ
@@ -1338,16 +2445,16 @@
 
   ///////////////////////////////////////////////////////////
   //
-  // Testcase: tc_write_block1_firmware_upgrade
+  // Testcase: tc_write_resource_block1_atomic_succ
   //
   // Purpose:
   //     Testcase for writing a resource value using atomic block1
   //
   // Action:
-  //     (see EPTF_LwM2M_Tests.tc_write_block1_firmware_upgrade.jpg)
+  //     (see EPTF_LwM2M_Tests.tc_write_resource_block1_atomic_succ.jpg)
   ///////////////////////////////////////////////////////////
   /*****************************************************************
-  *     @startuml EPTF_LwM2M_Tests.tc_write_block1_firmware_upgrade.jpg
+  *     @startuml EPTF_LwM2M_Tests.tc_write_resource_block1_atomic_succ.jpg
   *     ref over Applib, Peer: tc_initialization
   *     ref over Applib, Peer: tc_registration
   *     FSM -> Applib: c_LwM2M_stepName_setBlock1Handling_atomic
@@ -1365,7 +2472,7 @@
   *     FSM -> Applib: c_COAP_stepName_cleanUp()
   *     @enduml
   ******************************************************************/ 
-  testcase tc_write_block1_firmware_upgrade() runs on LWM2M_FSM_CT
+  testcase tc_write_resource_block1_atomic_succ() runs on LWM2M_FSM_CT
   {
     f_LWM2M_Tests_begin();
 
@@ -1418,19 +2525,165 @@
 
     f_LWM2M_Tests_end();
   }
+  
+  testcase tc_tlv_decoding_string() runs on LWM2M_FSM_CT
+  {
+    var octetstring v_oct :=
+    'C801D568747470733A2F2F6D65617339756B37766F706966656C686E2E626C6F622E636F72652E77696E646F77732E6E65742F6677732F34313137383832392D333634312D343234372D623637352D3739393934643666316639313F73763D323031362D30352D33312673723D63267369673D43475833253246415A79786B66675A79474970716D474161595763526D436B5563476A4A42446A377138314F342533442673743D323031382D31302D30325430303A30303A30305A2673653D323031382D31302D30345430303A30303A30305A2673703D72'O;
 
+    var LWM2M_TLV_Resources v_tlv_resources := {};
+    v_tlv_resources := f_dec_LwM2M_TLV_Resources(v_oct);
+    log("v_tlv_resources: ", v_tlv_resources);
+    
+    var LwM2M_Resource_List v_resources := {}
+    v_resources := f_LwM2M_TLV_Resources_toResources(v_tlv_resources, {"5","0","1"});    
+    
+    log("decoded resources", v_resources);
+    
+    if (match(v_resources[0], t_lwm2m_str_resource(5,0,1)))
+    { setverdict(pass) }
+    else { setverdict(fail)}
+  }
+  
+  template LwM2M_Resource t_lwm2m_str_resource(integer p_obj, integer p_inst, integer p_id) :=
+  { id := p_id, objId := p_obj, objInstId := p_inst, observed := ?, dataSample := omit, spec :=?, contentFormat := *, val := { strValue := ? } }
+  
+  testcase tc_encdec_LwM2M_JSON_Resources_to_oct() runs on LWM2M_FSM_CT
+  {
+    log("data: ",t_lwm2m_json_resources);
+    
+    var octetstring v_encoded := f_enc_LwM2M_JSON_Resources(valueof(t_lwm2m_json_resources));
+    
+    log("encoded: ", oct2char(v_encoded), "\n", v_encoded);
+      
+    var LwM2M_JSON_Resources v_decoded := f_dec_LwM2M_JSON_Resources(v_encoded);
+      
+    if (match(v_decoded, t_lwm2m_json_resources)) { setverdict(pass)}
+    else { setverdict(fail) }
+  }
+  
+  template LwM2M_JSON_Resources t_lwm2m_json_resources :=
+  {
+    bn := "/",
+    e := {
+      { n := "1", v := omit, bv := omit, sv := "sg", ov := omit },
+      { n := "7/1", v := omit, bv := true, sv := omit, ov := omit },
+      { n := "11/0/1", v := { f := 4.0 }, bv := omit, sv := omit, ov := omit },
+      { n := "14/0/1", v := { i := 5 }, bv := omit, sv := omit, ov := omit },
+      { n := "14/0/1", v := omit, bv := omit, sv := omit, ov := "01020304" }
+    }
+  }
+  
+  testcase tc_encdec_SenML_JSON_Resources_to_oct() runs on LWM2M_FSM_CT
+  {
+    log("data: ", t_senml_json_resources);
+    
+    var octetstring v_encoded := f_enc_SenML_JSON_Resources(valueof(t_senml_json_resources));
+    
+    log("encoded: ", oct2char(v_encoded), "\n", v_encoded);
+      
+    var SenML_JSON_Resources v_decoded := f_dec_SenML_JSON_Resources(v_encoded);
+      
+    if (match(v_decoded, t_senml_json_resources)) { setverdict(pass)}
+    else { setverdict(fail) }
+  }
+  
+  template SenML_JSON_Resources t_senml_json_resources :=
+  {
+    { bn := "/4/0", n := "1", v := omit, vb := omit, vs := "sg", vd := omit },
+    { bn := omit, n := "2", v := omit, vb := true, vs := omit, vd := omit },
+    { bn := omit, n := "11", v := { f := 4.0 }, vb := omit, vs := omit, vd := omit },
+    { bn := omit, n := "14", v := { i := 4 }, vb := omit, vs := omit, vd := omit },
+    { bn := omit, n := "15", v := omit, vb := omit, vs := omit, vd := "01020304" }
+  }
+  
+  testcase tc_encdec_LwM2M_Resources_to_oct_using_LwM2M_JSON() runs on LWM2M_FSM_CT
+  {
+    log("resources: ", t_lwm2m_resources);
+    
+    var octetstring v_encoded := f_enc_LwM2M_Resources_to_LwM2M_JSON(valueof(t_lwm2m_resources));
+    
+    log("encoded: ", oct2char(v_encoded), "\n", v_encoded);
+      
+    var LwM2M_Resource_List v_decoded := {};
+        
+    f_dec_LwM2M_Resources_from_LwM2M_JSON(v_encoded, v_decoded);
+    
+    log("decoded: ", v_decoded);
+      
+    if (match(v_decoded, t_lwm2m_resources)) { setverdict(pass)}
+    else { setverdict(fail) }
+  }
+  
+  testcase tc_encdec_LwM2M_Resources_to_oct_using_SenML_JSON() runs on LWM2M_FSM_CT
+  {
+    log("resources: ", t_lwm2m_resources);
+    
+    var octetstring v_encoded := f_enc_LwM2M_Resources_to_SenML_JSON(valueof(t_lwm2m_resources));
+    
+    log("encoded: ", oct2char(v_encoded), "\n", v_encoded);
+      
+    var LwM2M_Resource_List v_decoded := {};
+        
+    f_dec_LwM2M_Resources_from_SenML_JSON(v_encoded, v_decoded);
+    
+    log("decoded: ", v_decoded);
+      
+    if (match(v_decoded, t_lwm2m_resources)) { setverdict(pass)}
+    else { setverdict(fail) }
+  }
+  
+  template LwM2M_Resource_List t_lwm2m_resources :=
+  {
+    t_LwM2M_Resource_init(1,0,1,{ strValue := "sg" }),
+    t_LwM2M_Resource_init(1,0,2,{ boolValue := true }),
+    t_LwM2M_Resource_init(1,0,3,{ floatValue := 4.0 }),
+    t_LwM2M_Resource_init(1,0,4,{ intValue := 5 }),
+    t_LwM2M_Resource_init(1,0,5,{ opaqueValue := '01020304'O })
+  }
+  
   control
   {
+    execute(tc_tlv_decoding_string());
+    execute(tc_encdec_LwM2M_JSON_Resources_to_oct());
+    execute(tc_encdec_SenML_JSON_Resources_to_oct());
+    execute(tc_encdec_LwM2M_Resources_to_oct_using_LwM2M_JSON());
+    execute(tc_encdec_LwM2M_Resources_to_oct_using_SenML_JSON());
+    
     execute(tc_initialization());
     execute(tc_registration());
     execute(tc_deregistration());
-    execute(tc_read_resource());
-    execute(tc_write_resource());
+    
+    execute(tc_read_resource_float_using_text());
+    execute(tc_read_resource_float_using_lwm2m_json());
+    execute(tc_read_resource_float_using_senml_json());
+    execute(tc_read_resource_int_using_text());
+    execute(tc_read_resource_int_using_lwm2m_json());
+    execute(tc_read_resource_int_using_senml_json());
+    execute(tc_read_resource_string_using_text());
+    execute(tc_read_resource_string_lwm2m_json());
+    execute(tc_read_resource_string_senlm_json());
+    execute(tc_read_object_instance_using_lwm2m_json());
+    execute(tc_read_object_instance_using_senml_json());
+    execute(tc_read_object_using_lwm2m_json());
+    execute(tc_read_object_using_senml_json());
+    
+    execute(tc_write_resource_float_using_text());
+    execute(tc_write_resource_float_using_lwm2m_json());
+    execute(tc_write_resource_float_using_senml_json());
+    execute(tc_write_resource_int_using_text());
+    execute(tc_write_resource_int_using_lwm2m_json());
+    execute(tc_write_resource_int_using_senml_json());
+    execute(tc_write_resource_string_using_text());
+    execute(tc_write_resource_string_using_lwm2m_json());
+    execute(tc_write_resource_string_using_senml_json());
+    execute(tc_write_resource_block1_stateless_succ());
+    execute(tc_write_resource_block1_atomic_succ());
+    
     execute(tc_execute_resource());
+    
     execute(tc_observe_subscription());
     execute(tc_observe_notification());
     execute(tc_observe_unsubscribe());
-    execute(tc_write_resource_block1_stateless_succ());
-    execute(tc_write_block1_firmware_upgrade());
   }
 }
