///////////////////////////////////////////////////////////////////////////////
//
// 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_Functions.ttcn
//  Description:
//  Rev:                R1A
//  Prodnr:             CNL 113 859
//  Updated:            2020-03-04
//  Contact:            http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: EPTF_LwM2M_Object_Functions
// 
//  Purpose:
//    This module contains the functions of the smart object definitions for the LWM2M load generator component
//
//  See also:
//    <EPTF_COAP_LGen_Definitions>
///////////////////////////////////////////////////////////////
module EPTF_LwM2M_Object_Functions {

  import from LightweightM2M_Types all;
  import from EPTF_LwM2M_Object_Definitions all;
  import from EPTF_CLL_HashMapInt2Int_Functions all;
  import from EPTF_CLL_HashMapStr2Int_Functions all;
    
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectSpecificationDB_init
  //
  //  Purpose:
  //    Initializes the <LwM2M_ObjectSpecificationDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
  //    p_id - *in integer* - unique id for the instance
  //
  //  Related Type:
  //    <LwM2M_ObjectSpecificationDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectSpecificationDB_init(inout LwM2M_ObjectSpecificationDB p_db, in integer p_id)
  {
    p_db := c_LwM2M_ObjectSpecificationDB_init;
    p_db.id := p_id;
    p_db.hashRef := f_EPTF_int2int_HashMap_New("EPTF_LwM2M_ObjectSpecificationDB_"&int2str(p_id)&"_Hash");
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectSpecificationDB_cleanUp
  //
  //  Purpose:
  //    Cleans up the reserved resources of the <LwM2M_ObjectSpecificationDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
  //
  //  Related Type:
  //    <LwM2M_ObjectSpecificationDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectSpecificationDB_cleanUp(inout LwM2M_ObjectSpecificationDB p_db)
  {
    f_EPTF_int2int_HashMap_Delete("EPTF_LwM2M_ObjectSpecificationDB_"&int2str(p_db.id)&"_Hash");
    p_db := c_LwM2M_ObjectSpecificationDB_init;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectSpecificationDB_add
  //
  //  Purpose:
  //    Adds a new <LwM2M_ObjectSpecification> element to the <LwM2M_ObjectSpecificationDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
  //    p_spec - <LwM2M_ObjectSpecification> - new element
  //
  //  Related Type:
  //    <LwM2M_ObjectSpecificationDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectSpecificationDB_add(inout LwM2M_ObjectSpecificationDB p_db, LwM2M_ObjectSpecification p_spec)
  return integer
  {
    var integer vl_idx := -1;
    if (not f_EPTF_int2int_HashMap_Find(p_db.hashRef, p_spec.id, vl_idx))
    {
      vl_idx := sizeof(p_db.specs);
      p_db.specs[vl_idx] := p_spec;
      f_EPTF_int2int_HashMap_Insert(p_db.hashRef, p_spec.id, vl_idx);
    }
    return vl_idx;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectSpecificationDB_lookUp
  //
  //  Purpose:
  //    Gets the index of a <LwM2M_ObjectSpecification> element in the <LwM2M_ObjectSpecificationDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
  //    p_objId - *integer* - obj id of the <LwM2M_ObjectSpecification> to be retrieved
  //
  //  Returns:
  //    *integer* - the index of the looked up element in the database, or -1 if not found
  //
  //  Related Type:
  //    <LwM2M_ObjectSpecificationDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectSpecificationDB_lookUp(in LwM2M_ObjectSpecificationDB p_db, in integer p_objId)
  return integer
  {
    var integer vl_idx := -1;
    if (f_EPTF_int2int_HashMap_Find(p_db.hashRef, p_objId, vl_idx)) {
      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;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs
  //
  //  Purpose:
  //    Loads known OMA related <LwM2M_ObjectSpecification> elements into the <LwM2M_ObjectSpecificationDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectSpecificationDB> - DB instance
  //
  //  Related Type:
  //    <LwM2M_ObjectSpecificationDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(inout LwM2M_ObjectSpecificationDB p_db)
  {
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_Security_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_Server_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_Device_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_Location_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_FirmwareUpdate_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_IPSO_Temperature_spec);
    f_LwM2M_ObjectSpecificationDB_add(p_db, c_LwM2M_PowerMeasurement_spec);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_init
  //
  //  Purpose:
  //    Initializes the <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectDB> - DB instance
  //    p_id - *in integer* - unique id for the instance
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_init(inout LwM2M_ObjectDB p_db, in integer p_id)
  {
    p_db := c_LwM2M_ObjectDB_init;
    p_db.id := p_id;
    p_db.objHashRef := f_EPTF_int2int_HashMap_New("EPTF_LwM2M_ObjectDB_"&int2str(p_db.id)&"_objHash");    
    p_db.resHashRef := f_EPTF_str2int_HashMap_New("EPTF_LwM2M_ObjectDB_"&int2str(p_db.id)&"_resHash");
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_cleanUp
  //
  //  Purpose:
  //    Cleans up the reserved resources of the <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectDB> - DB instance
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_cleanUp(inout LwM2M_ObjectDB p_db)
  {
    if (p_db.id >= 0)
    {
      f_EPTF_int2int_HashMap_Delete("EPTF_LwM2M_ObjectDB_"&int2str(p_db.id)&"_objHash");
      f_EPTF_str2int_HashMap_Delete("EPTF_LwM2M_ObjectDB_"&int2str(p_db.id)&"_resHash");
      p_db := c_LwM2M_ObjectDB_init;
    }  
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_createObject
  //
  //  Purpose:
  //    Creates a new instance of a <LwM2M_Object> and adds it to the <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_ObjectDB> - DB instance
  //    p_spec - *in* <LwM2M_ObjectSpecification> - specification of the smart object to be instantiated
  //
  //  Returns:
  //    *integer* - the index of the <LwM2M_Object> instance in the database
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_createObject(inout LwM2M_ObjectDB p_db, in LwM2M_ObjectSpecification p_spec)
  return integer
  {
    var integer vl_idx := -1;
    if (not f_EPTF_int2int_HashMap_Find(p_db.objHashRef, p_spec.id, vl_idx))
    {
      vl_idx := sizeof(p_db.objs);
      f_EPTF_int2int_HashMap_Insert(p_db.objHashRef, p_spec.id, vl_idx);
      p_db.objs[vl_idx] := c_LwM2M_Object_init;
      p_db.objs[vl_idx].id := p_spec.id;
    }
    return vl_idx;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getObject
  //
  //  Purpose:
  //    Retrieves an instance of a <LwM2M_Object> from a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_id - *in integer* - id of the smart object to be retrieved
  //
  //  Returns:
  //    p_obj - *inout* <LwM2M_Object> - the  retrieved <LwM2M_Object> instance
  //    *boolean* - true if the instance was found, false otherwise
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getObject(in LwM2M_ObjectDB p_db, in integer p_id, inout LwM2M_Object p_obj)
  return boolean
  {
    var integer vl_idx := f_LwM2M_ObjectDB_getObjectIdx(p_db, p_id);
    if (vl_idx >= 0)
    {
      p_obj := p_db.objs[vl_idx];
      return true;
    }
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getObjectIdx
  //
  //  Purpose:
  //    Retrieves the index of an instance of a <LwM2M_Object> from a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_id - *in integer* - id of the smart object to be retrieved
  //
  //  Returns:
  //    integer - index of an instance of a <LwM2M_Object> in a <LwM2M_ObjectDB> database
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getObjectIdx(in LwM2M_ObjectDB p_db, in integer p_id)
  return integer
  {
    var integer vl_idx := -1;
    if (f_EPTF_int2int_HashMap_Find(p_db.objHashRef, p_id, vl_idx))
    {
      return vl_idx;
    }
    return -1;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_createObjectInstance
  //
  //  Purpose:
  //    Creates an <LwM2M_ObjectInstance> of a <LwM2M_Object> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_id - *in integer* - id of the smart object to be instantiated
  //    p_spec_db - *in* <LwM2M_ObjectSpecificationDB> - object specification DB
  //    p_createResources - *in boolean* - should the func create the resource instances as well?
  //
  //  Returns:
  //    integer - index of an instance of a <LwM2M_ObjectInstance> in a <LwM2M_ObjectDB> database
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_createObjectInstance(inout LwM2M_ObjectDB p_db, in LwM2M_ObjectSpecificationDB p_spec_db, in integer p_id, in boolean p_createResources := true)
  return integer
  {
    var integer      vl_objIdx := -1
    var integer 	 vl_objInstIdx := -1;
    var integer		 vl_objSpecIdx := -1;
    
    vl_objIdx := f_LwM2M_ObjectDB_getObjectIdx(p_db, p_id);
    
    if (vl_objIdx >= 0)
    {
      vl_objSpecIdx := f_LwM2M_ObjectSpecificationDB_lookUp(p_spec_db, p_id);
      if (vl_objSpecIdx >= 0) 
      {
		vl_objInstIdx := sizeof(p_db.objs[vl_objIdx].instances);
		p_db.objs[vl_objIdx].instances[vl_objInstIdx] := c_LwM2M_ObjectInstance_init;
	    p_db.objs[vl_objIdx].instances[vl_objInstIdx].id := vl_objInstIdx;
    	p_db.objs[vl_objIdx].instances[vl_objInstIdx].objId := p_spec_db.specs[vl_objSpecIdx].id;
    	
    	// Creating resources according to spec
    	if (p_createResources) {
          var LwM2M_Resource v_res;
          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);
	  }
	}
      }
    }
    return vl_objInstIdx;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_createObjectInstance
  //
  //  Purpose:
  //    Links in an <LwM2M_Resource> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_resource - *in* <LwM2M_Resource> - smart resource instance
  //
  //  Returns:
  //    boolean - true if it was succesful
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_addResource(inout LwM2M_ObjectDB p_db, in LwM2M_Resource p_resource)
  return boolean
  {
    var integer vl_resIdx;
    if (not f_EPTF_str2int_HashMap_Find(p_db.resHashRef, f_LwM2M_resourceHash_forResource(p_resource), vl_resIdx))
    {
      var integer vl_objIdx := f_LwM2M_ObjectDB_getObjectIdx(p_db, p_resource.objId);
      if (vl_objIdx >= 0)
      {
        // Adding to resource array
     	vl_resIdx := sizeof(p_db.resources);
        p_db.resources[vl_resIdx] := p_resource;      
	    // Linking it under the object instance
        var integer vl_resIdxInObjInst := sizeof(p_db.objs[vl_objIdx].instances[p_resource.objInstId].resources);
        p_db.objs[vl_objIdx].instances[p_resource.objInstId].resources[vl_resIdxInObjInst] := vl_resIdx;
        // Adding it to the hash
        f_EPTF_str2int_HashMap_Insert(p_db.resHashRef, f_LwM2M_resourceHash_forResource(p_resource), vl_resIdx);
        return true;
      }
	}
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getObjectInstance
  //
  //  Purpose:
  //    Retrieves an <LwM2M_ObjectInstance> from a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //
  //  Returns:
  //    p_objInst - *inout* <LwM2M_ObjectInstance> - object instance
  //    boolean - if the instance was found
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getObjectInstance(in LwM2M_ObjectDB p_db, 
  	in integer p_objId, in integer p_objInstId, inout LwM2M_ObjectInstance p_objInst)
  return boolean
  {
    var integer vl_objIdx := f_LwM2M_ObjectDB_getObjectIdx(p_db, p_objId);
    if (vl_objIdx >= 0) {
      if (sizeof(p_db.objs[vl_objIdx].instances) > p_objInstId and p_objInstId >= 0) {
        p_objInst := p_db.objs[vl_objIdx].instances[p_objInstId];
        return true;
      }
	}
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getResource
  //
  //  Purpose:
  //    Retrieves an <LwM2M_Resource> from a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //    p_resourceId - *in integer* - resource id
  //
  //  Returns:
  //    p_resource - *inout* <LwM2M_Resource> - object instance
  //    boolean - if the instance was found
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getResource(in LwM2M_ObjectDB p_db, 
  	in integer p_objId, in integer p_objInstId, in integer p_resourceId, inout LwM2M_Resource p_resource)
  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_resource := p_db.resources[vl_resIdx];
      return true;
    }
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_setResource
  //
  //  Purpose:
  //    Updates the contents of an already linked in <LwM2M_Resource> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //    p_resourceId - *in integer* - resource id
  //    p_resource - *in* <LwM2M_Resource> - resource instance
  //
  //  Returns:
  //    boolean - if the instance was found
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_setResource(inout LwM2M_ObjectDB p_db, 
  	in integer p_objId, in integer p_objInstId, in integer p_resourceId, in LwM2M_Resource p_resource)
  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] := p_resource;
      return true;
    }
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getResourceValue
  //
  //  Purpose:
  //    Retrieves the <LwM2M_ResourceValue> of a <LwM2M_Resource> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //    p_resourceId - *in integer* - resource id
  //
  //  Returns:
  //    p_value - *inout* <LwM2M_ResourceValue> - resource value
  //    boolean - if the instance was found
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getResourceValue(in LwM2M_ObjectDB p_db, 
  	in integer p_objId, in integer p_objInstId, in integer p_resourceId, inout LwM2M_ResourceValue p_value)
  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_value := p_db.resources[vl_resIdx].val;
      return true;
    }
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_setResourceValue
  //
  //  Purpose:
  //    Sets the <LwM2M_ResourceValue> of an already linked in <LwM2M_Resource> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //    p_resourceId - *in integer* - resource id
  //    p_value - *in* <LwM2M_ResourceValue> - resource instance
  //
  //  Returns:
  //    boolean - if the instance was found
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_setResourceValue(inout LwM2M_ObjectDB p_db, 
  	in integer p_objId, in integer p_objInstId, in integer p_resourceId, in LwM2M_ResourceValue p_value)
  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].val := p_value;
      return true;
    }
    return false;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_setResourceObserved
  //
  //  Purpose:
  //    Sets the observation flag of an already linked in <LwM2M_Resource> in a <LwM2M_ObjectDB> database
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //    p_objId - *in integer* - object id
  //    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
  //
  //  Related Type:
  //    <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 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;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_ObjectDB_getObjectPaths
  //
  //  Purpose:
  //    Retrieves all the object paths <ObjectPath_List> that are stored in the <LwM2M_ObjectDB>
  //
  //  Parameters:
  //    p_db - *in* <LwM2M_ObjectDB> - DB instance
  //
  //  Returns:
  //    p_paths - *inout* <ObjectPath_List> - the pathes of the objects stored in the DB
  //
  //  Related Type:
  //    <LwM2M_ObjectDB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_ObjectDB_getObjectPaths(in LwM2M_ObjectDB p_db, inout ObjectPath_List p_paths)
  {
    if (p_db.id != -1) {
      for (var integer i:=0; i<sizeof(p_db.objs); i:=i+1) {
        // No instances for object
        if (sizeof(p_db.objs[i].instances)==0) {
          p_paths[sizeof(p_paths)] := {
            objectId := p_db.objs[i].id,
            objectInstanceId := omit,
            resourceId := omit
          }
        }
        // There are object instances
        else {
          for (var integer j:=0; j<sizeof(p_db.objs[i].instances); j:=j+1) {
            p_paths[sizeof(p_paths)] := {
              objectId := p_db.objs[i].id,
              objectInstanceId := p_db.objs[i].instances[j].id,
              resourceId := omit
            }
          }
        }
      }      
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_resourceHash_forResource
  //
  //  Purpose:
  //    Function to generate a unique key for the <LwM2M_Resource> instance
  //
  //  Parameters:
  //    p_res - *in* <LwM2M_Resource> - resource instance
  //
  //  Returns:
  //    charstring - unique hash for the <LwM2M_Resource>
  //
  //  Related Type:
  //    <LwM2M_Resource>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_resourceHash_forResource(in LwM2M_Resource p_res)
  return charstring
  {
    return int2str(p_res.objId) & "/" & int2str(p_res.objInstId) & "/" & int2str(p_res.id);
  }  
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_resourceHash_forIds
  //
  //  Purpose:
  //    Function to generate a unique key for <LwM2M_Resource> IDs
  //
  //  Parameters:
  //    p_objId - *in integer* - object id
  //    p_objInstId - *in integer* - object instance id
  //    p_resId - *in integer* - resource id
  //
  //  Returns:
  //    charstring - unique hash for the reource IDs
  //
  //  Related Type:
  //    <LwM2M_Resource>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_resourceHash_forIds(in integer p_objId, in integer p_objInstId, in integer p_resId)
  return charstring
  {
    return int2str(p_objId) & "/" & int2str(p_objInstId) & "/" & int2str(p_resId);
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_createResource
  //
  //  Purpose:
  //    Function to create an <LwM2M_Resource> instance based on a <LwM2M_ResourceSpecification> and link it into an <LwM2M_ObjectInstance>
  //
  //  Parameters:
  //    p_oi - *inout* <LwM2M_ObjectInstance> - object instance, where the rousrce will be added
  //    p_spec - *in* <LwM2M_ResourceSpecification> - resource specification for the instantiation
  //
  //  Returns:
  //    <LwM2M_Resource> - the create resource instance
  //
  //  Related Type:
  //    <LwM2M_Resource>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_createResource(inout LwM2M_ObjectInstance p_oi, in LwM2M_ResourceSpecification p_spec)
  return LwM2M_Resource
  {
    var LwM2M_Resource v_ret := c_LwM2M_Resource_init;
	  
    v_ret.id := p_spec.id;
	  	  
    v_ret.objId := p_oi.objId;
    v_ret.objInstId := p_oi.id;
	  
    if (p_spec.type_ == FLOAT or p_spec.type_ == TIME) {
      v_ret.val.floatValue := 0.0;
    }
    else if (p_spec.type_ == INTEGER) {
	  v_ret.val.intValue := 0;
    }
    else if (p_spec.type_ == STRING) {
	  v_ret.val.strValue := "";
    }
    else if (p_spec.type_ == OPAQUE) {
	  v_ret.val.opaqueValue := ''O;
    }
    else if (p_spec.type_ == BOOLEAN) {
	  v_ret.val.boolValue := false;
    }
	  
    return v_ret;
  }
  
  ///////////////////////////////////////////////////////////
  //  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:
  //    In case the <LwM2M_Resource> instance is associated with a <LwM2M_DataSamples> it will set its value to the next from the samples
  //
  //  Parameters:
  //    p_res - *inout* <LwM2M_Resource> - resource instance, where the value will be updated
  //    p_db - *in out* <LwM2M_DataSamples_DB> - DB where the samples are stored
  //
  //  Returns:
  //    <LwM2M_Resource> - with the updated value
  //
  //  Related Type:
  //    <LwM2M_Resource>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_Resource_setNextDataSample(inout LwM2M_Resource p_res, inout LwM2M_DataSamples_DB p_db)
  {
    if (ispresent(p_res.dataSample)) {
      // Init samplesPointer
      if (p_res.dataSample.samplesPointer == -1) {
        p_res.dataSample.samplesPointer := f_LwM2M_DataSamples_DB_lookUp(p_db, p_res.dataSample.samplesName);
      }
      // We found the dataSamples
      if (p_res.dataSample.samplesPointer >=0 and p_res.dataSample.samplesPointer < sizeof(p_db.data)) {
        // We have values
        if (sizeof(p_db.data[p_res.dataSample.samplesPointer].values)>0) {
          // Check value pointer boundaries
          if (p_res.dataSample.valuePointer < 0 or 
              p_res.dataSample.valuePointer >= sizeof(p_db.data[p_res.dataSample.samplesPointer].values))
          {
            // Outside of boundaries, set it to zero
            p_res.dataSample.valuePointer := 0;
          }
          // Set the value
          p_res.val := p_db.data[p_res.dataSample.samplesPointer].values[p_res.dataSample.valuePointer];
          // Step value pointer
          p_res.dataSample.valuePointer := p_res.dataSample.valuePointer+1;
        }
      }
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_DataSamples_DB_init
  //
  //  Purpose:
  //    Initializes a <LwM2M_DataSamples_DB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_DataSamples_DB> - DB instance
  //    p_name - *in charstring* - name for the DB instance
  //
  //  Related Type:
  //    <LwM2M_DataSamples_DB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_DataSamples_DB_init(inout LwM2M_DataSamples_DB p_db, in charstring p_name)
  {
    p_db.name := p_name;
    p_db.data := {};
    p_db.hashRef := f_EPTF_str2int_HashMap_New(p_name);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_DataSamples_DB_add
  //
  //  Purpose:
  //    Adds a new <LwM2M_DataSamples> element to a <LwM2M_DataSamples_DB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_DataSamples_DB> - DB instance
  //    p_samples - *in* <LwM2M_DataSamples> - element to be added
  //
  //  Related Type:
  //    <LwM2M_DataSamples_DB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_DataSamples_DB_add(inout LwM2M_DataSamples_DB p_db, in LwM2M_DataSamples p_samples)
  return integer
  {
    var integer p_idx := f_LwM2M_DataSamples_DB_lookUp(p_db, p_samples.name);

    if (p_idx == -1)
    {
      p_idx := sizeof(p_db.data);
      f_EPTF_str2int_HashMap_Insert(p_db.hashRef, p_samples.name, p_idx);
      p_db.data[p_idx] := p_samples;
    }
    
    return p_idx;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_DataSamples_DB_lookUp
  //
  //  Purpose:
  //    Looks up a <LwM2M_DataSamples> element from a <LwM2M_DataSamples_DB> database based on the samples' name
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_DataSamples_DB> - DB instance
  //    p_sampleName - *in charstring* - name of the sample to look up
  //
  //  Related Type:
  //    <LwM2M_DataSamples_DB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_DataSamples_DB_lookUp(inout LwM2M_DataSamples_DB p_db, in charstring p_sampleName)
  return integer
  {    
    var integer vl_idx := -1;
    f_EPTF_str2int_HashMap_Find(p_db.hashRef, p_sampleName, vl_idx);
    return vl_idx;
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_DataSamples_DB_get
  //
  //  Purpose:
  //    Retrieves a <LwM2M_DataSamples> element from a <LwM2M_DataSamples_DB> database based on its internal index
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_DataSamples_DB> - DB instance
  //    p_idx - *in integer* - index of the sample to be fetched
  //
  //  Returns:
  //    p_samples - *inout* <LwM2M_DataSamples> - retrieved element
  //
  //  Related Type:
  //    <LwM2M_DataSamples_DB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_DataSamples_DB_get(inout LwM2M_DataSamples_DB p_db, in integer p_idx, inout LwM2M_DataSamples p_samples)
  {
    if (p_idx < sizeof(p_db.data))
    {
      p_samples := p_db.data[p_idx];
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_LwM2M_DataSamples_DB_cleanUp
  //
  //  Purpose:
  //    Cleans up the reserved resources of a <LwM2M_DataSamples_DB> database
  //
  //  Parameters:
  //    p_db - *inout* <LwM2M_DataSamples_DB> - DB instance
  //
  //  Related Type:
  //    <LwM2M_DataSamples_DB>
  ///////////////////////////////////////////////////////////
  function f_LwM2M_DataSamples_DB_cleanUp(inout LwM2M_DataSamples_DB p_db)
  {
    p_db.data := {};
    f_EPTF_str2int_HashMap_Delete(p_db.name);
  }
}