| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_LoggingServer_Functions |
| // |
| // Purpose: |
| // This module contains the implementation of generic EPTF logging functions. |
| // |
| // Module depends on: |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_Variable_Definitions> |
| // <EPTF_CLL_Logging_Definitions> |
| // <EPTF_CLL_Common_Functions> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // <EPTF_CLL_DataSource_Definitions> |
| // <EPTF_CLL_DataSourceClient_Functions> |
| // <EPTF_CLL_Logging_Functions> |
| // <EPTF_CLL_Variable_Functions> |
| // <EPTF_CLL_LoggingServer_Definitions> |
| // <EPTF_CLL_HashMap_Functions> |
| |
| // |
| // Current Owner: |
| // ELSZSKU |
| // |
| // Last Review Date: |
| // 2010-xx-xx |
| // |
| // Detailed Comments: |
| // This module contains the interface functions for the EPTF_Logging client component. |
| // |
| /////////////////////////////////////////////////////////////// |
| module EPTF_CLL_LoggingServer_Functions |
| { |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Common_Functions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_DataSource_Definitions all; |
| import from EPTF_CLL_DataSourceClient_Functions all; |
| import from EPTF_CLL_DataSource_Functions all; |
| import from EPTF_CLL_Logging_Functions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_CLL_LoggingServer_Definitions all; |
| import from EPTF_CLL_HashMap_Functions all; |
| |
| public function f_EPTF_LoggingServer_init_CT( |
| in charstring pl_selfName, |
| in EPTF_DataSource_CT pl_sourceCompRef := null) |
| runs on EPTF_LoggingServer_CT { |
| |
| if (v_EPTF_LoggingServer_initialized) {return;} |
| f_EPTF_Logging_init_CT(pl_selfName); |
| var charstring vl_selfName := f_EPTF_Base_selfName(); |
| f_EPTF_Var_init_CT(vl_selfName); |
| f_EPTF_HashMap_init_CT (vl_selfName); |
| //Create DataSource variables which has no parameters, so always exist |
| //Create EPTF var for global enable |
| f_EPTF_Var_newBoolRef( |
| c_LoggingServer_allComponentGlobalEnableVarName, |
| v_EPTF_Logging_allComponentGlobalEnable, |
| v_EPTF_LoggingServer_allComponentGlobalEnableIdx); |
| //Create EPTF var for Selections iterator |
| var EPTF_CharstringList vl_list; |
| f_EPTF_Logging_getSelectionList(vl_list); |
| f_EPTF_Var_newCharstringlist( |
| c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorSelectionTypes_varName, |
| vl_list, |
| v_LoggingServer_iteratorSelectionsVarIdx); |
| //Create EPTF var for Clients iterator without parameter |
| f_EPTF_Var_newCharstringlist( |
| c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorClients_varName, |
| {}, |
| v_LoggingServer_iteratorClientsVarIdx); |
| //Create EPTF var for ComponentTypes iterators per selection |
| for ( var integer vl_i := 0,vl_size := sizeof(vl_list); vl_i < vl_size ; vl_i := vl_i+1 ){ |
| f_EPTF_Var_newCharstringlist( |
| c_LoggingServer_iteratorVarPrefix&vl_list[vl_i]&"."&c_LoggingServer_iteratorComponentTypes_varName, |
| {}, |
| v_LoggingServer_iteratorComponentTypesVarIdxList[vl_i]); |
| } |
| v_EPTF_LoggingServer_typesLookupTableID:=f_EPTF_str2int_HashMap_New (c_LoggingServer_typesLookupTable_HashName); |
| v_EPTF_LoggingServer_typesID:=0; |
| |
| f_EPTF_DataSourceClient_init_CT(vl_selfName, pl_sourceCompRef); |
| f_EPTF_DataSourceClient_registerData(c_LoggingServer_sourceId, vl_selfName, refers( f_EPTF_LoggingServer_DSProcessData ), pl_sourceCompRef) |
| f_EPTF_DataSourceClient_registerDataValue(c_LoggingServer_sourceId, vl_selfName, refers(f_EPTF_LoggingServer_DSProcessDataValue), pl_sourceCompRef); |
| |
| v_EPTF_LoggingServer_initialized := true; |
| v_EPTF_LoggingServer_numberOfClients:=0; |
| |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_LoggingServer_cleanup_CT)); |
| //log("----- LoggingServer init END -------"); |
| |
| v_EPTF_LoggingServer_def:=activate(as_EPTF_LoggingServer_main_CT()); |
| } |
| |
| private altstep as_EPTF_LoggingServer_main_CT() runs on EPTF_LoggingServer_CT { |
| |
| //log("***********f_EPTF_LoggingServer_main***************"); |
| var EPTF_LoggingClient_CT v_send; |
| var EPTF_Logging_Msg vl_req; |
| |
| [v_EPTF_LoggingServer_allowReq] EPTF_LoggingServerPort_CP.receive(tr_EPTF_Logging_req) -> value vl_req sender v_send |
| { |
| v_EPTF_LoggingServer_allowReq := false; |
| var charstring vl_compNameList4TypeVarName := f_EPTF_LoggingServer_compNameList4TypeVarName(vl_req.Logging_Req.compType); |
| var integer vl_compTypeID; |
| //Store client name |
| var integer vl_clientIdx := vl_req.Logging_Req.clientIdx; |
| var charstring vl_clientName := f_EPTF_LoggingServer_getNameFromVar(v_LoggingServer_iteratorClientsVarIdx, vl_clientIdx); |
| var integer vl_selIdx := v_LoggingServer_selIdxMap[vl_clientIdx][vl_req.Logging_Req.selectionInClient] |
| //find if ID not exist |
| if(not f_EPTF_str2int_HashMap_Find(v_EPTF_LoggingServer_typesLookupTableID,vl_req.Logging_Req.compType,vl_compTypeID)) |
| { |
| v_EPTF_LoggingServer_typesID:=v_EPTF_LoggingServer_typesID+1; |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_LoggingServer_typesLookupTableID,vl_req.Logging_Req.compType,v_EPTF_LoggingServer_typesID); |
| vl_compTypeID := v_EPTF_LoggingServer_typesID; |
| //Add type to the list |
| v_LoggingServer_dummyInt := f_EPTF_LoggingServer_addNewNameByIdx(v_LoggingServer_iteratorComponentTypesVarIdxList[vl_selIdx],vl_req.Logging_Req.compType); |
| //Create a new EPTF Var CharstringList for the client names which registered the type |
| //Initially it contains the client name from this message |
| var integer vl_varId |
| f_EPTF_Var_newCharstringlist( |
| vl_compNameList4TypeVarName, |
| {vl_clientName}, |
| vl_varId) |
| //Create EPTF var |
| f_EPTF_LoggingServer_CompTypeBindToEPTFVar(vl_req.Logging_Req.compType,v_EPTF_LoggingServer_typesID,vl_selIdx,vl_req.Logging_Req.eventClassNames); |
| //Create list of classes |
| f_EPTF_Var_newCharstringlist( |
| f_EPTF_LoggingServer_classNameList4TypeVarName(vl_req.Logging_Req.compType), |
| vl_req.Logging_Req.eventClassNames, |
| vl_varId) |
| }else{ |
| //Set client name |
| f_EPTF_LoggingServer_addNewName(vl_compNameList4TypeVarName, vl_clientName); |
| } |
| v_EPTF_LoggingServer_allowReq := true; |
| EPTF_LoggingServerPort_CP.send(c_Logging_resp) to v_send; |
| repeat; |
| } |
| [v_EPTF_LoggingServer_allowReq] EPTF_LoggingServerPort_CP.receive(tr_EPTF_Logging_newSelection) -> value vl_req sender v_send |
| { |
| v_EPTF_LoggingServer_allowReq := false; |
| var integer vl_clientIdx := vl_req.Logging_NewSelection.clientIdx; |
| var integer vl_selIdx := f_EPTF_LoggingServer_getNameIdxInVar(v_LoggingServer_iteratorSelectionsVarIdx, vl_req.Logging_NewSelection.name); |
| if(0 > vl_selIdx){ |
| vl_selIdx := f_EPTF_LoggingServer_addNewNameByIdx(v_LoggingServer_iteratorSelectionsVarIdx,vl_req.Logging_NewSelection.name); |
| f_EPTF_Var_newCharstringlist( |
| c_LoggingServer_iteratorVarPrefix&vl_req.Logging_NewSelection.name&"."&c_LoggingServer_iteratorComponentTypes_varName, |
| {}, |
| v_LoggingServer_iteratorComponentTypesVarIdxList[vl_selIdx]); |
| } |
| v_LoggingServer_selIdxMap[vl_clientIdx][vl_req.Logging_NewSelection.selectionInClient] := vl_selIdx; |
| |
| v_EPTF_LoggingServer_allowReq := true; |
| EPTF_LoggingServerPort_CP.send(c_Logging_resp) to v_send; |
| repeat; |
| } |
| [] EPTF_LoggingServerPort_CP.receive(tr_EPTF_Logging_hello) -> value vl_req sender v_send |
| { |
| var integer vl_clientIdx := sizeof(v_LoggingServer_clients); |
| var integer vl_clientIdxInList := f_EPTF_LoggingServer_addNewNameByIdx(v_LoggingServer_iteratorClientsVarIdx, vl_req.Logging_Hello.compName); |
| if(vl_clientIdx != vl_clientIdxInList){ |
| f_EPTF_Logging_error(true, %definitionId&": Client idx of the client "& |
| vl_req.Logging_Hello.compName&" in the list is "&int2str(vl_clientIdxInList)& |
| " instead of the requested "&int2str(vl_clientIdx)&". Probably there is another client with the same name.") |
| } |
| v_EPTF_LoggingServer_numberOfClients:=v_EPTF_LoggingServer_numberOfClients+1; |
| v_LoggingServer_clients[vl_clientIdx] := v_send; |
| var EPTF_Logging_Msg vl_ack; vl_ack.Logging_ClientAck.clientIdx := vl_clientIdx; |
| EPTF_LoggingServerPort_CP.send(vl_ack) to v_send; |
| repeat; |
| } |
| [] EPTF_LoggingServerPort_CP.receive(c_Logging_bye) -> value vl_req sender v_send |
| { |
| f_EPTF_LoggingServer_handleBy(v_send); |
| repeat; |
| } |
| |
| } |
| |
| ////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LoggingUI_CompTypeBindToEPTFVar |
| // |
| // Purpose: |
| // Binds the component type boolean parameters to EPTF_variables |
| // |
| // Parameters: |
| // pl_compType - *in* *charstring* - name of the component type |
| // pl_compTypeID - *in* *integer* - the ID of the component type |
| // pl_selection - *in* *integer* - CORE/USER |
| // pl_eventClassNames - *in* <EPTF_Logging_EventClassPrefixList> - logmasks names defined for this component type |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - (none) |
| // |
| // Detailed Comments: |
| // Binds the boolean parameters to EPTF_variables. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| private function f_EPTF_LoggingServer_CompTypeBindToEPTFVar( |
| in charstring pl_compType, |
| in integer pl_compTypeID, |
| in integer pl_selection, |
| in EPTF_Logging_EventClassPrefixList pl_eventClassNames) runs on EPTF_LoggingServer_CT { |
| |
| //log("***********f_EPTF_LoggingUI_CompTypeBindToEPTFVar***************"); |
| |
| // mask bindings |
| f_EPTF_Var_newBool( |
| f_EPTF_LoggingServer_typeEnabledVarName(pl_compType), |
| true, |
| v_EPTF_LoggingServer_componentGlobalEnableIdx[pl_compTypeID][pl_selection]); |
| |
| for(var integer i:=0; i<sizeof(pl_eventClassNames); i:=i+1) { |
| f_EPTF_Var_newBool( |
| f_EPTF_LoggingServer_typeClassEnabledVarName(pl_compType, pl_eventClassNames[i]), |
| true, |
| v_EPTF_LoggingServer_componentGlobalMaskIdx[pl_compTypeID][pl_selection][i]); |
| } |
| } |
| |
| ////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LoggingServer_typeEnabledVarName |
| // |
| // Purpose: |
| // Returns the name of the EPTF variable representing |
| // the enabled state |
| // |
| public function f_EPTF_LoggingServer_typeEnabledVarName( |
| in charstring pl_compType) |
| return charstring{ |
| return c_LoggingServer_componentGlobalEnablePrefix&pl_compType; |
| } |
| |
| public function f_EPTF_LoggingServer_typeClassEnabledVarName( |
| in charstring pl_compType, |
| in charstring pl_className) |
| return charstring{ |
| return c_LoggingServer_componentGlobalMaskPrefix&pl_className&"."&pl_compType; |
| } |
| |
| public function f_EPTF_LoggingServer_compNameList4TypeVarName(in charstring pl_type) |
| return charstring{ |
| return c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorClients_varName&"."&pl_type; |
| } |
| |
| public function f_EPTF_LoggingServer_classNameList4TypeVarName(in charstring pl_type) |
| return charstring{ |
| return c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorClasses_varName&"."&pl_type; |
| } |
| |
| private function f_EPTF_LoggingServer_getNameIdxInVar(in integer pl_varIdx, in charstring pl_name) |
| runs on EPTF_Var_CT |
| return integer{ |
| var EPTF_CharstringList vl_temp := f_EPTF_Var_getCharstringlistValue(pl_varIdx); |
| for ( var integer i := 0; i < sizeof(vl_temp) ; i := i+1 ){ |
| if(vl_temp[i] == pl_name){ |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| private function f_EPTF_LoggingServer_getNameFromVar(in integer pl_varIdx, in integer pl_idx) |
| runs on EPTF_Var_CT |
| return charstring{ |
| if(0 <= pl_idx){ |
| var EPTF_CharstringList vl_temp := f_EPTF_Var_getCharstringlistValue(pl_varIdx); |
| if(pl_idx < sizeof(vl_temp)){ |
| return vl_temp[pl_idx]; |
| } |
| } |
| return ""; |
| } |
| |
| private function f_EPTF_LoggingServer_addNewNameByIdx(in integer pl_varIdx, in charstring pl_newName) |
| runs on EPTF_Var_CT |
| return integer{ |
| var EPTF_CharstringList vl_temp := f_EPTF_Var_getCharstringlistValue(pl_varIdx); |
| //Filter if already exsists in the list |
| for ( var integer i := 0; i < sizeof(vl_temp) ; i := i+1 ){ |
| if(vl_temp[i] == pl_newName){ |
| return i; |
| } |
| } |
| var integer vl_idx := lengthof(vl_temp); |
| vl_temp[vl_idx] := pl_newName; |
| f_EPTF_Var_adjustContent(pl_varIdx, {charstringlistVal := vl_temp}); |
| return vl_idx; |
| } |
| private function f_EPTF_LoggingServer_addNewName(in charstring pl_varName, in charstring pl_newName) |
| runs on EPTF_Var_CT{ |
| var integer vl_varId := f_EPTF_Var_getId(pl_varName); |
| f_EPTF_LoggingServer_addNewNameByIdx(vl_varId, pl_newName); |
| } |
| |
| ////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LoggingServer_cleanup_CT |
| // |
| // Purpose: |
| // Function to shutdown main LoggingServer component |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - (none) |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| |
| private function f_EPTF_LoggingServer_cleanup_CT() runs on EPTF_LoggingServer_CT { |
| //log("----- LoggingServer cleanup -------"); |
| if (v_EPTF_LoggingServer_initialized == false) { |
| return; |
| } |
| |
| if (v_EPTF_LoggingServer_typesLookupTableID != -1) { |
| f_EPTF_str2int_HashMap_Delete(c_LoggingServer_typesLookupTable_HashName); |
| v_EPTF_LoggingServer_typesLookupTableID := -1; |
| } |
| |
| var EPTF_LoggingClient_CT v_send; |
| var EPTF_Logging_Msg vl_msg; |
| |
| v_EPTF_LoggingServer_initialized := false; |
| if (v_EPTF_LoggingServer_numberOfClients==0) { |
| return; |
| } |
| //Send bye |
| for ( var integer i := 0; i < sizeof(v_LoggingServer_clients) ; i := i+1 ){ |
| if(null != v_LoggingServer_clients[i]){
|
| EPTF_LoggingServerPort_CP.send( c_Logging_bye ) to v_LoggingServer_clients[i]; |
| }
|
| }
|
| |
| // wait for missing bye messages |
| alt { |
| [] EPTF_LoggingServerPort_CP.receive(c_Logging_bye) -> sender v_send |
| { |
| f_EPTF_LoggingServer_handleBy(v_send); |
| if (v_EPTF_LoggingServer_numberOfClients>0) { |
| repeat; |
| } |
| log("LoggingServer: all clients exited"); |
| } |
| [] EPTF_LoggingServerPort_CP.receive(c_Logging_byeAck){} |
| [] EPTF_LoggingServerPort_CP.receive(?) -> value vl_msg sender v_send |
| { |
| f_EPTF_Common_warning(log2str("WARNING:", "Unexpected message received from ",v_send," during cleanup. Message: "&log2str(vl_msg)&" dropped")); |
| repeat; |
| } |
| } |
| } |
| |
| private function f_EPTF_LoggingServer_handleBy(in EPTF_LoggingClient_CT pl_client) |
| runs on EPTF_LoggingServer_CT{ |
| //Set to null |
| for ( var integer i := 0; i < sizeof(v_LoggingServer_clients) ; i := i+1 ){ |
| if(v_LoggingServer_clients[i]==pl_client){ |
| v_EPTF_LoggingServer_numberOfClients:=v_EPTF_LoggingServer_numberOfClients-1; |
| f_EPTF_Logging_debug(true,log2str("v_EPTF_LoggingServer_numberOfClients:",v_EPTF_LoggingServer_numberOfClients)); |
| v_LoggingServer_clients[i]:=null; |
| EPTF_LoggingServerPort_CP.send(c_Logging_byeAck) to pl_client; |
| return; |
| } |
| } |
| f_EPTF_Logging_warning(true, "By message arrived from an unknown client: "&log2str(pl_client)); |
| } |
| |
| private function f_EPTF_LoggingServer_getCTIdx( |
| in charstring pl_cTypeName, |
| in charstring pl_element) |
| runs on EPTF_LoggingServer_CT return integer{ |
| var integer vl_compTypeID; |
| if(not f_EPTF_str2int_HashMap_Find(v_EPTF_LoggingServer_typesLookupTableID,pl_cTypeName,vl_compTypeID)){ |
| f_EPTF_Logging_warning(true, "Parameter "&c_LoggingServer_paramNameComponentType&"=="&pl_cTypeName&" is invalid for iterator or data element "&pl_element& |
| ". There is no registered component type "&pl_cTypeName); |
| return -1; |
| } |
| return vl_compTypeID; |
| } |
| |
| private function f_EPTF_LoggingServer_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_LoggingServer_CT return integer{ |
| select( pl_element ){
|
| case ( c_LoggingServer_dataElementLogEnabled ){ |
| const EPTF_CharstringList cl_neededParams := { |
| c_LoggingServer_paramNameComponentType,
|
| c_LoggingServer_paramNameClass |
| } |
| var EPTF_CharstringList vl_params
|
| v_LoggingServer_dummyInt := f_EPTF_DataSourceClient_extractParams(c_LoggingServer_dataElementLogEnabled,pl_params, cl_neededParams, vl_params); |
| var integer vl_mask := f_EPTF_LoggingServer_DSGetParamsMask(vl_params); |
| select( vl_mask ){
|
| case ( 0 ){ //Global log enable
|
| pl_dataVarName := c_LoggingServer_allComponentGlobalEnableVarName; |
| return 0;
|
| }
|
| case ( 1 ){ //Global component type log enable |
| var charstring vl_ctName := vl_params[0]; |
| var integer vl_compTypeID := f_EPTF_LoggingServer_getCTIdx(vl_ctName,c_LoggingServer_dataElementLogEnabled); |
| if(-1 == vl_compTypeID){ |
| return -1; |
| } |
| pl_dataVarName := f_EPTF_LoggingServer_typeEnabledVarName(vl_ctName); |
| return 0; |
| } |
| case ( 3 ){ //Global LogClass of component type log enable |
| var charstring vl_ctName := vl_params[0]; |
| var charstring vl_className := vl_params[1]; |
| var integer vl_compTypeID := f_EPTF_LoggingServer_getCTIdx(vl_ctName,c_LoggingServer_dataElementLogEnabled); |
| if(-1 == vl_compTypeID){ |
| return -1; |
| } |
| var integer vl_clasVarId := f_EPTF_Var_getId(f_EPTF_LoggingServer_classNameList4TypeVarName(vl_ctName)); |
| var EPTF_CharstringList vl_classes := f_EPTF_Var_getCharstringlistValue(vl_clasVarId); |
| var integer vl_classIdx := -1; |
| for ( var integer i := 0; i < sizeof(vl_classes) and -1 == vl_classIdx ; i := i+1 ){
|
| if(vl_classes[i]==vl_className){ |
| vl_classIdx := i; |
| }
|
| } |
| if(-1 == vl_classIdx){ |
| f_EPTF_Logging_warning(true, "Parameter "&c_LoggingServer_paramNameClass&"=="&vl_className& |
| " for "&c_LoggingServer_dataElementLogEnabled&" is invalid. There is no registered log class "& |
| vl_className&" for component type "&vl_ctName& |
| ". Available classes: "&log2str(vl_classes)& |
| ". Received parameters: "&log2str(pl_params)); |
| return -1; |
| }
|
| pl_dataVarName := f_EPTF_LoggingServer_typeClassEnabledVarName(vl_ctName, vl_className); |
| return 0; |
| } |
| case ( 2 ){ //Class is set, but type not. Invalid. |
| f_EPTF_Logging_warning(true, "Parameter "&c_LoggingServer_paramNameComponentType&" must be set if you set "&c_LoggingServer_paramNameClass&" for "&c_LoggingServer_dataElementLogEnabled&"."); |
| return -1; |
| } |
| case else{ |
| //This can not happen.
|
| f_EPTF_Logging_warning(true, "Invalid parameter set. Parameters can not be used in this combination. Received: "&log2str(pl_params)); |
| return -1;
|
| }
|
| }
|
| }
|
| case ( c_LoggingServer_iteratorClients ){ |
| //The clients iterator accepts no parameter, or a component type |
| //No param |
| if(0 == lengthof(pl_params)){ |
| pl_dataVarName := c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorClients_varName; |
| return 0; |
| }else{ |
| //Component type |
| var EPTF_CharstringList vl_params |
| v_LoggingServer_dummyInt := f_EPTF_DataSourceClient_extractParams(c_LoggingServer_iteratorClients,pl_params, {c_LoggingServer_paramNameComponentType}, vl_params); |
| var integer vl_compTypeID := f_EPTF_LoggingServer_getCTIdx(vl_params[0],c_LoggingServer_iteratorClients); |
| if(-1 == vl_compTypeID){ |
| return -1; |
| } |
| pl_dataVarName := f_EPTF_LoggingServer_compNameList4TypeVarName(vl_params[0]); |
| return 0; |
| } |
| } |
| case ( c_LoggingServer_iteratorComponentTypes ){ |
| var EPTF_CharstringList vl_params |
| var EPTF_CharstringList vl_list; |
| f_EPTF_Logging_getSelectionList(vl_list); |
| |
| v_LoggingServer_dummyInt := f_EPTF_DataSourceClient_extractParams(c_LoggingServer_iteratorComponentTypes,pl_params, {c_LoggingServer_paramNameSelection}, vl_params); |
| if("" == vl_params[0]){
|
| //Empty |
| f_EPTF_Logging_warning(true, "Missing or empty parameter "&c_LoggingServer_paramNameSelection&" for iterator "&c_LoggingServer_iteratorComponentTypes&". It can have the following values: "&log2str(vl_list)); |
| return -1 |
| }
|
| pl_dataVarName := c_LoggingServer_iteratorVarPrefix&vl_params[0]&"."&c_LoggingServer_iteratorComponentTypes_varName; |
| var integer vl_varId := f_EPTF_Var_getId(pl_dataVarName); |
| if(0 > vl_varId){ |
| f_EPTF_Logging_warning(true, "Invalid selection parameter "&vl_params[0]&" for iterator "&c_LoggingServer_iteratorComponentTypes&". It can have the following values: "&log2str(vl_list)); |
| return -1; |
| }else{ |
| return 0; |
| } |
| } |
| case ( c_LoggingServer_iteratorSelectionTypes ){ |
| var EPTF_CharstringList vl_params |
| if(-1 == f_EPTF_DataSourceClient_extractParams(c_LoggingServer_iteratorSelectionTypes, pl_params, {}, vl_params)){ |
| /*if(0 < sizeof(pl_params)){ |
| f_EPTF_Logging_warning(true, %definitionId&": Invalid parameters: "&log2str(pl_params)& |
| ". Iterator "&c_LoggingServer_iteratorSelectionTypes&" has no parameters.");*/ |
| return -1; |
| } |
| pl_dataVarName := c_LoggingServer_iteratorVarPrefix&c_LoggingServer_iteratorSelectionTypes_varName; |
| return 0; |
| } |
| case ( c_LoggingServer_iteratorClasses ){ |
| var EPTF_CharstringList vl_params |
| v_LoggingServer_dummyInt := f_EPTF_DataSourceClient_extractParams(c_LoggingServer_iteratorClasses,pl_params, {c_LoggingServer_paramNameComponentType}, vl_params); |
| //vl_params[0] is component type which registered the log classes |
| if(""==vl_params[0]){ |
| f_EPTF_Logging_warning(true, "Missing or empty parameter "&c_LoggingServer_paramNameComponentType&" for iterator "&c_LoggingServer_iteratorClasses&"."); |
| return -1; |
| } |
| if (-1 == f_EPTF_LoggingServer_getCTIdx(vl_params[0],c_LoggingServer_iteratorClasses)){ |
| return -1; |
| } |
| pl_dataVarName := f_EPTF_LoggingServer_classNameList4TypeVarName(vl_params[0]); |
| return 0; |
| } |
| case else{ |
| //Just to avoid compiler warnings |
| v_LoggingServer_dummyCharstring := pl_source; |
| v_LoggingServer_dummyCharstring := pl_ptcName;
|
| f_EPTF_Logging_warning(true, %definitionId&": Invalid iterator or external data element: "&pl_element& |
| ". Available elements: "& |
| c_LoggingServer_iteratorSelectionTypes&","& |
| c_LoggingServer_iteratorClasses&","& |
| c_LoggingServer_iteratorClients&","& |
| c_LoggingServer_iteratorComponentTypes&","& |
| c_LoggingServer_dataElementLogEnabled); |
| }
|
| }
|
| return -1; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LoggingServer_DSProcessDataValue |
| // |
| // Purpose: |
| // Processes the incoming DataValue requests - iterators and external data elements - and gives back the value. |
| // It should be registered in the EPTF_LoggingServer_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: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LoggingServer_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_LoggingServer_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_Logging_help); |
| } |
| case else |
| { |
| } |
| } |
| return vl_errorCode; |
| } |
| |
| |
| public function f_EPTF_LoggingServer_DSGetParamsMask(in EPTF_CharstringList pl_params) |
| //runs on EPTF_LoggingServer_CT |
| return integer{ |
| var integer vl_paramMask := 0; |
| var integer vl_flag := 1; |
| for ( var integer vl_i := 0; vl_i < lengthof(pl_params) ; vl_i := vl_i+1 ){
|
| if("" != pl_params[vl_i]){ |
| vl_paramMask := vl_paramMask + vl_flag; |
| } |
| vl_flag := vl_flag * 2; |
| }
|
| |
| return vl_paramMask; |
| } |
| } // end of module |
