///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2019 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                                 //
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//  Module: EPTF_CLL_StatManager_Functions
// 
//  Purpose:
//    This module contains function definitions for TTCN-3 EPTF StatManager 
//    implementation.
// 
//  Module Parameters:
//    
//
//  Module depends on:
//    <EPTF_CLL_DataSource_Definitions>
//    <EPTF_CLL_DataSource_Functions>
//    <EPTF_CLL_DataSourceClient_Functions>
//    <EPTF_CLL_StatManager_Definitions>
//    <EPTF_CLL_StatMeasure_Definitions>
//    <EPTF_CLL_StatMeasure_Functions>
//    <EPTF_CLL_Logging_Definitions>
//    <EPTF_CLL_Logging_Functions>
//    <EPTF_CLL_Base_Functions>
//    <EPTF_CLL_HashMapStr2Int_Functions>
//    <EPTF_CLL_Variable_Definitions>
//    <EPTF_CLL_Variable_Functions>
//
//  Public functions:
//    <f_EPTF_StatManager_init_CT>    
// 
//  Current Owner:
//    Balazs Lugossy (EBALLUG)
// 
//  Last Review Date:
//    
//
//  Detailed Comments:
//    This module contains function definitions for TTCN-3 EPTF StatManager 
//    implementation.
// 
///////////////////////////////////////////////////////////////////////////////

module EPTF_CLL_StatManager_Functions {

import from EPTF_CLL_DataSource_Definitions all;
import from EPTF_CLL_DataSource_Functions all;
import from EPTF_CLL_DataSourceClient_Functions all;
import from EPTF_CLL_StatManager_Definitions all;
import from EPTF_CLL_StatMeasure_Definitions all;
import from EPTF_CLL_StatMeasure_Functions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_HashMapStr2Int_Functions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Variable_Functions all;
import from EPTF_CLL_Common_Definitions all;

group ModulePars{
  modulepar boolean tsp_debug_EPTF_StatManager_Functions := false;
}//ModulePars


///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_init_CT
// 
//  Purpose:
//    Initializes the EPTF_StatManager_CT component
//
//  Parameters:
//    -
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//    This function should be called before using the <EPTF_StatManager_CT>
//    component.
//
///////////////////////////////////////////////////////////////////////////////
public function f_EPTF_StatManager_init_CT(
  in charstring pl_selfName,
  in EPTF_DataSource_CT pl_dataSourceCompRef := null) 
runs on EPTF_StatManager_CT 
{
  if (v_EPTF_StatManager_initialized) {
    return; // already initialized
  }

  f_EPTF_Logging_init_CT(pl_selfName);
  v_StatManager_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_StatManager_loggingComponentMask, c_EPTF_StatManager_loggingEventClasses, EPTF_Logging_CLL);
  if(tsp_debug_EPTF_StatManager_Functions) {
    f_EPTF_Logging_enableLocalMask(v_StatManager_loggingMaskId, c_EPTF_StatManager_loggingClassIdx_Debug);
  } else {
    f_EPTF_Logging_disableLocalMask(v_StatManager_loggingMaskId, c_EPTF_StatManager_loggingClassIdx_Debug);
  }
  //f_EPTF_Var_init_CT(pl_selfName);

  if (pl_dataSourceCompRef == null or pl_dataSourceCompRef == self) {
    pl_dataSourceCompRef := self;
    f_EPTF_DataSource_init_CT(pl_selfName);
  }
  f_EPTF_DataSourceClient_init_CT(pl_selfName, pl_dataSourceCompRef);
  f_EPTF_StatMeasure_init_CT(pl_selfName);
  f_EPTF_str2int_HashMap_Init(pl_selfName);

  v_EPTF_StatManager_limitStatVarsHashMap := f_EPTF_str2int_HashMap_New("StatManager_LimitStatVars");

  f_EPTF_DataSourceClient_registerData(c_StatManager_DataSource_sourceId, pl_selfName, refers(f_EPTF_StatManager_DSProcessData));
  f_EPTF_DataSourceClient_registerDataValue(c_StatManager_DataSource_sourceId, pl_selfName, refers(f_EPTF_StatManager_DSProcessDataValue));
  f_EPTF_DataSourceClient_sendReady(c_StatManager_DataSource_sourceId, f_EPTF_Base_selfName());

  v_EPTF_StatManager_initialized := true;

  f_EPTF_Base_registerCleanup(refers(f_EPTF_StatManager_cleanup_CT));

  f_EPTF_StatManager_debug(
    "---- EPTF_StatManager INIT "&pl_selfName&" DONE ----");
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_cleanup_CT
// 
//  Purpose:
//    This function should be called before the <EPTF_StatManager_CT> component
//    shuts down.
//
//  Parameters:
//    -
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//    The function is registered by <f_EPTF_Base_RegisterCleanup> as a 
//    cleanup function in the init function for the <EPTF_StatManager_CT> 
//    component.
//    This function makes it possible to be able to shut down the
//    <EPTF_StatManager_CT> component gracefully.
//    
///////////////////////////////////////////////////////////////////////////////
private function f_EPTF_StatManager_cleanup_CT() 
runs on EPTF_StatManager_CT 
{
  if (v_EPTF_StatManager_initialized == false) {
    return;
  }
  f_EPTF_str2int_HashMap_DeleteById(v_EPTF_StatManager_limitStatVarsHashMap);
  v_EPTF_StatManager_limitStatVarsHashMap := -1;
  v_EPTF_StatManager_initialized := false;
  f_EPTF_StatManager_debug("----- STATMANAGER CLEANUP DONE -------");
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_debug
// 
//  Purpose:
//    Function to log a debug message from StatManager feature.
//
//  Parameters:
//    - pl_message - *in* *charstring* - the message to log
//
//  Return Value:
//    -
//
//  Errors & assertions:
//    - 
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////
private function f_EPTF_StatManager_debug(in @lazy charstring pl_message)
runs on EPTF_StatManager_CT
{
  f_EPTF_Logging_debugV2(pl_message, v_StatManager_loggingMaskId, {c_EPTF_StatManager_loggingClassIdx_Debug});
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_warning
// 
//  Purpose:
//    Function to log a warning message from StatManager feature.
//
//  Parameters:
//    - pl_message - *in* *charstring* - the message to log
//
//  Return Value:
//    -
//
//  Errors & assertions:
//    - 
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////
private function f_EPTF_StatManager_warning(in @lazy charstring pl_message)
runs on EPTF_StatManager_CT
{
  f_EPTF_Logging_warningV2(pl_message, v_StatManager_loggingMaskId, {c_EPTF_StatManager_loggingClassIdx_Warning});
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_getOrCreateLimitStat
// 
//  Purpose:
//    Creates a limit statistic from the provided variable then a variable to this statistic thus it is possible
//    from the custom GUI descriptor to query the color of a LED depending on the value of the original variable
//
//  Parameters:
//    pl_varIdx - *in* *integer* - the index of variable for which the limits statistic will be created
//    pl_limitsPar - *in* *EPTF_StatMeasure_LimitsPar*  - the parameters for the limits statistic
//
//  Return Value:
//    integer - The index of the variable that holds the actual state of the LED
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////////////////////////
private function f_EPTF_StatManager_getOrCreateLimitStat(
  in integer pl_varId,
  in EPTF_StatMeasure_LimitsPar pl_limitsPar)
runs on EPTF_StatManager_CT return integer
{
  var EPTF_StatMeasure_StatParams vl_limitPar;
  vl_limitPar.limits := pl_limitsPar;
  var integer vl_statId := -1;  
  var integer vl_limitStatVarId := -1;
  var charstring vl_hashKey:= log2str(pl_varId) & log2str(pl_limitsPar);

  if (f_EPTF_str2int_HashMap_Find(v_EPTF_StatManager_limitStatVarsHashMap, vl_hashKey, vl_limitStatVarId))
  {
    return vl_limitStatVarId;
  }

  vl_statId := f_EPTF_StatMeasure_newStatWithParams(pl_varId, vl_limitPar);
  vl_limitStatVarId := f_EPTF_StatMeasure_createVarFromStat(vl_statId);

  f_EPTF_str2int_HashMap_Insert(v_EPTF_StatManager_limitStatVarsHashMap, vl_hashKey, vl_limitStatVarId);

  f_EPTF_Var_refreshContent(pl_varId); // calculate initial value of the stat
  return vl_limitStatVarId;
}

private function f_EPTF_StatManager_gosCalcFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_IntegerList pl_nonVarArgList, inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_StatManager_CT {
  pl_retVal := {floatVal := 0.0}
  var integer vl_nofSucc,vl_nofFail,vl_nofTimeout,vl_nofError;
  vl_nofSucc := f_EPTF_Var_getIntValue(pl_argList[0]);
  vl_nofFail := f_EPTF_Var_getIntValue(pl_argList[1]);
  vl_nofTimeout := f_EPTF_Var_getIntValue(pl_argList[2]);
  vl_nofError := f_EPTF_Var_getIntValue(pl_argList[3]);
  if (vl_nofSucc>0) {
    pl_retVal.floatVal := 100.0*int2float(vl_nofSucc)/int2float(vl_nofSucc+vl_nofFail+vl_nofTimeout+vl_nofError);
  }
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_StatManager_getOrCreateGoSStat
// 
//  Purpose:
//    Creates a GoS statistics from the provided variable names then a variable to this statistic thus it is possible
//    from the custom GUI descriptor to query the value
//
//  Parameters:
//    pl_gosPar - *in* *EPTF_StatManager_GoSPar*  - the parameters for the gos statistic
//
//  Return Value:
//    integer - The index of the variable that holds the actual value of the GoS statistics
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////////////////////////
private function f_EPTF_StatManager_getOrCreateGoSStat(
  in EPTF_StatManager_GoSPar pl_gosPar)
runs on EPTF_StatManager_CT return integer
{
  var integer vl_gosStatVarId := -1;
  var charstring vl_hashKey:= "GoS_"&log2str(pl_gosPar.nofSuccVarId);

  if (f_EPTF_str2int_HashMap_Find(v_EPTF_StatManager_limitStatVarsHashMap, vl_hashKey, vl_gosStatVarId))
  {
    return vl_gosStatVarId;
  }

  f_EPTF_Var_newFloat(vl_hashKey,0.123,vl_gosStatVarId)

  f_EPTF_Var_subscribeLocal(vl_gosStatVarId,
    {{
      refers(f_EPTF_StatManager_gosCalcFn),
      {pl_gosPar.nofSuccVarId,pl_gosPar.nofFailVarId,pl_gosPar.nofTimeoutVarId,pl_gosPar.nofErrorVarId},
      {}
    }}
  );
  
  f_EPTF_str2int_HashMap_Insert(v_EPTF_StatManager_limitStatVarsHashMap, vl_hashKey, vl_gosStatVarId);

  return vl_gosStatVarId;
}

private function f_EPTF_StatManager_DSProcessData(
  out charstring pl_dataVarName,
  in charstring pl_source,
  in charstring pl_ptcName,
  in charstring pl_element,
  in EPTF_DataSource_Params pl_params)
runs on EPTF_StatManager_CT return integer
{
  var EPTF_StatMeasure_LimitsPar vl_limitspar:={-1, led_black, false, {}};
  var integer vl_i:=0, vl_size:=0, vl_varId:=-1;

  select(pl_element){
    case(c_StatManager_dataElementGoS) {
      var EPTF_StatManager_GoSPar vl_gosPar := {-1,-1,-1,-1}

      vl_size := sizeof(pl_params);

      for(vl_i:=0; vl_i<vl_size; vl_i:=vl_i+1){
        select(pl_params[vl_i].paramName){
          case(c_StatManager_paramName_SuccessVarId){
            if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_gosPar.nofSuccVarId)){
                pl_dataVarName := log2str(%definitionId& ": Wrong "&c_StatManager_paramName_SuccessVarId&" parameter was given! No GoS statistic will be returned!")
                f_EPTF_StatManager_warning(pl_dataVarName);
                return -1;
            }
          }
          case(c_StatManager_paramName_FailVarId){
            if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_gosPar.nofFailVarId)){
                pl_dataVarName := log2str(%definitionId& ": Wrong "&c_StatManager_paramName_FailVarId&" parameter was given! No GoS statistic will be returned!")
                f_EPTF_StatManager_warning(pl_dataVarName);
                return -1;
            }
          }
          case(c_StatManager_paramName_TimeoutVarId){
            if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_gosPar.nofTimeoutVarId)){
                pl_dataVarName := log2str(%definitionId& ": Wrong "&c_StatManager_paramName_TimeoutVarId&" parameter was given! No GoS statistic will be returned!")
                f_EPTF_StatManager_warning(pl_dataVarName);
                return -1;
            }
          }
          case(c_StatManager_paramName_ErrorVarId){
            if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_gosPar.nofErrorVarId)){
                pl_dataVarName := log2str(%definitionId& ": Wrong "&c_StatManager_paramName_ErrorVarId&" parameter was given! No GoS statistic will be returned!")
                f_EPTF_StatManager_warning(pl_dataVarName);
                return -1;
            }
          } case else {
             pl_dataVarName := log2str(%definitionId& ": The parameter name "& pl_params[vl_i].paramName & " is not valid!");
             f_EPTF_StatManager_warning(pl_dataVarName);
             return -1;
          }
        }
      }
        
      var integer vl_idx := f_EPTF_StatManager_getOrCreateGoSStat(vl_gosPar);
      if (vl_idx == -1) {
        return -1;
      }
      pl_dataVarName :=  f_EPTF_Var_getName(vl_idx);
      return 0;

    }
    case(c_StatManager_dataElementLEDlimit){
      vl_size := sizeof(pl_params);
      
    for(vl_i:=0; vl_i<vl_size; vl_i:=vl_i+1){
      select(pl_params[vl_i].paramName){
        case(c_StatManager_paramName_blackLimit){
          if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
              vl_limitspar.limits[sizeof(vl_limitspar.limits)].blackLimit := str2float(pl_params[vl_i].paramValue);
            }                     
        }
        
        case(c_StatManager_paramName_blueLimit){
          if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
              vl_limitspar.limits[sizeof(vl_limitspar.limits)].blueLimit := str2float(pl_params[vl_i].paramValue);
            }                     
        }
        
        case(c_StatManager_paramName_redLimit){
          if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
              vl_limitspar.limits[sizeof(vl_limitspar.limits)].redLimit := str2float(pl_params[vl_i].paramValue);
            }                     
        }
        
        case(c_StatManager_paramName_yellowLimit){
          if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
              vl_limitspar.limits[sizeof(vl_limitspar.limits)].yellowLimit := str2float(pl_params[vl_i].paramValue);
            }                     
        }
        
        case(c_StatManager_paramName_greenLimit){
          if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
              vl_limitspar.limits[sizeof(vl_limitspar.limits)].greenLimit := str2float(pl_params[vl_i].paramValue);
            }                     
        }
        
        case(c_StatManager_paramName_defaultColor){
          if(not f_EPTF_StatManager_checkColor(pl_params[vl_i].paramValue, vl_limitspar)){
              f_EPTF_StatManager_warning(%definitionId& ": Setting '"&c_StatManager_paramName_defaultColor&"' was unsuccessful! Using default color: black");
              vl_limitspar.defaultColor := led_black;
          }
        }
        
        case(c_StatManager_paramName_enableValueInLEDText){
          if(not f_EPTF_StatManager_checkEnabledLEDText(pl_params[vl_i].paramValue, vl_limitspar)){
              f_EPTF_StatManager_warning(%definitionId& ": Setting '"&c_StatManager_paramName_enableValueInLEDText&"' was unsuccessful! Setting it to false");
              vl_limitspar.enableValueInLEDText:=false;
          }
        }
        
        case(c_StatManager_paramName_VarId){
          if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_varId)){
              f_EPTF_StatManager_warning(%definitionId& ": Wrong "&c_StatManager_paramName_VarId&" parameter was given! No limit statistic will be returned!");
              return -1;
          }
        }
        
        case(c_StatManager_paramName_referenceVarId){
          if(not f_EPTF_StatManager_checkvarId(pl_params[vl_i].paramValue, vl_limitspar.referenceVarId)){
              f_EPTF_StatManager_warning(%definitionId& ": Wrong "&c_StatManager_paramName_referenceVarId&" parameter was given! Setting to -1!");
              vl_limitspar.referenceVarId:=-1;
          }
        }
        case else{
          f_EPTF_StatManager_warning(%definitionId& pl_params[vl_i].paramName & " is not a valid parameter name!");
        }
      }
    }
    
    if(vl_varId == -1){
      f_EPTF_StatManager_warning(%definitionId& ": No "&c_StatManager_paramName_VarId&" parameter was given! No limit statistic will be returned!");
        return -1
    }    

    var integer vl_idx := f_EPTF_StatManager_getOrCreateLimitStat(vl_varId, vl_limitspar);
      if (vl_idx == -1) {
        return -1;
      }
      pl_dataVarName :=  f_EPTF_Var_getName(vl_idx);
      return 0;

    }
    case else {  //error, no rule for that
      pl_dataVarName := "";
      f_EPTF_StatManager_warning(%definitionId& ": unhandled element: "& pl_element);
      return -1;
    }    
  }
  return -1; //this should never be executed  
}

  ///////////////////////////////////////////////////////////
  //  Function: f_EPTF_StatManager_DSProcessDataValue
  // 
  //  Purpose:
  //    Processes the incoming DataValue requests - iterators and external data elements - and gives back the value.
  //    It should be registered in the LoadRegulator_init_CT. Type function fcb_EPTF_DataSourceClient_dataValueHandler
  //
  //  Parameters:
  //    *out *<EPTF_Var_DirectContent>* pl_dataValue* - the value of the data or the iterator result
  //    *in charstring pl_source* - the name of the data source 'feature'
  //    *in charstring pl_ptcName* - the name of the ptc (ID of the PTC)  
  //    *in charstring pl_element* - the name of the data element
  //    *in* <EPTF_DataSource_Params> *pl_params* - the parameters
  //      of the data for the dataElement
  //
  //  Return Value:
  //    integer - error code (0 of OK, non zero if unsuccessful: e.g. invalid parameters given in pl_params)
  //
  //  Detailed Comments: 
  //    -
  //
  ///////////////////////////////////////////////////////////
  private function f_EPTF_StatManager_DSProcessDataValue(out EPTF_Var_DirectContent pl_dataValue,
                                                in charstring pl_source,
                                                in charstring pl_ptcName,
                                                in charstring pl_element,
                                                in EPTF_DataSource_Params pl_params)
  runs on EPTF_StatManager_CT return integer{   
    var integer vl_errorCode := -1;
    pl_dataValue := {unknownVal := {omit}}; // set it to invalid
    select( pl_element )
    {
      case(c_EPTF_DataSource_dataElement_Help) {
        vl_errorCode := f_EPTF_DataSource_handleHelp(pl_dataValue,pl_source,pl_params,c_EPTF_StatManager_help);
      }
      case(c_StatManager_dataElementLEDlimit) {
        var integer vl_size := sizeof(pl_params);
        var EPTF_StatMeasure_LimitsPar vl_limitspar:={-1, led_black, false, {}};
        var boolean vl_valueSet := false;
        var float vl_value := 0.0;
        var float vl_refValue := 0.0;
        
        for(var integer vl_i:=0; vl_i<vl_size; vl_i:=vl_i+1){
          select(pl_params[vl_i].paramName){
            case(c_StatManager_paramName_blackLimit){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_limitspar.limits[sizeof(vl_limitspar.limits)].blackLimit := str2float(pl_params[vl_i].paramValue);
              }                     
            }
          
            case(c_StatManager_paramName_blueLimit){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_limitspar.limits[sizeof(vl_limitspar.limits)].blueLimit := str2float(pl_params[vl_i].paramValue);
              }                     
            }
            
            case(c_StatManager_paramName_redLimit){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_limitspar.limits[sizeof(vl_limitspar.limits)].redLimit := str2float(pl_params[vl_i].paramValue);
              }                     
            }
            
            case(c_StatManager_paramName_yellowLimit){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_limitspar.limits[sizeof(vl_limitspar.limits)].yellowLimit := str2float(pl_params[vl_i].paramValue);
              }                     
            }
            
            case(c_StatManager_paramName_greenLimit){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_limitspar.limits[sizeof(vl_limitspar.limits)].greenLimit := str2float(pl_params[vl_i].paramValue);
              }                     
            }
            
            case(c_StatManager_paramName_defaultColor){
              if(not f_EPTF_StatManager_checkColor(pl_params[vl_i].paramValue, vl_limitspar)){
                f_EPTF_StatManager_warning(%definitionId& ": Setting '"&c_StatManager_paramName_defaultColor&"' was unsuccessful! Using default color: black");
                vl_limitspar.defaultColor := led_black;
              }
            }
            
            case(c_StatManager_paramName_enableValueInLEDText){
              if(not f_EPTF_StatManager_checkEnabledLEDText(pl_params[vl_i].paramValue, vl_limitspar)){
                f_EPTF_StatManager_warning(%definitionId& ": Setting '"&c_StatManager_paramName_enableValueInLEDText&"' was unsuccessful! Setting it to false");
                vl_limitspar.enableValueInLEDText:=false;
              }
            }
            
            case(c_StatManager_paramName_value){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_value := str2float(pl_params[vl_i].paramValue);
                vl_valueSet := true;
              }
            }
            
            case(c_StatManager_paramName_referenceValue){
              if(f_EPTF_StatManager_checkLimit(pl_params[vl_i].paramValue)){
                vl_refValue := str2float(pl_params[vl_i].paramValue);
              }
            }
            
            case else{
              f_EPTF_StatManager_warning(%definitionId& pl_params[vl_i].paramName & " is not a valid parameter name!");
            }
          }
        }
        
        if (vl_valueSet) {
          f_EPTF_StatMeasure_bubblesort_LimitList(vl_limitspar.limits);
          pl_dataValue.statusLEDVal := f_EPTF_StatMeasure_calculateValue_limits(
            pl_value := vl_value,
            pl_limits := vl_limitspar.limits,
            pl_referenceValue := vl_refValue,
            pl_defaultLED := {vl_limitspar.defaultColor, ""},
            pl_enableValueInLEDText := vl_limitspar.enableValueInLEDText
          );
          vl_errorCode := 0;
        } else {
          pl_dataValue.charstringVal := "No value was given in the parameters";
          vl_errorCode := 5;
        }
      }
      case else
      {
      }
    }
    return vl_errorCode;
  }  

private function f_EPTF_StatManager_checkLimit(in charstring pl_lim) runs on EPTF_StatManager_CT return boolean{  
  if(match(pl_lim, pattern c_EPTF_StatManager_floatNumber)){
    return true;
    
    
  }else{
    f_EPTF_StatManager_warning(%definitionId& ": " & pl_lim & " is not a legal float number!");
    return false;
  }  
}

private function f_EPTF_StatManager_checkColor(in charstring pl_color, inout EPTF_StatMeasure_LimitsPar pl_limitsPar) runs on EPTF_StatManager_CT return boolean{
  select(pl_color){
    case("blue"){pl_limitsPar.defaultColor:=led_blue}
    case("black"){pl_limitsPar.defaultColor:=led_black}
    case("yellow"){pl_limitsPar.defaultColor:=led_yellow}
    case("green"){pl_limitsPar.defaultColor:=led_green}
    case("red"){pl_limitsPar.defaultColor:=led_red}
    case else{
      f_EPTF_StatManager_warning(%definitionId& ": " & pl_color & " is not a legal LED color!");
      return false;}
  }
  return true;
}

private function f_EPTF_StatManager_checkEnabledLEDText(in charstring pl_enabled, inout EPTF_StatMeasure_LimitsPar pl_limitsPar) runs on EPTF_StatManager_CT return boolean{
  select(pl_enabled){
    case("yes"){pl_limitsPar.enableValueInLEDText:=true}
    case("no"){pl_limitsPar.enableValueInLEDText:=false}
    case else{
      f_EPTF_StatManager_warning(%definitionId& ": " & pl_enabled & " is not a legal parameter value for: '"&c_StatManager_paramName_enableValueInLEDText&"'!");
      return false}  
  }
  return true;
}

private function f_EPTF_StatManager_checkvarId(in charstring pl_varId, out integer pl_IvarId) runs on EPTF_StatManager_CT return boolean{
  pl_IvarId := f_EPTF_Var_getId(pl_varId);
    
  if(pl_IvarId>-1)
  {   
    return true
  }else{    
    return false
  }
}

} // module