Google Git
Sign in
eclipse / titan / titan.Libraries.CLL / refs/tags/LPA108463_R15A02 / . / src / Variable / EPTF_CLL_Variable_Functions.ttcn
blob: 83fa1e46c09f8e1fb5390e783971d980bd137cdb [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
// //
// 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_Variable_Functions
//
// Purpose:
// This module contains the implementation of generic EPTF_Variable functions.
//
// Module Parameters:
// tsp_EPTF_Var_enableName2Id - *boolean* - if true hashmap database is maintained to get the id from a variable name, default: true
// tsp_EPTF_Var_enableCompRef2Id - *boolean* - if true hashmap database is maintained to get the id from a component variable, default: true
// tsp_EPTF_Var_enableEmptyTimeLine - *boolean* - if true timeline message will always be sent at the sync-time even if empty, default: false
// tsp_EPTF_Var_cfg - <EPTF_Var_InitialValueList> - the initial value list of variables to load
// tsp_EPTF_Var_maxWaitTime - *float* - the max time to wait for responses (default: 120.0 sec)
// tsp_EPTF_Var_maxWaitTimeForByeAck - *float* - the max time to wait for ByeAck messages (default: 240.0 sec)
// tsp_EPTF_Var_debug - *boolean* - to switch on debugging (default: false)
//
// Module depends on:
// <EPTF_CLL_Variable_Definitions>
// <EPTF_CLL_Base_Definitions>
// <EPTF_CLL_Base_Functions>
// <EPTF_CLL_Common_Definitions>
// <EPTF_CLL_Common_Functions>
// <EPTF_CLL_HashMapStr2Int_Functions>
// <EPTF_CLL_HashMapOct2Int_Functions>
// <TCCFileIO_Functions>
// <TCCDateTime_Functions>
// <EPTF_CLL_Logging_Definitions>
// <EPTF_CLL_Logging_Functions>
// <EPTF_CLL_Scheduler_Definitions>
// <EPTF_CLL_RBTScheduler_Functions>
// <EPTF_CLL_HashMap_Functions>
// <EPTF_CLL_FBQ_Functions>
//
// Current Owner:
// EFLOATT
//
// Last Review Date:
// 2010-xx-xx
//
// Detailed Comments:
// This module contains the interface functions for the EPTF_Variable.
// Public functions:
// <f_EPTF_Var_init_CT>
// <f_EPTF_Var_Log>
// <f_EPTF_Var_CT_LogAll>
// <f_EPTF_Var_logNames>
// <f_EPTF_Var_newIntRef>
// <f_EPTF_Var_newFloatRef>
// <f_EPTF_Var_newBoolRef>
// <f_EPTF_Var_newCharstringRef>
// <f_EPTF_Var_newOctetstringRef>
// <f_EPTF_Var_newHexstringRef>
// <f_EPTF_Var_newBitstringRef>
// <f_EPTF_Var_newIntegerlistRef>
// <f_EPTF_Var_newFloatlistRef>
// <f_EPTF_Var_newCharstringlistRef>
// <f_EPTF_Var_newStatusLEDRef>
// <f_EPTF_Var_newVar>
// <f_EPTF_Var_createVarFromCfg>
// <f_EPTF_Var_loadVarFromCfg>
// <f_EPTF_Var_saveVarToCfg>
// <f_EPTF_Var_saveVarToCfgStr>
// <f_EPTF_Var_registerVarToSave>
// <f_EPTF_Var_deregisterVarFromSave>
// <f_EPTF_Var_saveVars>
// <f_EPTF_Var_saveVars2tsp>
// <f_EPTF_Var_save>
// <f_EPTF_Var_load>
// <f_EPTF_Var_loadVarsFromCfg>
// <f_EPTF_Var_removeSelfName>
// <f_EPTF_Var_newInt>
// <f_EPTF_Var_newFloat>
// <f_EPTF_Var_newBool>
// <f_EPTF_Var_newCharstring>
// <f_EPTF_Var_newOctetstring>
// <f_EPTF_Var_newHexstring>
// <f_EPTF_Var_newBitstring>
// <f_EPTF_Var_newIntegerlist>
// <f_EPTF_Var_newFloatlist>
// <f_EPTF_Var_newCharstringlist>
// <f_EPTF_Var_newStatusLED>
// <f_EPTF_Var_isValid>
// <f_EPTF_Var_getIntValue>
// <f_EPTF_Var_getFloatValue>
// <f_EPTF_Var_getBoolValue>
// <f_EPTF_Var_getCharstringValue>
// <f_EPTF_Var_getOctetstringValue>
// <f_EPTF_Var_getHexstringValue>
// <f_EPTF_Var_getBitstringValue>
// <f_EPTF_Var_getIntegerlistValue>
// <f_EPTF_Var_getFloatlistValue>
// <f_EPTF_Var_getCharstringlistValue>
// <f_EPTF_Var_getStatusLEDValue>
// <f_EPTF_Var_getContent>
// <f_EPTF_Var_setContent>
// <f_EPTF_Var_updateRef>
// <f_EPTF_Var_getId>
// <f_EPTF_Var_getName>
// <f_EPTF_Var_intCompRef2Id>
// <f_EPTF_Var_Id2CompRef>
// <f_EPTF_Var_floatCompRef2Id>
// <f_EPTF_Var_boolCompRef2Id>
// <f_EPTF_Var_charstringCompRef2Id>
// <f_EPTF_Var_octetstringCompRef2Id>
// <f_EPTF_Var_hexstringCompRef2Id>
// <f_EPTF_Var_bitstringCompRef2Id>
// <f_EPTF_Var_integerlistCompRef2Id>
// <f_EPTF_Var_floatlistCompRef2Id>
// <f_EPTF_Var_charstringlistCompRef2Id>
// <f_EPTF_Var_statusLEDCompRef2Id>
// <f_EPTF_Var_getValueRef>
// <f_EPTF_Var_directContent2RefType>
// <f_EPTF_Var_subscribeLocal>
// <f_EPTF_Var_addLocalProviders>
// <f_EPTF_Var_removeLocalProviders>
// <f_EPTF_Var_isPresentRemote>
// <f_EPTF_Var_subscribeRemote>
// <f_EPTF_Var_resubscribeRemote>
// <f_EPTF_Var_isSubscribeRemoteFinished>
// <f_EPTF_Var_subscribeRemoteIntRef>
// <f_EPTF_Var_subscribeRemoteFloatRef>
// <f_EPTF_Var_subscribeRemoteBoolRef>
// <f_EPTF_Var_subscribeRemoteCharstringRef>
// <f_EPTF_Var_subscribeRemoteOctetstringRef>
// <f_EPTF_Var_subscribeRemoteHexstringRef>
// <f_EPTF_Var_subscribeRemoteBitstringRef>
// <f_EPTF_Var_subscribeRemoteIntegerlistRef>
// <f_EPTF_Var_subscribeRemoteFloatlistRef>
// <f_EPTF_Var_subscribeRemoteCharstringlistRef>
// <f_EPTF_Var_subscribeRemoteStatusLEDValRef>
// <f_EPTF_Var_subscribeRemoteRef>
// <f_EPTF_Var_unsubscribe>
// <f_EPTF_Var_callCalcFn>
// <f_EPTF_Var_callPostProcFns>
// <f_EPTF_Var_addPostProcFn>
// <f_EPTF_Var_removePostProcFn>
// <f_EPTF_Var_callGuardFns>
// <f_EPTF_Var_addGuardFn>
// <f_EPTF_Var_removeGuardFn>
// <f_EPTF_Var_callUnsubscribeNotifyFns>
// <f_EPTF_Var_addUnsubscribeNotifyFn>
// <f_EPTF_Var_removeUnsubscribeNotifyFn>
// <f_EPTF_Var_callSubsCanAdjustNotifyFns>
// <f_EPTF_Var_addSubsCanAdjustNotifyFn>
// <f_EPTF_Var_removeSubsCanAdjustNotifyFn>
// <f_EPTF_Var_callSyncCallBackFns>
// <f_EPTF_Var_addSyncCallBackFn>
// <f_EPTF_Var_removeSyncCallBackFn>
// <f_EPTF_Var_refreshContent>
// <f_EPTF_Var_getSubsCanAdjust>
// >f_EPTF_Var_setSubsCanAdjust>
// <f_EPTF_Var_adjustContent>
// <f_EPTF_Var_adjustContent_Blocking>
// <f_EPTF_Var_getRemoteContent>
// <f_EPTF_Var_adjustRemoteContent>
// <f_EPTF_Var_adjustRemoteContent_Blocking>
// <f_EPTF_Var_setMaxWaitTimeForByeAck>
// <f_EPTF_Var_getVarRefreshRate>
// <f_EPTF_Var_getRefreshPeriod>
// <f_EPTF_Var_getRefreshRate>
// <f_EPTF_Var_getRefreshRateId>
// <f_EPTF_Var_getTimeLine>
// <f_EPTF_Var_setSyncInterval>
// <f_EPTF_Var_setMinSyncInterval>
// <f_EPTF_Var_setMaxWaitTime>
// <f_EPTF_Var_content2str>
// <f_EPTF_Var_str2content>
// <f_EPTF_Var_content2string>
// <f_EPTF_Var_upcast>
// <f_EPTF_Var_downcast>
// <f_EPTF_Var_getIntRef>
// <f_EPTF_Var_derefInt>
// <f_EPTF_Var_modifyIntRefValue>
// <f_EPTF_Var_getFloatRef>
// <f_EPTF_Var_derefFloat>
// <f_EPTF_Var_modifyFloatRefValue>
// <f_EPTF_Var_getBoolRef>
// <f_EPTF_Var_derefBool>
// <f_EPTF_Var_modifyBoolRefValue>
// <f_EPTF_Var_getCharstringRef>
// <f_EPTF_Var_derefCharstring>
// <f_EPTF_Var_modifyCharstringRefValue>
// <f_EPTF_Var_getOctetstringRef>
// <f_EPTF_Var_derefOctetstring>
// <f_EPTF_Var_modifyOctetstringRefValue>
// <f_EPTF_Var_getHexstringRef>
// <f_EPTF_Var_derefHexstring>
// <f_EPTF_Var_modifyHexstringRefValue>
// <f_EPTF_Var_getBitstringRef>
// <f_EPTF_Var_derefBitstring>
// <f_EPTF_Var_modifyBitstringRefValue>
// <f_EPTF_Var_getIntegerlistRef>
// <f_EPTF_Var_derefIntegerlist>
// <f_EPTF_Var_modifyIntegerlistRefValue>
// <f_EPTF_Var_getFloatlistRef>
// <f_EPTF_Var_derefFloatlist>
// <f_EPTF_Var_modifyFloatlistRefValue>
// <f_EPTF_Var_getCharstringlistRef>
// <f_EPTF_Var_derefCharstringlist>
// <f_EPTF_Var_modifyCharstringlistRefValue>
// <f_EPTF_Var_getStatusLEDRef>
// <f_EPTF_Var_derefStatusLED>
// <f_EPTF_Var_modifyStatusLEDRefValue>
//
// <f_EPTF_Var_checkName>
// <f_EPTF_Var_directContent2str>
// <f_EPTF_Var_str2directContent>
// <f_EPTF_Var_removeVar>
// <f_EPTF_Var_getTopProviderType>
// <f_EPTF_Var_checkSubscriptionMode>
// <f_EPTF_Var_useCompRef2Id>
// <f_EPTF_Var_useName2Id>
// <f_EPTF_Var_getHashmap_Hashmap_CompRef2Id>
// <f_EPTF_Var_getHashmap_Name2Id>
// <f_EPTF_Var_enableDebug>
// <f_EPTF_Var_updateTimeLine>
// <f_EPTF_Var_sendTimeLine>
// <f_EPTF_Var_subscribeRemote_nonBlocking>
//
///////////////////////////////////////////////////////////////
module EPTF_CLL_Variable_Functions {
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Common_Definitions all; // EPTF_IntegerList
import from EPTF_CLL_Common_Functions all;
import from EPTF_CLL_HashMapStr2Int_Functions all;
import from EPTF_CLL_HashMapOct2Int_Functions all;
import from TCCFileIO_Functions all;
import from TCCDateTime_Functions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_Scheduler_Definitions all;
import from EPTF_CLL_RBTScheduler_Functions all;
import from EPTF_CLL_HashMap_Functions all;
import from EPTF_CLL_FBQ_Functions all;
modulepar boolean tsp_EPTF_Var_enableName2Id := true; // if true hashmap database is maintained to get the id from a variable name
modulepar boolean tsp_EPTF_Var_enableCompRef2Id := true; // if true hashmap database is maintained to get the id from a component variable
modulepar boolean tsp_EPTF_Var_enableEmptyTimeLine := false; // if true timeline message will always be sent at the sync-time even if empty
modulepar float tsp_EPTF_Var_maxWaitTime := 120.0; // the max time to wait for responses (default: 120.0 sec)
modulepar float tsp_EPTF_Var_maxWaitTimeForByeAck := 240.0; // the max time to wait for ByeAck messages (default: 240.0 sec)
modulepar boolean tsp_EPTF_Var_debug := false; // switch on debugging
modulepar EPTF_Var_InitialValueList tsp_EPTF_Var_cfg := {}; // the initial value list of variables to load
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// public:
//////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Group: Public
//
// Purpose:
// Public functions. Only these functions can be used by the user of <EPTF_Var_CT>
//
// Elements:
///////////////////////////////////////////////////////////
group Public {
// LOGGING
///////////////////////////////////////////////////////////
// Group: Logging
//
// Purpose:
// Logging functions.
//
// Elements:
///////////////////////////////////////////////////////////
group Logging {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_CT_LogAll
//
// Purpose:
// Log everything (important) in <EPTF_Var_CT> component
//
// Parameters:
// pl_msg - *in* *charstring* - message to log. It is printed before and after the component data
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_CT_LogAll(in charstring pl_msg) runs on EPTF_Var_CT {
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
f_EPTF_Var_debug(log2str("EPTF_Var_CT.v_EPTF_Vars: ", v_EPTF_Vars));
f_EPTF_Var_debug(log2str("EPTF_Var_CT.v_syncBuffer: ", v_syncBuffer));
f_EPTF_Var_debug(log2str("EPTF_Var_CT.adjustContentResp_handler_ParamStack:", adjustContentResp_handler_ParamStack));
f_EPTF_Var_debug(log2str("EPTF_Var_CT.v_EPTF_Var_varsToSave", v_EPTF_Var_varsToSave));
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_Log
//
// Purpose:
// Log a given EPTF Variable
//
// Parameters:
// pl_msg - *in* *charstring* - message to log. It is printed before and after the variable data
// pl_idx - *in* *integer* - the idx of the EPTF Variable to log
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_Log(in charstring pl_msg, in integer pl_idx) runs on EPTF_Var_CT {
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
f_EPTF_Var_debug(log2str("EPTF_Var_CT.v_EPTF_Vars[",pl_idx,"]: ", v_EPTF_Vars[pl_idx]));
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_logNames
//
// Purpose:
// Log all variable names
//
// Parameters:
// pl_msg - *in* *charstring* - message to log. It is printed before and after the variable data
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_logNames(in charstring pl_msg) runs on EPTF_Var_CT {
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
for(var integer i:=0; i<sizeof(v_EPTF_Vars); i:=i+1) {
f_EPTF_Var_debug(log2str("Name of v_EPTF_Vars[",i,"]: ", v_EPTF_Vars[i].name));
}
if (pl_msg!="") {
f_EPTF_Var_debug(pl_msg);
};
}
} // group Logging
///////////////////////////////////////////////////////////
// Group: CompInit
//
// Purpose:
// Functions to initialize the <EPTF_Var_CT> component.
//
// Elements:
///////////////////////////////////////////////////////////
group CompInit {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_init_CT
//
// Purpose:
// Initializes the EPTF_Var_CT component
//
// Parameters:
// pl_selfName - *in* *charstring* - name of the component
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function should be called before using the EPTF Variable
// component.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_init_CT(in charstring pl_selfName) runs on EPTF_Var_CT {
if (v_EPTF_Var_initialized) {
// set the priority of the altstep to the highest by reactivating it:
deactivate(v_EPTF_Var_def);
v_EPTF_Var_def := activate(as_EPTF_Var_mainHandler_MgmtIf());
return; // already initialized
}
// activate with lowest priority (befor the init function calls):
v_EPTF_Var_def := activate(as_EPTF_Var_mainHandler_MgmtIf());
f_EPTF_Base_init_CT(pl_selfName);
f_EPTF_FBQ_init_CT(pl_selfName);
f_EPTF_Scheduler_init_CT(pl_selfName);
f_EPTF_Logging_init_CT(pl_selfName);
f_EPTF_HashMap_init_CT (pl_selfName);
f_EPTF_Var_setMaxWaitTime(tsp_EPTF_Var_maxWaitTime);//HM27497
v_Var_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_Var_loggingComponentMask, c_EPTF_Var_loggingEventClasses, EPTF_Logging_CLL);
if(tsp_EPTF_Var_debug) {
f_EPTF_Logging_enableLocalMask(v_Var_loggingMaskId, c_EPTF_Var_loggingClassIdx_Debug);
} else {
f_EPTF_Logging_disableLocalMask(v_Var_loggingMaskId, c_EPTF_Var_loggingClassIdx_Debug);
}
v_EPTF_Var_enableName2Id := tsp_EPTF_Var_enableName2Id;
v_EPTF_Var_enableCompRef2Id := tsp_EPTF_Var_enableCompRef2Id;
if (v_EPTF_Var_enableName2Id) {
v_EPTF_Var_Hashmap_Name2Id := f_EPTF_str2int_HashMap_New("EPTF_Var_Hashmap_Name2Id");
}
if (v_EPTF_Var_enableCompRef2Id) {
v_EPTF_Var_Hashmap_CompRef2Id := f_EPTF_oct2int_HashMap_New("EPTF_Var_Hashmap_CompRef2Id");
}
v_EPTF_Var_Hashmap_Provider2Id := f_EPTF_str2int_HashMap_New("EPTF_Var_Hashmap_Provider2Id");
v_EPTF_Var_Hashmap_SyncBuffer := f_EPTF_str2int_HashMap_New("EPTF_Var_Hashmap_SyncBuffer");
v_EPTF_Vars := {};
var integer vl_refreshRateId := 0;
v_syncBuffer[vl_refreshRateId].refreshRate := 0; // default refresh method
v_syncBuffer[vl_refreshRateId].eventIdx := -1; // invalid index
v_syncBuffer[vl_refreshRateId].syncBuffer := {};
v_syncInterval := tsp_EPTF_Var_SyncInterval;
v_minSyncInterval := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM;
if(f_EPTF_SchedulerComp_scheduleAction(
pl_when := f_EPTF_Base_getRelTimeInSecs()+v_syncInterval,
pl_actionHandler := refers(f_EPTF_Var_syncTimeoutHandler),
pl_action := {vl_refreshRateId},
pl_eventIndex := v_syncBuffer[vl_refreshRateId].eventIdx
)){/*remove the warning*/};
v_EPTF_Var_syncCallbackFns := {};
v_EPTF_Var_varsToSave := {};
f_EPTF_initEPTF_Var_adjustContentResp_handlerPool(adjustContentResp_handler_ParamStack);
f_EPTF_initbooleanPool(v_booleanPool);
v_EPTF_Var_pendingByeNum := 0;
v_EPTF_Var_varsToUpdate := {};
f_EPTF_Var_setRefreshSubscribersPeriod();
v_EPTF_Var_numPendingHellos := 0;
v_EPTF_Var_maxWaitTimeForByeAck := tsp_EPTF_Var_maxWaitTimeForByeAck;
v_EPTF_Var_Msg_Buffer := {};
v_EPTF_Var_Msg_BufferStartIdx := 0;
v_EPTF_Var_nofPendingMsgs := 0;
v_EPTF_Var_Connections := {};
v_EPTF_Var_resubscribeRemoteResp_handler_DB := {};
v_EPTF_Var_msgBufferBeforeConnect := {};
v_EPTF_Var_nonBlockingEnabled := {};
v_EPTF_Var_initialized := true;
f_EPTF_Base_registerCleanup(refers(f_EPTF_Var_cleanup_CT));
f_EPTF_Var_debug("---- EPTF_Variable INIT "&pl_selfName&" DONE ----");
}
} // group CompInit
///////////////////////////////////////////////////////////
// Group: VaribleCreationValueAssignment
//
// Purpose:
// Functions to create EPTF Variables and and assign value.
//
// Elements:
///////////////////////////////////////////////////////////
group VaribleCreationValueAssignment {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newIntRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *integer* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newIntRef(in charstring pl_name, inout integer pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getIntRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=intType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newFloatRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *float* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newFloatRef(in charstring pl_name, inout float pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getFloatRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=floatType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newBoolRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *boolean* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newBoolRef(in charstring pl_name, inout boolean pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getBoolRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=boolType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newCharstringRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *charstring* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newCharstringRef(in charstring pl_name, inout charstring pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getCharstringRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=charstringType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newOctetstringRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *octetstring* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newOctetstringRef(in charstring pl_name, inout octetstring pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getOctetstringRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=octetstringType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newHexstringRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *hexstring* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newHexstringRef(in charstring pl_name, inout hexstring pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getHexstringRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=hexstringType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newBitstringRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *bitstring* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newBitstringRef(in charstring pl_name, inout bitstring pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getBitstringRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=bitstringType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newIntegerlistRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* <EPTF_IntegerList> - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newIntegerlistRef(in charstring pl_name, inout EPTF_IntegerList pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getIntegerlistRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=integerlistType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newFloatlistRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* <EPTF_FloatList> - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newFloatlistRef(in charstring pl_name, inout EPTF_FloatList pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getFloatlistRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=floatlistType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newCharstringlistRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* <EPTF_CharstringList> - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newCharstringlistRef(in charstring pl_name, inout EPTF_CharstringList pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getCharstringlistRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=charstringlistType, valueRef := vl_valueRef});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newStatusLEDRef
//
// Purpose:
// Creates a new EPTF_Var that is a reference to an existing component variable
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_compVar - *inout* *EPTF_StatusLED* - component variable for which the EPTF Variable is assigned
// pl_idx - *out* *integer* - the idx of the assigned new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newStatusLEDRef(in charstring pl_name, inout EPTF_StatusLED pl_compVar, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
var octetstring vl_valueRef := f_EPTF_Var_getStatusLEDRef(pl_compVar);
f_EPTF_Var_initContentRef(pl_idx, {refType:=statusLEDType, valueRef := vl_valueRef});
}
//...
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newVar
//
// Purpose:
// Creates a new EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* <EPTF_Var_DirectContent> - initial value of the variable
//
// Return Value:
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newVar(in charstring pl_name, in EPTF_Var_DirectContent pl_initValue) runs on EPTF_Var_CT return integer {
var integer pl_idx;
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, pl_initValue);
return pl_idx;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_createVarFromCfg
//
// Purpose:
// Creates a new EPTF_Var and sets its initial value from cfg data
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable to create automatically if found in the pl_cfg
// pl_cfg - *in* <EPTF_Var_InitialValueList> - List of initial values of the variables to search for pl_name. Default: tsp_EPTF_Var_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the created variable will be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the created variable name will be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_createVarFromCfg(in charstring pl_name, in EPTF_Var_InitialValueList pl_cfg := tsp_EPTF_Var_cfg, in boolean pl_removeSelfNameFromParamName := true) runs on EPTF_Var_CT return integer
{
for (var integer i:= 0; i<sizeof(pl_cfg); i:=i+1) {
if (f_EPTF_Base_selfName()&"."&pl_name == pl_cfg[i].name and pl_removeSelfNameFromParamName) {
return f_EPTF_Var_newVar(pl_name, pl_cfg[i].initValue);
}
if (pl_name == pl_cfg[i].name and not pl_removeSelfNameFromParamName) {
return f_EPTF_Var_newVar(pl_name, pl_cfg[i].initValue);
}
}
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_loadVarFromCfg
//
// Purpose:
// Loads a the value of an existing EPTF_Var and sets its initial value from cfg data
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable to load if found in the pl_cfg
// pl_cfg - *in* <EPTF_Var_InitialValueList> - List of initial values of the variables to search for pl_name. Default: tsp_EPTF_Var_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// pl_idx - *out* *integer* - the idx of the loaded EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_loadVarFromCfg(in charstring pl_name, in EPTF_Var_InitialValueList pl_cfg := tsp_EPTF_Var_cfg, in boolean pl_removeSelfNameFromParamName := true) runs on EPTF_Var_CT return integer
{
if (pl_name=="") {
return -1; // variables with empty names are not loaded
}
var integer vl_idx := f_EPTF_Var_getId(pl_name);
if (vl_idx == -1) {
f_EPTF_Var_warning(log2str("Cannot load Variable ", pl_name, " from config: Variable does not exist."));
return -1; // variable does not exist
}
var charstring vl_name := pl_name; // cfg file name and variable name is the same
if (pl_removeSelfNameFromParamName) {
vl_name := f_EPTF_Base_selfName()&"."&pl_name; // cfg file name contains selfName, but variable name does not
}
for (var integer i:= 0; i<sizeof(pl_cfg); i:=i+1) {
if (vl_name == pl_cfg[i].name) {
f_EPTF_Var_adjustContent(vl_idx, pl_cfg[i].initValue);
return vl_idx;
}
}
f_EPTF_Var_warning(log2str("No entry found for Variable ", vl_name, " in config. Variable ",pl_name," is not loaded."));
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_saveVarToCfg
//
// Purpose:
// Saves a the value of the given EPTF_Var to cfg data
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable to load if found in the pl_cfg
// pl_cfg - *out* <EPTF_Var_InitialValueList> - Initial value of the variable with its name
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is not used. Would be useful if there were a toStr function for EPTF_Var_InitialValue
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_saveVarToCfg(in charstring pl_name, out EPTF_Var_InitialValue pl_cfg, in boolean pl_removeSelfNameFromParamName := true) runs on EPTF_Var_CT
{
var integer vl_idx := f_EPTF_Var_getId(pl_name);
if (vl_idx == -1) {
pl_cfg := {
name := "-NOTFOUND: in component "&f_EPTF_Base_selfName()&": "&pl_name&"-",
initValue := {intVal := -1}
}
return;
}
// f_EPTF_Base_assert("Cannot save Variable " &pl_name& " to config: Variable does not exist.", vl_idx != -1);
if (pl_removeSelfNameFromParamName) {
pl_cfg.name := f_EPTF_Base_selfName()&"."&pl_name; // cfg file name contains selfName, but variable name does not
} else {
pl_cfg.name := pl_name; // cfg file name and variable name is the same
}
f_EPTF_Var_debug(log2str("saved to: ", pl_cfg));
f_EPTF_Var_getContent(vl_idx,pl_cfg.initValue);
//var charstring vl_contentStr := f_EPTF_Var_content2string(pl_cfg.initValue);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_saveVarToCfgStr
//
// Purpose:
// Saves a the value of the given EPTF_Var to cfg string
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable to load if found in the pl_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// charstring - Value of the variable in loadable format
//
// Errors:
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_saveVarToCfgStr(in charstring pl_name, in boolean pl_removeSelfNameFromParamName := true) runs on EPTF_Var_CT return charstring
{
var integer vl_idx := f_EPTF_Var_getId(pl_name);
if (vl_idx == -1) {
return ""; // if not found: do not save
}
var charstring vl_contentStr := f_EPTF_Var_content2string(vl_idx);
var charstring vl_name := pl_name; // cfg file name and variable name is the same
if (pl_removeSelfNameFromParamName) {
vl_name := f_EPTF_Base_selfName()&"."&pl_name; // cfg file name contains selfName, but variable name does not
}
return "{ name := \""&vl_name&"\", initValue := "&vl_contentStr&" }"
// var EPTF_Var_InitialValue vl_cfg;
// f_EPTF_Var_saveVarToCfg(pl_name,vl_cfg,pl_removeSelfNameFromParamName);
// var charstring vl_contentStr := f_EPTF_Var_directContent2string(vl_cfg.initValue);
// return "{ name := "&vl_cfg.name&", initValue := "&vl_contentStr&" }"
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_registerVarToSave
//
// Purpose:
// Registers a variable name that will be saved
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
//
// Return Value:
// -
//
// Errors:
//
// Detailed Comments:
// Does not check if variable exists ( => it is possible to register variables before they are created)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_registerVarToSave(in charstring pl_name) runs on EPTF_Var_CT {
if (pl_name=="") {
return; // variables with empty names are not saved
}
v_EPTF_Var_varsToSave[sizeof(v_EPTF_Var_varsToSave)] := pl_name;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_deregisterVarFromSave
//
// Purpose:
// Removes a variable name from the list of varibles registered by <f_EPTF_Var_registerVarToSave>
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
//
// Return Value:
// -
//
// Errors:
//
// Detailed Comments:
// Does not check if variable exists ( => it is possible to deregister variables before they are created)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_deregisterVarFromSave(in charstring pl_name) runs on EPTF_Var_CT {
if (pl_name=="") {
return; // variables with empty names are not saved
}
for (var integer i:=0; i<sizeof(v_EPTF_Var_varsToSave); i:=i+1) {
if (v_EPTF_Var_varsToSave[i] == pl_name) {
v_EPTF_Var_varsToSave[i] := "";
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_saveVars
//
// Purpose:
// Saves all registered variables in cfg format
//
// Parameters:
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// charstring - Value of the variables in loadable format
//
// Errors:
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_saveVars(in boolean pl_removeSelfNameFromParamName := true) runs on EPTF_Var_CT return charstring {
var charstring vl_result := "";
for(var integer i:=0; i<sizeof(v_EPTF_Var_varsToSave); i:=i+1) {
var charstring vl_saveStr := f_EPTF_Var_saveVarToCfgStr(v_EPTF_Var_varsToSave[i],pl_removeSelfNameFromParamName);
if (vl_saveStr!="") {
if (vl_result!="") {
vl_result := vl_result&",\n"; // add comma if necessary
}
vl_result := vl_result & vl_saveStr;
}
}
return vl_result;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_saveVars2tsp
//
// Purpose:
// Saves all registered variables in a module parameter tsp_xxx := {***} format
//
// Parameters:
// pl_moduleParName - *in charstring* - the module parameter name to save the values into. Default: tsp_EPTF_Var_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: true
//
// Return Value:
// charstring - Value of the variables in loadable format
//
// Errors:
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_saveVars2tsp(
in charstring pl_moduleParName := "tsp_EPTF_Var_cfg",
in boolean pl_removeSelfNameFromParamName := true
) runs on EPTF_Var_CT return charstring {
return pl_moduleParName & " := {\n" &f_EPTF_Var_saveVars(pl_removeSelfNameFromParamName)& "\n}\n\n";
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_save
//
// Purpose:
// Saves all registered variables in a file as module parameter tsp_xxx := {***} format
//
// Parameters:
// pl_fileName - *in charstring* - the filename where the variables shall be saved (default: <tsp_EPTF_Var_snapshotFilename>)
// pl_timeStampFormat - *in charstring* - the format of the timestamp in the generated filename (pl_fileName<timestamp>).
// Can be anything, even empty string. For the supported time-format strings see <f_getTimeFormatted>. Default: tsp_EPTF_Var_snapshotTimestamp
// pl_moduleparName - *in charstring* - the module parameter name to save the values into. Default: tsp_EPTF_Var_<selfname>_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: false
//
// Return Value:
// charstring - name of the file the snapshot was saved in. Empty string ("") is returned on error.
//
// Errors:
// -
//
// Detailed Comments:
// The name of the file will be: pl_fileName + timestamp
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_save(
in charstring pl_fileName := tsp_EPTF_Var_snapshotFilename,
in charstring pl_timeStampFormat := tsp_EPTF_Var_snapshotTimestamp,
in charstring pl_moduleparName := "",
in boolean pl_removeSelfNameFromParamName := false
) runs on EPTF_Var_CT return charstring {
var charstring vl_moduleparName := pl_moduleparName;
if (vl_moduleparName == "") {
vl_moduleparName := "tsp_EPTF_Var_"&f_EPTF_Base_selfName()&"_cfg"
}
var charstring vl_saveString := "[MODULE_PARAMETERS]\n"&f_EPTF_Var_saveVars2tsp(vl_moduleparName,pl_removeSelfNameFromParamName);
var charstring vl_timeStamp := f_getTimeFormatted(float2int(f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime())),pl_timeStampFormat);
var charstring vl_filename := pl_fileName;
if (vl_filename=="") { // if pl_fileName=="" the file name will be <selfname><timestamp>
vl_filename := f_EPTF_Base_selfName();
}
vl_filename := vl_filename&vl_timeStamp;
f_EPTF_Var_debug(log2str("vl_filename: ", vl_filename));
f_EPTF_Var_debug(log2str("vl_saveString: ", vl_saveString));
// use filio to save the string to file. // FIXME
var integer vl_fd := f_FIO_open_append_wronly_excl(vl_filename);
if (vl_fd == -1) {
f_EPTF_Var_warning(log2str("f_EPTF_Var_save: cannot open file ", vl_filename, ": ", f_FIO_get_error_string()));
return "";
}
var charstring vl_fileNameSaved := vl_filename;
if (f_FIO_write_text(vl_fd, vl_saveString) == -1) {
f_EPTF_Var_warning(log2str("f_EPTF_Var_save: cannot save EPTF_Variable data to file ", vl_filename, ": ", f_FIO_get_error_string()));
return "";
};
if (-1==f_FIO_close(vl_fd)) {/*to remove the warning*/};
return vl_filename;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_load
//
// Purpose:
// Loads all variables in a file that was saved earlier by <f_EPTF_Var_save>
//
// Parameters:
// pl_fileName - *in charstring* - the filename from where the variables shall be loaded (default: <tsp_EPTF_Var_snapshotFilename>)
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variable should be the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e. the component name (selfName) is
// removed from the name of the variable. Default: false
//
// Return Value:
// -
//
// Errors:
//
// Detailed Comments:
// Not implemented yet! Inverse of log2str or parsing needed
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_load(
in charstring pl_fileName := tsp_EPTF_Var_snapshotFilename,
in boolean pl_removeSelfNameFromParamName := false
) runs on EPTF_Var_CT {
// f_EPTF_Var_loadVarsFromCfg(pl_cfg,pl_removeSelfNameFromParamName);
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_loadVarsFromCfg
//
// Purpose:
// Load all variables that exists in the current component from the initial value list parameter
//
// Parameters:
// pl_cfg - *in* <EPTF_Var_InitialValueList> - List of initial values of the variables to load. Default: tsp_EPTF_Var_cfg
// pl_removeSelfNameFromParamName - *in boolean* - if false, the name of the variables are the same as in the pl_cfg.
// If true, the <selfName>&"."&pl_name name is searched in pl_cfg, and the variable name should be pl_name, i.e.
// the component name (selfName) is removed from the name of the variable. Default: true
//
// Return Value:
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_loadVarsFromCfg(in EPTF_Var_InitialValueList pl_cfg := tsp_EPTF_Var_cfg, in boolean pl_removeSelfNameFromParamName := true
) runs on EPTF_Var_CT {
var charstring vl_varName;
for(var integer i:=0; i<sizeof(pl_cfg); i:=i+1) {
if (pl_removeSelfNameFromParamName) {
// load only if the name begins with selfname
vl_varName := f_EPTF_Var_removeSelfName(pl_cfg[i].name);
} else {
vl_varName := pl_cfg[i].name;
}
if (vl_varName != "") {
// f_EPTF_Var_loadVarFromCfg(vl_varName,pl_cfg,pl_removeSelfNameFromParamName);
var integer vl_idx := f_EPTF_Var_getId(vl_varName);
if (vl_idx >= 0) {
f_EPTF_Var_adjustContent(vl_idx, pl_cfg[i].initValue);
} else {
f_EPTF_Var_warning(log2str("Cannot load Variable ", vl_varName, " from config: Variable does not exist."));
}
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeSelfName
//
// Purpose:
// Removes selfName from the name (with the dot) and returns the rest. returns "" if selfName cannot be removed
//
// Parameters:
// pl_name - *in* *charstring* - a name (of the variable) to remove the selfName from
//
// Return Value:
// charstring - the name without "<selfName>.", or "" of selfName cannot be removed
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeSelfName(in charstring pl_name) runs on EPTF_Var_CT return charstring {
if (pl_name=="") {
return "";
}
if (lengthof(f_EPTF_Base_selfName())+1<lengthof(pl_name) // +1 is for the dot; the rest should not be an empty string
and substr(pl_name,0,lengthof(f_EPTF_Base_selfName())) == f_EPTF_Base_selfName()
) {
// remove the selfname (+1 is the dot):
return substr(pl_name, lengthof(f_EPTF_Base_selfName())+1, lengthof(pl_name)-lengthof(f_EPTF_Base_selfName())-1);
} else {
return "";
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newInt
//
// Purpose:
// Creates a new integer-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *integer* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newInt(in charstring pl_name, in integer pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {intVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newFloat
//
// Purpose:
// Creates a new float-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *float* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newFloat(in charstring pl_name, in float pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {floatVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newBool
//
// Purpose:
// Creates a new boolean-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *boolean* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newBool(in charstring pl_name, in boolean pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {boolVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newCharstring
//
// Purpose:
// Creates a new charstring-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *charstring* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newCharstring(in charstring pl_name, in charstring pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {charstringVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newOctetstring
//
// Purpose:
// Creates a new octetstring-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *octetstring* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newOctetstring(in charstring pl_name, in octetstring pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {octetstringVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newHexstring
//
// Purpose:
// Creates a new hexstring-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *hexstring* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newHexstring(in charstring pl_name, in hexstring pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {hexstringVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newBitstring
//
// Purpose:
// Creates a new bitstring-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *bitstring* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newBitstring(in charstring pl_name, in bitstring pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {bitstringVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newIntegerlist
//
// Purpose:
// Creates a new EPTF_IntegerList-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* <EPTF_IntegerList> - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newIntegerlist(in charstring pl_name, in EPTF_IntegerList pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {integerlistVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newFloatlist
//
// Purpose:
// Creates a new EPTF_FloatList-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* <EPTF_FloatList> - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newFloatlist(in charstring pl_name, in EPTF_FloatList pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {floatlistVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newCharstringlist
//
// Purpose:
// Creates a new EPTF_CharstringList-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* <EPTF_CharstringList> - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newCharstringlist(in charstring pl_name, in EPTF_CharstringList pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {charstringlistVal := pl_initValue});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_newStatusLED
//
// Purpose:
// Creates a new EPTF_StatusLED-type EPTF_Var and sets its initial value
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
// pl_initValue - *in* *EPTF_StatusLED* - initial value of the variable
// pl_idx - *out* *integer* - the idx of the created new EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_newStatusLED(in charstring pl_name, in EPTF_StatusLED pl_initValue, out integer pl_idx) runs on EPTF_Var_CT {
f_EPTF_Var_addNew(pl_idx, pl_name);
f_EPTF_Var_initContent(pl_idx, {statusLEDVal := pl_initValue});
}
//...
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_isValid
//
// Purpose:
// Returns true if the variable has valid content
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *boolean* - true if the variable has valid content
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_isValid(in integer pl_idx) runs on EPTF_Var_CT return boolean {
return not ischosen(v_EPTF_Vars[pl_idx].content.invalid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getIntValue
//
// Purpose:
// Returns the value as an integer of a direct EPTF_Var or the dereffed value of a referenced intType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *integer* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not an integer referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getIntValue(in integer pl_idx) runs on EPTF_Var_CT return integer {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.intVal)) {
f_EPTF_Var_error(log2str("Integer value is requested for the EPTF_Var[",pl_idx,"] which has non-integer content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.intVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.intVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != intType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not an intType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefInt(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return -1; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getFloatValue
//
// Purpose:
// Returns the value as a float of a direct EPTF_Var or the dereffed value of a referenced floatType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *float* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a float referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getFloatValue(in integer pl_idx) runs on EPTF_Var_CT return float {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.floatVal)) {
f_EPTF_Var_error(log2str("Float value is requested for the EPTF_Var[",pl_idx,"] which has non-float content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.floatVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.floatVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != floatType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a floatType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefFloat(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return -1.0; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getBoolValue
//
// Purpose:
// Returns the value as a boolean of a direct EPTF_Var or the dereffed value of a referenced boolType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *boolean* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a boolean referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getBoolValue(in integer pl_idx) runs on EPTF_Var_CT return boolean {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.boolVal)) {
f_EPTF_Var_error(log2str("Boolean value is requested for the EPTF_Var[",pl_idx,"] which has non-boolean content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.boolVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.boolVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != boolType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a boolType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefBool(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return false; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getCharstringValue
//
// Purpose:
// Returns the value as a charstring of a direct EPTF_Var or the dereffed value of a referenced charstringType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *charstring* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a charstring referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getCharstringValue(in integer pl_idx) runs on EPTF_Var_CT return charstring {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.charstringVal)) {
f_EPTF_Var_error(log2str("Charstring value is requested for the EPTF_Var[",pl_idx,"] which has non-charstring content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.charstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.charstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != charstringType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a charstringType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefCharstring(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return ""; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getOctetstringValue
//
// Purpose:
// Returns the value as a octetstring of a direct EPTF_Var or the dereffed value of a referenced octetstringType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *octetstring* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a charstring referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getOctetstringValue(in integer pl_idx) runs on EPTF_Var_CT return octetstring {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.octetstringVal)) {
f_EPTF_Var_error(log2str("Octetstring value is requested for the EPTF_Var[",pl_idx,"] which has non-octetstring content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.octetstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.octetstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != octetstringType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not an octetstringType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefOctetstring(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return ''O; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getHexstringValue
//
// Purpose:
// Returns the value as a hexstring of a direct EPTF_Var or the dereffed value of a referenced hexstringType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *hexstring* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a hexstring referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getHexstringValue(in integer pl_idx) runs on EPTF_Var_CT return hexstring {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.hexstringVal)) {
f_EPTF_Var_error(log2str("Hexstring value is requested for the EPTF_Var[",pl_idx,"] which has non-hexstring content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.hexstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.hexstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != hexstringType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a hexstringType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefHexstring(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return ''H; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getBitstringValue
//
// Purpose:
// Returns the value as a bitstring of a direct EPTF_Var or the dereffed value of a referenced bitstringType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *bitstring* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a bitstring referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getBitstringValue(in integer pl_idx) runs on EPTF_Var_CT return bitstring {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.bitstringVal)) {
f_EPTF_Var_error(log2str("Bitstring value is requested for the EPTF_Var[",pl_idx,"] which has non-bitstring content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.bitstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.bitstringVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != bitstringType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a bitstringType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefBitstring(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return ''B; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getIntegerlistValue
//
// Purpose:
// Returns the value as an EPTF_IntegerList of a direct EPTF_Var or the dereffed value of a referenced integerlistType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *EPTF_IntegerList* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a EPTF_IntegerList referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getIntegerlistValue(in integer pl_idx) runs on EPTF_Var_CT return EPTF_IntegerList {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.integerlistVal)) {
f_EPTF_Var_error(log2str("Integerlist value is requested for the EPTF_Var[",pl_idx,"] which has non-integerlist content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.integerlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.integerlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != integerlistType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not an integerlistType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefIntegerlist(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return {}; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getFloatlistValue
//
// Purpose:
// Returns the value as an EPTF_FloatList of a direct EPTF_Var or the dereffed value of a referenced floatlistType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *EPTF_FloatList* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a EPTF_FloatList referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getFloatlistValue(in integer pl_idx) runs on EPTF_Var_CT return EPTF_FloatList {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.floatlistVal)) {
f_EPTF_Var_error(log2str("Floatlist value is requested for the EPTF_Var[",pl_idx,"] which has non-floatlist content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.floatlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.floatlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != floatlistType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not an floatlistType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefFloatlist(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return {}; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getCharstringlistValue
//
// Purpose:
// Returns the value as an EPTF_CharstringList of a direct EPTF_Var or the dereffed value of a referenced CharstringlistType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *EPTF_CharstringList* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a EPTF_CharstringList referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getCharstringlistValue(in integer pl_idx) runs on EPTF_Var_CT return EPTF_CharstringList {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.charstringlistVal)) {
f_EPTF_Var_error(log2str("Charstringlist value is requested for the EPTF_Var[",pl_idx,"] which has non-charstringlist content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.charstringlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.charstringlistVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != charstringlistType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not an charstringlistType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefCharstringlist(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return {}; // just to remove the warning, this is never executed
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getStatusLEDValue
//
// Purpose:
// Returns the value as an EPTF_StatusLED of a direct EPTF_Var or the dereffed value of a referenced statusLEDType EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *EPTF_StatusLED* - the (dereferenced) value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a EPTF_StatusLED referenced variable is stops with an error
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getStatusLEDValue(in integer pl_idx) runs on EPTF_Var_CT return EPTF_StatusLED {
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx,vl_currentContent);
if (not ischosen(vl_currentContent.statusLEDVal)) {
f_EPTF_Var_error(log2str("StatusLED value is requested for the EPTF_Var[",pl_idx,"] which has non-statusLED content"));
//f_EPTF_Base_stop();
}
return vl_currentContent.statusLEDVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
return v_EPTF_Vars[pl_idx].content.direct.statusLEDVal;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != statusLEDType) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] content is not a statusLEDType reference"));
//f_EPTF_Base_stop();
}
return f_EPTF_Var_derefStatusLED(v_EPTF_Vars[pl_idx].content.reference.valueRef);
}
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] has invalid content"));
//f_EPTF_Base_stop();
return {color:=led_black, text := ""}; // just to remove the warning, this is never executed
}
//...
/* use f_EPTF_Var_setContent instead!
// set the intValue of a direct EPTF_Var or the dereffed value of a referenced intType EPTF_Var
private function f_EPTF_Var_setIntValue(in integer pl_idx, in integer pl_newIntValue) runs on EPTF_Var_CT {
if (ischosen(v_EPTF_Vars[pl_idx].content.direct)) {
v_EPTF_Vars[pl_idx].content.direct.intVal := pl_newIntValue;
return;
}
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
if (v_EPTF_Vars[pl_idx].content.reference.refType != intType) {
log("ERROR: ", "EPTF_Var[",pl_idx,"] content is not and intType reference");
f_EPTF_Base_stop();
}
f_EPTF_Var_modifyIntRefValue(v_EPTF_Vars[pl_idx].content.reference.valueRef, pl_newIntValue);
return;
}
log("ERROR: ", "EPTF_Var[",pl_idx,"] has invalid content");
f_EPTF_Base_stop();
}*/
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getContent
//
// Purpose:
// Returns the content of an EPTF_Var or the dereffed content of a referenced EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_currentContent - *out* <EPTF_Var_DirectContent> - the content of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getContent(in integer pl_idx, out EPTF_Var_DirectContent pl_currentContent) runs on EPTF_Var_CT {
var EPTF_Var_DirectContent vl_prevContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[pl_idx].content,vl_prevContent);
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,pull)) {
v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter := v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter + 1;
var boolean vl_useOriginalProvider := v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter >= cg_EPTF_Var_routeUpdatePeriod;
if (vl_useOriginalProvider) {
v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter:=0;
}
var EPTF_Var_Ref vl_provider;
var boolean vl_prevSubsCanAdjust := v_EPTF_Vars[pl_idx].subsCanAdjust;
var boolean vl_getContentResult;
var boolean vl_subsCanAdjust;
if (v_EPTF_Vars[pl_idx].provider.remote.varRef.idx != -1 and not vl_useOriginalProvider) {
vl_getContentResult := f_EPTF_Var_getRemoteContentById(
pl_remoteCompRef := v_EPTF_Vars[pl_idx].provider.remote.varRef.compRef,
pl_remoteVarId := { idx := v_EPTF_Vars[pl_idx].provider.remote.varRef.idx},
pl_content := pl_currentContent,
pl_provider := vl_provider,
pl_subsCanAdjust := vl_subsCanAdjust
);
} else {
vl_getContentResult := f_EPTF_Var_getRemoteContentById(
pl_remoteCompRef := v_EPTF_Vars[pl_idx].provider.remote.compRef,
pl_remoteVarId := {name := v_EPTF_Vars[pl_idx].provider.remote.name},
pl_content := pl_currentContent,
pl_provider := vl_provider,
pl_subsCanAdjust := vl_subsCanAdjust
);
}
if (vl_getContentResult) {
//initialize the local var:
if (ischosen(v_EPTF_Vars[pl_idx].content.invalid)) {
v_EPTF_Vars[pl_idx].content.direct := pl_currentContent;
} else {
f_EPTF_Var_setContent(pl_idx,pl_currentContent);
}
v_EPTF_Vars[pl_idx].subsCanAdjust := vl_subsCanAdjust;
if (vl_prevContent!=pl_currentContent) {
f_EPTF_Var_updateTimeLine(pl_idx,pl_currentContent);
f_EPTF_Var_callPostProcFns(pl_idx);
}
if (vl_prevSubsCanAdjust!=v_EPTF_Vars[pl_idx].subsCanAdjust) {
f_EPTF_Var_callSubsCanAdjustNotifyFns(pl_idx);
}
if (vl_provider != {null,-1}) {
v_EPTF_Vars[pl_idx].provider.remote.varRef := vl_provider;
}
} else {
// return the cached value if remote value is not available:
pl_currentContent := vl_prevContent;
}
} else {
if (f_EPTF_Var_checkLocalSubscriptionMode(pl_idx,pull)) {
// calculate the value:
// f_EPTF_Var_refreshContent(pl_idx);
// TODO: Use refreshContent for the var or the providers only?
// var EPTF_Var_DirectContent vl_contentTmp;
// // register update for the pull mode providers, do not recalculate:
// for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList); i:=i+1) {
// if (f_EPTF_Var_checkSubscriptionMode(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i],pull)
// or f_EPTF_Var_checkLocalSubscriptionMode(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i],pull)
// ) {
// //f_EPTF_Var_refreshContent(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i]);
// f_EPTF_Var_getContent(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i], vl_contentTmp);
// }
// }
f_EPTF_Var_callCalcFn(pl_idx,pl_currentContent);
if (vl_prevContent!=pl_currentContent) {
f_EPTF_Var_setContent(pl_idx,pl_currentContent);
f_EPTF_Var_updateTimeLine(pl_idx,pl_currentContent);
f_EPTF_Var_callPostProcFns(pl_idx);
}
//f_EPTF_Var_refreshContent(pl_idx);
}
f_EPTF_Var_content2direct(v_EPTF_Vars[pl_idx].content,pl_currentContent);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setContent
//
// Purpose:
// Sets the content of an EPTF_Var or the dereffed content of a referenced EPTF_Var without invoking the refresh mechanism
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_newContent - *in* <EPTF_Var_DirectContent> - the content of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// The refresh mechanism is not invoked. The value is just copied into the content, nothing else.
// To invoke automatic refresh, use the function <f_EPTF_Var_adjustContent> instead.
// This function allows the user to modify the value of an EPTF Variable several
// times before activating the refresh mechanism. When the final value is set, use the function <f_EPTF_Var_refreshContent>
// to notify the library about the refresh.
//
// Type checking is performed in the function <f_EPTF_Var_direct2content>
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setContent(in integer pl_idx, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_Var_CT {
if (not f_EPTF_Var_direct2content(pl_newContent,v_EPTF_Vars[pl_idx].content)) {
f_EPTF_Var_error(log2str("ERROR:","Cannot set direct content ",pl_newContent," into variable #", pl_idx, " : ", v_EPTF_Vars[pl_idx]));
//f_EPTF_Base_stop();
};
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_updateRef
//
// Purpose:
// Updates the reference of the EPTF Variable to the new reference
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_newReference - *in* *octetstring* - the new reference to the component variable
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// If the content of the EPTF Variable is not a reference it does not do anything.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_updateRef(in integer pl_idx, in octetstring pl_newReference) runs on EPTF_Var_CT {
if (ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
v_EPTF_Vars[pl_idx].content.reference.valueRef := pl_newReference;
}
}
} // group VaribleCreationValueAssignment
///////////////////////////////////////////////////////////
// Group: LookUp
//
// Purpose:
// Functions to look up an EPTF Variable based on name, component variable, etc.
//
// Detailed Comments:
// Some of the functions need hashmap to be enabled
//
// Elements:
///////////////////////////////////////////////////////////
group LookUp {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getId
//
// Purpose:
// Returns the idx for the EPTF variable name. returns -1 if not found
//
// Parameters:
// pl_name - *in* *charstring* - name of the variable
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// Uses hashmap if enabled, otherwise for-cycle
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getId(in charstring pl_name) runs on EPTF_Var_CT return integer {
if (pl_name=="") {return -1;}
if (v_EPTF_Var_enableName2Id == false) {
// search using for cycle:
return f_EPTF_Var_lookupName(pl_name);
}
var integer vl_idx;
if (f_EPTF_str2int_HashMap_Find(v_EPTF_Var_Hashmap_Name2Id, pl_name, vl_idx)) {
return vl_idx;
}
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getName
//
// Purpose:
// Returns the name for the EPTF variable with the given idx.
//
// Parameters:
// pl_idx - *in* *integer* - idx of the variable
//
// Return Value:
// *charstring* - the name of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getName(in integer pl_idx) runs on EPTF_Var_CT return charstring {
return v_EPTF_Vars[pl_idx].name;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_intCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *integer* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_intCompRef2Id(inout integer pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({intType,f_EPTF_Var_getIntRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getIntRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_Id2CompRef
//
// Purpose:
// Returns the reference for the EPTF variable with the given idx.
//
// Parameters:
// pl_idx - *in* *integer* - idx of the variable
//
// Return Value:
// <EPTF_Var_ReferencedContent> - the reference to the component variable referred by the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_Id2CompRef(in integer pl_idx) runs on EPTF_Var_CT return EPTF_Var_ReferencedContent {
if(ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
return v_EPTF_Vars[pl_idx].content.reference;
}
return {intType, ''O};
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_floatCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *float* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_floatCompRef2Id(inout float pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({floatType,f_EPTF_Var_getFloatRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getFloatRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_boolCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *boolean* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_boolCompRef2Id(inout boolean pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({boolType,f_EPTF_Var_getBoolRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getBoolRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_charstringCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *integer* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_charstringCompRef2Id(inout charstring pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({charstringType,f_EPTF_Var_getCharstringRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getCharstringRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_octetstringCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *octetstring* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_octetstringCompRef2Id(inout octetstring pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({octetstringType,f_EPTF_Var_getOctetstringRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getOctetstringRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_hexstringCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *hexstring* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_hexstringCompRef2Id(inout hexstring pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({hexstringType,f_EPTF_Var_getHexstringRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getHexstringRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_bitstringCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* *bitstring* - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_bitstringCompRef2Id(inout bitstring pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({bitstringType,f_EPTF_Var_getBitstringRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getBitstringRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_integerlistCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* <EPTF_IntegerList> - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_integerlistCompRef2Id(inout EPTF_IntegerList pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({integerlistType,f_EPTF_Var_getIntegerlistRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getIntegerlistRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_floatlistCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* <EPTF_FloatList> - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_floatlistCompRef2Id(inout EPTF_FloatList pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({floatlistType,f_EPTF_Var_getFloatlistRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getFloatlistRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_charstringlistCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* <EPTF_CharstringList> - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_charstringlistCompRef2Id(inout EPTF_CharstringList pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({charstringlistType,f_EPTF_Var_getCharstringlistRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getCharstringlistRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//////////////////////////////////////////////////////////
// Function: f_EPTF_Var_statusLEDCompRef2Id
//
// Purpose:
// Returns the idx for the EPTF variable that refers to the given component variable. returns -1 if not found
//
// Parameters:
// pl_compVar - *inout* <EPTF_StatusLED> - the component variable for which the referring EPTF Variable should be found
//
// Return Value:
// *integer* - the idx of the EPTF_Var
//
// Errors:
// -
//
// Detailed Comments:
// This function is one of the type-specific functions that are implemented for
// all value types.
// The inout for pl_compVar is needed so it is not copied
// (which would result in incorrect memory address for the EPTF variable).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_statusLEDCompRef2Id(inout EPTF_StatusLED pl_compVar) runs on EPTF_Var_CT return integer {
if (v_EPTF_Var_enableCompRef2Id == false) {
return f_EPTF_Var_lookupCompRef({statusLEDType,f_EPTF_Var_getStatusLEDRef(pl_compVar)}); // hasmap is not enabled
}
var integer vl_idx;
if (f_EPTF_oct2int_HashMap_Find(v_EPTF_Var_Hashmap_CompRef2Id, f_EPTF_Var_getStatusLEDRef(pl_compVar), vl_idx)) {
return vl_idx;
}
return -1;
}
//...
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getValueRef
//
// Purpose:
// Returns the valueRef of a referenced EPTF_Var
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *octetstring* - the reference to the value of the EPTF variable
//
// Errors:
// If the EPTF Variable is not a referenced variable is stops with an error
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getValueRef(in integer pl_idx) runs on EPTF_Var_CT return octetstring {
if (not ischosen(v_EPTF_Vars[pl_idx].content.reference)) {
f_EPTF_Var_error(log2str("EPTF_Var[",pl_idx,"] is not a referenced variable"));
//f_EPTF_Base_stop();
}
return v_EPTF_Vars[pl_idx].content.reference.valueRef;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_directContent2RefType
//
// Purpose:
// Converts type information in a <EPTF_Var_DirectContent> to the enumerated type <EPTF_Var_RefType>
//
// Parameters:
// pl_directContent - <EPTF_Var_DirectContent> - the direct content to convert
//
// Return Value:
// <EPTF_Var_RefType> - the type as an enumerated
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_directContent2RefType(in EPTF_Var_DirectContent pl_directContent) runs on EPTF_Var_CT return EPTF_Var_RefType {
if (ischosen(pl_directContent.intVal)) {
return intType;
}
if (ischosen(pl_directContent.floatVal)) {
return floatType;
}
if (ischosen(pl_directContent.boolVal)) {
return boolType;
}
if (ischosen(pl_directContent.charstringVal)) {
return charstringType;
}
if (ischosen(pl_directContent.octetstringVal)) {
return octetstringType;
}
if (ischosen(pl_directContent.hexstringVal)) {
return hexstringType;
}
if (ischosen(pl_directContent.bitstringVal)) {
return bitstringType;
}
if (ischosen(pl_directContent.integerlistVal)) {
return integerlistType;
}
if (ischosen(pl_directContent.floatlistVal)) {
return floatlistType;
}
if (ischosen(pl_directContent.charstringlistVal)) {
return charstringlistType;
}
if (ischosen(pl_directContent.statusLEDVal)) {
return statusLEDType;
}
//...
f_EPTF_Base_stop();
// this is never reached:
return intType;
}
} // group LookUp
///////////////////////////////////////////////////////////
// Group: Subscribing
//
// Purpose:
// Functions to subscribe/unsubscribe to other EPTF Variables
//
// Elements:
///////////////////////////////////////////////////////////
group Subscribing {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeLocal
//
// Purpose:
// Sets the local provider for the subscriber variable pl_idx
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_localProvider - *in* <EPTF_Var_ProviderLocal> - the local provider
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeLocal(in integer pl_idx, in EPTF_Var_ProviderLocal pl_localProvider) runs on EPTF_Var_CT {
// create var automatically? subscrLocalRef?
if (not ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
f_EPTF_Var_error(log2str("Cannot set local provider for EPTF_Var[",pl_idx,"]. It has already a provider"));
//f_EPTF_Base_stop();
}
v_EPTF_Vars[pl_idx].provider := {local:=pl_localProvider};
v_EPTF_Vars[pl_idx].subsCanAdjust := false;
f_EPTF_Var_addLocalSubscriber(pl_idx, pl_localProvider.calcFn.argList);
f_EPTF_Var_refreshContent(pl_idx);
f_EPTF_Var_callSubsCanAdjustNotifyFns(pl_idx);
f_EPTF_Var_setSubsCanAdjustInAllSubscribers(pl_idx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addLocalProviders
//
// Purpose:
// Adds the local providers to the variable with ID pl_idx
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_providerList - *in* <EPTF_IntegerList> - the local providers to add
//
// Return Value:
// -
//
// Errors:
// The varible should already have local providers. If it does not,
// this function stops with an error
//
// Detailed Comments:
// This function can be used to add additional local providers to a
// variable that is a local subscriber already (i.e. <f_EPTF_Var_subscribeLocal>
// was already called)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addLocalProviders(in integer pl_idx, in EPTF_IntegerList pl_providerList)
runs on EPTF_Var_CT
{
f_EPTF_Base_assert(%definitionId&": not a local subscription.", ischosen(v_EPTF_Vars[pl_idx].provider.local));
for(var integer i:=0; i<sizeof(pl_providerList); i:=i+1) {
v_EPTF_Vars[pl_idx].provider.local.calcFn.argList
[sizeof(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList)] := pl_providerList[i];
}
f_EPTF_Var_addLocalSubscriber(pl_idx, pl_providerList);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeLocalProviders
//
// Purpose:
// Removes the local providers from the variable with ID pl_idx
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_providerList - *in* <EPTF_IntegerList> - the local providers to remove
//
// Return Value:
// -
//
// Errors:
// The varible should already have local providers. If it does not,
// this function stops with an error
//
// Detailed Comments:
// This function can be used to remove the given local providers from a
// variable that is a local subscriber already (i.e. <f_EPTF_Var_subscribeLocal>
// was already called)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeLocalProviders(in integer pl_idx, in EPTF_IntegerList pl_providerList)
runs on EPTF_Var_CT
{
f_EPTF_Base_assert(%definitionId&": not a local subscription.", ischosen(v_EPTF_Vars[pl_idx].provider.local));
f_EPTF_Var_removeLocalSubscriber(pl_idx, pl_providerList);
var EPTF_IntegerList vl_old := v_EPTF_Vars[pl_idx].provider.local.calcFn.argList;
v_EPTF_Vars[pl_idx].provider.local.calcFn.argList := {};
for(var integer i:=0; i<sizeof(vl_old); i:=i+1) {
var boolean vl_found := false;
for(var integer j:=0; j<sizeof(pl_providerList); j:=j+1) {
if(vl_old[i] == pl_providerList[j]) { vl_found := true; break;}
}
if(not vl_found) {
v_EPTF_Vars[pl_idx].provider.local.calcFn.argList
[sizeof(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList)] := vl_old[i];
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_isPresentRemote
//
// Purpose:
// Checks if a variable is present on a remote component
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote variable's component reference
// pl_remoteVarName - *in* *charstring* - the remote variable's name
//
// Return Value:
// boolean - true if present, false if not
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_isPresentRemote(in EPTF_Var_CT pl_remoteCompRef, in charstring pl_remoteVarName) runs on EPTF_Var_CT
return boolean {
var integer vl_blockingFlagIdx := f_EPTF_setNewboolean(v_booleanPool,false);
var integer vl_responseIdx := f_EPTF_setNewboolean(v_booleanPool,false);
f_EPTF_Var_addConnection(pl_remoteCompRef);
f_EPTF_Var_send(
{isPresentRemote:={
pl_remoteVarName,
vl_blockingFlagIdx,
vl_responseIdx
}},
pl_remoteCompRef
);
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_Var_maxWaitTime; // maximum wait
t_minWait.start;
t_maxWait.start;
// wait until response is received:
alt {
[f_EPTF_getValueboolean(v_booleanPool,vl_blockingFlagIdx)] t_minWait.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_warning(log2str("No response received for isPresent for: ", pl_remoteVarName, " from: ", pl_remoteCompRef));
}
}
// response is received here, boolean at vl_responseIdx is set to the appropriate value
var boolean vl_isPresentResponse := f_EPTF_getValueboolean(v_booleanPool,vl_responseIdx);
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,vl_blockingFlagIdx);
f_EPTF_deleteboolean(v_booleanPool,vl_responseIdx);
return vl_isPresentResponse;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemote
//
// Purpose:
// Creates a new EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName" (if not already subscribed)
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// If pl_localName is empty ("") only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
// If subscribing realtime to a local variable and pl_localName is not given or it is the same as pl_remoteProviderVarName, new variable
// is not created, instead the id of pl_remoteProviderVarName is returned
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemote(
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
if (pl_remoteCompRef==self and pl_subscriptionMode == realtime) {
if (f_EPTF_Var_getId(pl_remoteProviderVarName) == -1) {
// remote var does not exist
pl_idx := -1; // subscribe is unsuccessful
return;
}
if (pl_remoteProviderVarName==pl_localName or pl_localName=="") {
//remote var is on the local component and subscription is realtime and local name is not given or is the same => return the local var
pl_idx := f_EPTF_Var_getId(pl_remoteProviderVarName);
return;
} else {
// local name is given but does not match with the already existing local var
f_EPTF_Var_debug(%definitionId&
": Subscribing realtime to a local variable with a different name (existing:"&pl_remoteProviderVarName&", given:"&pl_localName&") might cause performance degradation."&
" For optimal performance pl_localName should not be specified.")
}
}
// zero or negative pl_refreshRate-s are treated as zero (default refresh method)
var integer vl_refreshRate := 0;
if (pl_refreshRate>0) {
vl_refreshRate := pl_refreshRate;
}
f_EPTF_Var_findSubscription(pl_remoteCompRef,pl_remoteProviderVarName,pl_idx);
if (pl_idx != -1) {
f_EPTF_Var_debug(log2str("Already subscribed for ", pl_remoteCompRef,":",pl_remoteProviderVarName, " by v_EPTF_Vars[",pl_idx,"]: ",v_EPTF_Vars[pl_idx]));
if ((pl_remoteProviderVarName==pl_localName or pl_localName==""
or pl_localName==v_EPTF_Vars[pl_idx].name) and vl_refreshRate == f_EPTF_Var_getVarRefreshRate(pl_idx)) {
return; // using the existing variable (the autoGenerated name is the name of the existing variable)
}
// // subscribe to the local variable:
// // FIXME: this requires more port communication than if subscribing directly to the remote var twice:
// This is better: comp1/1->comp2/2 comp1/1->comp2/3 (needs 1 message) than comp1/1->comp2/2->comp2/3 needs 2 messages
// f_EPTF_Var_subscribeRemote(self,v_EPTF_Vars[pl_idx].name,pl_subscriptionMode,pl_idx,pl_localName);
//
// no return: creating new subscriber variable
}
if (pl_subscriptionMode==pull and pl_localName=="") {
// auto-generate name for the pull mode subscriber
pl_localName := "PullSubscrOf."&log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName;
pl_idx := f_EPTF_Var_getId(pl_localName);
if (pl_idx!=-1) {
return; // already subscribed
}
}
f_EPTF_Var_addNew(pl_idx,pl_localName);
v_EPTF_Vars[pl_idx].provider := {remote:={pl_remoteProviderVarName, pl_remoteCompRef, {pl_remoteCompRef,-1},pl_subscriptionMode,vl_refreshRate,empty,0}};
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_Provider2Id,log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName,pl_idx);
if (pl_subscriptionMode==pull) {
// This is not needed if No request is sent and there is no response for pull type subscription!!!:
f_EPTF_Var_sendSubscribe(pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, 0, -1);
return; // do not have to block execution for pull mode subscription
}
// create a blocking flag:
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_Var_maxWaitTime; // maximum wait
var integer v_blockingFlagIdx := f_EPTF_setNewboolean(v_booleanPool,false);
f_EPTF_Var_sendSubscribe(pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, vl_refreshRate, v_blockingFlagIdx);
t_minWait.start;
t_maxWait.start;
// block execution until subscribeResp arrives:
alt {
[f_EPTF_getValueboolean(v_booleanPool,v_blockingFlagIdx)] t_minWait.timeout;
[] t_maxWait.timeout {
//HM27497
//It must be an error instead of warning
f_EPTF_Var_error(log2str("No response received for subscribe with data: ", pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, v_blockingFlagIdx));
//f_EPTF_Base_stopAll(); // called by f_EPTF_Var_error
}
}
// here the subscribe resp was handled, which fills in the omit value, the idx, and the name
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,v_blockingFlagIdx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemote_nonBlocking
//
// Purpose:
// Nonblocking version of <f_EPTF_Var_subscribeRemote>.
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the original name will be reused, otherwise the variable is renamed to this name.
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
// pl_respHandler - *in* <EPTF_Var_resubscribeRemoteResp_handler> - subscribe response handler callback function
//
// Return Value:
// -
//
// Errors:
//
// Detailed Comments:
// It creates an "invalid" variable in order to call f_EPTF_Var_resubscribeRemote which does not block execution until resubscription response is received.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemote_nonBlocking(
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
in charstring pl_localName := "",
in integer pl_refreshRate := -1,
in EPTF_Var_resubscribeRemoteResp_handler pl_respHandler := cg_EPTF_Var_resubscribeRemoteResp_handler_null
) runs on EPTF_Var_CT {
var integer vl_varIdx;
f_EPTF_Var_addNew(vl_varIdx,pl_localName);
f_EPTF_Var_resubscribeRemote(
pl_remoteCompRef := pl_remoteCompRef,
pl_remoteProviderVarName := pl_remoteProviderVarName,
pl_subscriptionMode := pl_subscriptionMode,
pl_idx := vl_varIdx,
pl_localName := pl_localName,
pl_refreshRate := pl_refreshRate,
pl_respHandler := pl_respHandler
)
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_resubscribeRemote
//
// Purpose:
// Resubscribes an existing EPTF Variable to the remote provider (provider on a remote component)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the original name will be reused, otherwise the variable is renamed to this name.
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
// pl_respHandler - *in* <EPTF_Var_resubscribeRemoteResp_handler> - subscribe response handler callback function
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// If pl_localName is empty ("") only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns immediately
// This function does not block execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_resubscribeRemote(
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
in integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1,
in EPTF_Var_resubscribeRemoteResp_handler pl_respHandler := cg_EPTF_Var_resubscribeRemoteResp_handler_null
) runs on EPTF_Var_CT {
if (pl_remoteCompRef==self) {
if (f_EPTF_Var_getId(pl_remoteProviderVarName) == -1) {
// remote var does not exist
// resubscribe is unsuccessful
if(pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx,false,pl_respHandler.argList);
}
return;
}
if (pl_remoteProviderVarName==f_EPTF_Var_getName(pl_idx)) {
// update the name:
if (pl_localName != "") {
v_EPTF_Vars[pl_idx].name := pl_localName;
}
if (pl_subscriptionMode != realtime) {
f_EPTF_Var_debug(%definitionId&": Resubscribing to the same variable in no-realtime mode would result in an infinite loop. Resubscribe is not done to variable "&pl_remoteProviderVarName);
if(pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx,false,pl_respHandler.argList);
}
return;
}
//remote var is the same as the var to be subscribed => do nothing for realtime mode
if(pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx,true,pl_respHandler.argList); // resubscribe is successful
}
return;
} else {
if (pl_subscriptionMode == realtime) {
f_EPTF_Var_debug(%definitionId&": Resubscribing to a local variable in realtime mode results in performance degradation.");
}
}
}
if( (f_EPTF_Var_checkSubscriptionMode(pl_idx,pl_subscriptionMode) or f_EPTF_Var_checkSubscriptionMode(pl_idx,pull) or pl_subscriptionMode == pull) and
ischosen(v_EPTF_Vars[pl_idx].provider.remote) and
v_EPTF_Vars[pl_idx].provider.remote.compRef == pl_remoteCompRef and
v_EPTF_Vars[pl_idx].provider.remote.name==pl_remoteProviderVarName) {
if(pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx,true,pl_respHandler.argList); // resubscribe is successful
}
return; // already subscribed to the same var
}
if (not ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
f_EPTF_Var_error(log2str("Cannot resubscribe the variable #",pl_idx," ",v_EPTF_Vars[pl_idx].name,
" to variable ",pl_remoteProviderVarName," on component ",pl_remoteCompRef," with subscription mode ",pl_subscriptionMode,": It has a provider already: ",v_EPTF_Vars[pl_idx].provider,". Please unsubscribe it first."));
}
// zero or negative pl_refreshRate-s are treated as zero (default refresh method)
var integer vl_refreshRate := 0;
if (pl_refreshRate>0) {
vl_refreshRate := pl_refreshRate;
}
// FIXME: do we need this? :
// if (pl_subscriptionMode==pull and pl_localName=="") {
// // auto-generate name for the pull mode subscriber
// pl_localName := "PullSubscrOf."&log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName;
// }
// update the name:
if (pl_localName != "") {
v_EPTF_Vars[pl_idx].name := pl_localName;
}
v_EPTF_Vars[pl_idx].provider := {remote:={pl_remoteProviderVarName, pl_remoteCompRef, {pl_remoteCompRef,-1},pl_subscriptionMode,vl_refreshRate,empty,0}};
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_Provider2Id,log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName,pl_idx);
// if (pl_subscriptionMode==pull) {
// //call handler
// if(pl_respHandler.handlerFn != null) {
// pl_respHandler.handlerFn.apply(pl_idx,true,pl_respHandler.argList); // resubscribe is successful
// }
// return; // No request is sent and there is no response for pull type resubscription!!!
// }
// // create a blocking flag:
// timer t_minWait := 0.0; // zero wait
// timer t_maxWait := v_Var_maxWaitTime; // maximum wait
// t_minWait.start;
// t_maxWait.start;
// store the subscribe response handler function if it is not null
if (pl_respHandler.handlerFn != null) {
v_EPTF_Var_resubscribeRemoteResp_handler_DB[pl_idx] := pl_respHandler;
}
f_EPTF_Var_sendSubscribe_nonBlocking(pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, vl_refreshRate);
// // block execution until subscribeResp arrives:
// alt {
// [f_EPTF_getValueboolean(v_booleanPool,v_blockingFlagIdx)] t_minWait.timeout;
// [] t_maxWait.timeout {
// f_EPTF_Var_error(log2str("No response received for subscribe with data: ", pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, v_blockingFlagIdx));
// //f_EPTF_Base_stopAll(); // called by f_EPTF_Var_error
// }
// }
// // here the subscribe resp was handled, which fills in the omit value, the idx, and the name
//
// // remove the bool from the pool:
// f_EPTF_deleteboolean(v_booleanPool,v_blockingFlagIdx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_isSubscribeRemoteFinished
//
// Purpose:
// Checks if a remote subscription is finished for an existing EPTF Variable
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// *boolean* - true if subscription is done, false if not, or invalid parameters
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_isSubscribeRemoteFinished(in integer pl_idx) runs on EPTF_Var_CT return boolean {
return (pl_idx!=-1 and ischosen(v_EPTF_Vars[pl_idx].provider.remote) and v_EPTF_Vars[pl_idx].provider.remote.varRef.idx != -1);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteIntRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *integer* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteIntRef(
inout integer pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {intType,f_EPTF_Var_getIntRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteFloatRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *float* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteFloatRef(
inout float pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {floatType,f_EPTF_Var_getFloatRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteBoolRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *boolean* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteBoolRef(
inout boolean pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {boolType,f_EPTF_Var_getBoolRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteCharstringRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *charstring* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteCharstringRef(
inout charstring pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {charstringType,f_EPTF_Var_getCharstringRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteOctetstringRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *octetstring* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteOctetstringRef(
inout octetstring pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {octetstringType,f_EPTF_Var_getOctetstringRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteHexstringRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *hexstring* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteHexstringRef(
inout hexstring pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {hexstringType,f_EPTF_Var_getHexstringRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteBitstringRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* *bitstring* - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteBitstringRef(
inout bitstring pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {bitstringType,f_EPTF_Var_getBitstringRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteIntegerlistRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* <EPTF_IntegerList> - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteIntegerlistRef(
inout EPTF_IntegerList pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {integerlistType,f_EPTF_Var_getIntegerlistRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteFloatlistRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* <EPTF_FloatList> - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteFloatlistRef(
inout EPTF_FloatList pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {floatlistType,f_EPTF_Var_getFloatlistRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteCharstringlistRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* <EPTF_CharstringList> - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteCharstringlistRef(
inout EPTF_CharstringList pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {charstringlistType,f_EPTF_Var_getCharstringlistRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteStatusLEDValRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable to the given component variable)
//
// Parameters:
// pl_compVar - *inout* <EPTF_StatusLED> - the component variable that will be used to create a reference for
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName"
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// Only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteStatusLEDValRef(
inout EPTF_StatusLED pl_compVar,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
var EPTF_Var_ReferencedContent v_referencedContent := {statusLEDType,f_EPTF_Var_getStatusLEDRef(pl_compVar)};
f_EPTF_Var_subscribeRemoteRef(v_referencedContent,pl_remoteCompRef,pl_remoteProviderVarName,pl_subscriptionMode, pl_idx,pl_localName,pl_refreshRate); // subscribe-ref with local name
}
//...
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_subscribeRemoteRef
//
// Purpose:
// Creates a new reference-EPTF_Var (this will be the subscriber) and subscribes it to the remote provider (provider on a remote component)
// (Same as the function <f_EPTF_Var_subscribeRemote>, but it creates a referenced-content EPTF Variable)
//
// Parameters:
// v_varReference - *in* <EPTF_Var_ReferencedContent> - the reference to a component variable to be used
// pl_remoteCompRef - *in* <EPTF_Var_CT> - the remote provider variable's component reference
// pl_remoteProviderVarName - *in* *charstring* - the remote provider variable's name
// pl_subscriptionMode - *in* <EPTF_Var_SubscriptionMode> - subscription mode: sampled or timeLine: buffered; realtime: non-buffered
// pl_idx - *out* *integer* - the idx of the new EPTF_Var
// pl_localName - *in* *charstring* *optional* - the name of the subscriber variable. If not specified (or "")
// the name will be auto-generated by the provider variable as "ProviderCompName.providerVarName" (if not already subscribed)
// pl_refreshRate - *in integer* - the refresh rate for the subscription. It is the multiplier of the elementary refresh period.
// If it is set to -1: the old refresh period is used (default)
//
// Return Value:
// -
//
// Errors:
// stops execution if the specified (or autogenerated) name is not unique
//
// Detailed Comments:
// If pl_localName is empty ("") only one subscriber can be created from the same component for a remote provider
// If there is a subscriber already, the function returns its index instead of creating
// a new subscriber
// The type-checking is performed when the subscribeResp is received in the default altstep.
// This function blocks execution until subscription response is received.
// Buffered mode means that the value of the provider will be received periodically as a time series (timeLine) or a sample (sampled)
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_subscribeRemoteRef(
in EPTF_Var_ReferencedContent v_varReference,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
out integer pl_idx,
in charstring pl_localName := "",
in integer pl_refreshRate := -1
) runs on EPTF_Var_CT {
// zero or negative pl_refreshRate-s are treated as zero (default refresh method)
var integer vl_refreshRate := 0;
if (pl_refreshRate>0) {
vl_refreshRate := pl_refreshRate;
}
f_EPTF_Var_findSubscription(pl_remoteCompRef,pl_remoteProviderVarName,pl_idx);
if (pl_idx != -1) {
f_EPTF_Var_debug(log2str("Already subscribed for ", pl_remoteCompRef,":",pl_remoteProviderVarName, " by v_EPTF_Vars[",pl_idx,"]: ",v_EPTF_Vars[pl_idx]));
if (pl_localName == "" and vl_refreshRate == f_EPTF_Var_getVarRefreshRate(pl_idx)) {
return; // using the existing variable (the autoGenerated name is the name of the existing variable)
}
// // subscribe to the local variable:
// // FIXME: this requires more port communication than if subscribing directly to the remote var twice:
// This is better: comp1/1->comp2/2 comp1/1->comp2/3 (needs 1 message) than comp1/1->comp2/2->comp2/3 needs 2 messages
// f_EPTF_Var_subscribeRemoteRef(v_varReference,self,v_EPTF_Vars[pl_idx].name,pl_subscriptionMode,pl_idx,pl_localName);
//
// no return: creating new subscriber variable
}
f_EPTF_Var_addNew(pl_idx,pl_localName);
v_EPTF_Vars[pl_idx].provider := {remote:={pl_remoteProviderVarName, pl_remoteCompRef,{pl_remoteCompRef,-1},pl_subscriptionMode,vl_refreshRate,empty,0}};
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_Provider2Id,log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName,pl_idx);
f_EPTF_Var_initContentRef(pl_idx,v_varReference);
if (pl_subscriptionMode==pull) {
// This is not needed if No request is sent and there is no response for pull type subscription!!!:
f_EPTF_Var_sendSubscribe(pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, 0, -1);
return; // do not have to block execution for pull mode subscription
}
// create a blocking flag:
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_Var_maxWaitTime; // maximum wait
var integer v_blockingFlagIdx := f_EPTF_setNewboolean(v_booleanPool,false);
f_EPTF_Var_sendSubscribe(pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, vl_refreshRate, v_blockingFlagIdx);
t_minWait.start;
t_maxWait.start;
// block execution until subscribeResp arrives:
alt {
[f_EPTF_getValueboolean(v_booleanPool,v_blockingFlagIdx)] t_minWait.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_error(log2str("No response received for subscribe with data: ", pl_idx, pl_remoteCompRef, pl_remoteProviderVarName, pl_subscriptionMode, v_blockingFlagIdx));
//f_EPTF_Base_stopAll(); // called by f_EPTF_Var_error
}
}
// here the subscribe resp was handled, which fills in the omit value, the idx, and the name
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,v_blockingFlagIdx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_checkSubscriptionMode
//
// Purpose:
// Checks if the variable has the given subscription mode
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_subscriptionMode - *in* *EPTF_Var_SubscriptionMode* - the expected subscription mode
//
// Return Value:
// boolean - true if the variable was subscribed to a remote variable with the specified mode
//
// Errors:
// -
//
// Detailed Comments:
// If the provider of the variable is remote and the subscription mode is the one specified
// in the argument pl_subscriptionMode the function returns true, otherwise false.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_checkSubscriptionMode(in integer pl_idx, in EPTF_Var_SubscriptionMode pl_subscriptionMode)
runs on EPTF_Var_CT return boolean {
return (ischosen(v_EPTF_Vars[pl_idx].provider.remote) and pl_subscriptionMode == v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode);
}
private function f_EPTF_Var_checkLocalSubscriptionMode(in integer pl_idx, in EPTF_Var_SubscriptionMode pl_subscriptionMode)
runs on EPTF_Var_CT return boolean {
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList); i:=i+1) {
if (f_EPTF_Var_checkSubscriptionMode(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i],pl_subscriptionMode)
or f_EPTF_Var_checkLocalSubscriptionMode(v_EPTF_Vars[pl_idx].provider.local.calcFn.argList[i],pl_subscriptionMode)) {
return true;
}
}
}
return false;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_unsubscribe
//
// Purpose:
// Unsubscribes the pl_ids EPTF Variable from its provider(s)
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_unsubscribe(in integer pl_idx) runs on EPTF_Var_CT {
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
// removes the local-subscriber variable pl_idx from its provider list
f_EPTF_Var_removeLocalSubscriber(pl_idx, v_EPTF_Vars[pl_idx].provider.local.calcFn.argList);
v_EPTF_Vars[pl_idx].provider := { empty:= {} };
f_EPTF_Var_callUnsubscribeNotifyFns(pl_idx);
} else if (ischosen(v_EPTF_Vars[pl_idx].provider.remote)) {
// unsubscribes from the remote provider (and removes the EPTF_Var (this was the subscriber))
if (v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode != pull) {
// no notification is sent to provider for pull mode subscription
if (v_EPTF_Vars[pl_idx].provider.remote.varRef.idx != -1) {
// unsubscribe only if we know the owner idx (subscribeResp arrived)
f_EPTF_sendUnsubscribe(pl_idx, v_EPTF_Vars[pl_idx].provider.remote.varRef, v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode,v_EPTF_Vars[pl_idx].provider.remote.refreshRate);
}
}
var EPTF_Var_CT vl_remoteCompRef := v_EPTF_Vars[pl_idx].provider.remote.compRef;
var charstring vl_remoteProviderVarName :=v_EPTF_Vars[pl_idx].provider.remote.name;
f_EPTF_str2int_HashMap_Erase(v_EPTF_Var_Hashmap_Provider2Id,log2str(vl_remoteCompRef)&"."&vl_remoteProviderVarName);
v_EPTF_Vars[pl_idx].provider := { empty:= {} };
f_EPTF_Var_callUnsubscribeNotifyFns(pl_idx);
//f_EPTF_Var_removeVar(pl_idx);
} else if (ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
// nothing to do
}
}
} // group Subscribing
///////////////////////////////////////////////////////////
// Group: UserHandlers
//
// Purpose:
// Functions related to user handlers that will be called by the library
// at specific events like the value of a variable was updated etc.
//
// Elements:
///////////////////////////////////////////////////////////
group UserHandlers {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callCalcFn
//
// Purpose:
// Calls the calcFn function if possible, otherwise returns the current (dereferenced)content
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_retVal - *inout* <EPTF_Var_DirectContent> - the value calculated by the CalcFn function
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callCalcFn(in integer pl_idx, inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_Var_CT {
f_EPTF_Var_content2direct(v_EPTF_Vars[pl_idx].content,pl_retVal);
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
if (v_EPTF_Vars[pl_idx].provider.local.calcFn.funcRef != null) {
v_EPTF_Vars[pl_idx].provider.local.calcFn.funcRef.apply(pl_idx,v_EPTF_Vars[pl_idx].provider.local.calcFn.argList,v_EPTF_Vars[pl_idx].provider.local.calcFn.nonVarArgList,pl_retVal);
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callPostProcFns
//
// Purpose:
// Calls the prostProcFn functions if possible
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callPostProcFns(in integer pl_idx) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].postProcFns); i:=i+1) {
if (v_EPTF_Vars[pl_idx].postProcFns[i].funcRef != null) {
f_EPTF_Var_debug(log2str("Calling postProcFn of var ",pl_idx,": ", v_EPTF_Vars[pl_idx].postProcFns[i].funcRef,
" args: ",v_EPTF_Vars[pl_idx].postProcFns[i].argList));
v_EPTF_Vars[pl_idx].postProcFns[i].funcRef.apply(pl_idx,v_EPTF_Vars[pl_idx].postProcFns[i].argList);
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addPostProcFn
//
// Purpose:
// Adds a new postProc function to the pl_idx variable. Checks if it had been added already
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_postProcFn - *in* <EPTF_Var_GenericFn> - the postProc function to add
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addPostProcFn(in integer pl_idx, in EPTF_Var_GenericFn pl_postProcFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].postProcFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].postProcFns[i] == pl_postProcFn) {
return; // already added
}
}
v_EPTF_Vars[pl_idx].postProcFns[sizeof(v_EPTF_Vars[pl_idx].postProcFns)] := pl_postProcFn;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removePostProcFn
//
// Purpose:
// Removes the postProc function
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_postProcFn - *in* <EPTF_Var_GenericFn> - the postProc function to remove
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removePostProcFn(in integer pl_idx, in EPTF_Var_GenericFn pl_postProcFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].postProcFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].postProcFns[i] == pl_postProcFn) {
v_EPTF_Vars[pl_idx].postProcFns[i] := {null,{}};
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callGuardFns
//
// Purpose:
// Calls the guard functions. If any of them returns false, this function will return false, otherwise it'll return true
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_newContent - *in* <EPTF_Var_DirectContent> - the new value to be checked
//
// Return Value:
// *boolean* - true if value accepted, false if not
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callGuardFns(in integer pl_idx, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_Var_CT return boolean {
var boolean vl_result := true;
// type compatibility check:
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[pl_idx].content,vl_currentContent);
//f_EPTF_Var_getContent(pl_idx,vl_currentContent);
// try to set new content into current:
var EPTF_Var_Content vl_content := {direct := vl_currentContent};
if (not f_EPTF_Var_direct2content(pl_newContent,vl_content)) {
return false;
};
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].guardFns); i:=i+1) {
if (v_EPTF_Vars[pl_idx].guardFns[i].funcRef != null) {
vl_result := v_EPTF_Vars[pl_idx].guardFns[i].funcRef.apply(pl_idx,v_EPTF_Vars[pl_idx].guardFns[i].argList,pl_newContent);
if (vl_result == false) {
f_EPTF_Var_warning(log2str("The guard function #",i," (",v_EPTF_Vars[pl_idx].guardFns[i],") of EPTF_Var[",pl_idx,"]: ",v_EPTF_Vars[pl_idx].name," does not accept the new value: ",pl_newContent));
return false;
}
}
}
return true;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addGuardFn
//
// Purpose:
// Adds a new guard function to the pl_idx variable. Checks if it had been added already
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_guardFn - *in* <EPTF_Var_GuardFn> - the guard function to add
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addGuardFn(in integer pl_idx, in EPTF_Var_GuardFn pl_guardFn) runs on EPTF_Var_CT {
// if the variable has a remote provider, warning is shown that the guards are not allowed:
if (ischosen(v_EPTF_Vars[pl_idx].provider.remote)) {
f_EPTF_Var_warning(log2str(%definitionId, " Guard fn ",pl_guardFn," is ignored for " &
"Variable[",pl_idx,"] ", v_EPTF_Vars[pl_idx].name,": it has a remote provider." &
" Only the guard fns of the top-provider (owner) are called."));
}
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].guardFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].guardFns[i] == pl_guardFn) {
return; // already added
}
}
v_EPTF_Vars[pl_idx].guardFns[sizeof(v_EPTF_Vars[pl_idx].guardFns)] := pl_guardFn;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeGuardFn
//
// Purpose:
// Removes the guard function
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_guardFn - *in* <EPTF_Var_GuardFn> - the guard function to remove
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeGuardFn(in integer pl_idx, in EPTF_Var_GuardFn pl_guardFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].guardFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].guardFns[i] == pl_guardFn) {
v_EPTF_Vars[pl_idx].guardFns[i] := {null,{}};
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callUnsubscribeNotifyFns
//
// Purpose:
// Calls the unsubscribeNotifyFns functions if possible
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callUnsubscribeNotifyFns(in integer pl_idx) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].unsubscribeNotifyFns); i:=i+1) {
if (v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i].funcRef != null) {
v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i].funcRef.apply(pl_idx,v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i].argList);
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addUnsubscribeNotifyFn
//
// Purpose:
// Adds a new unsubscribe function to the pl_idx variable. Checks if it had been added already
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_unsubscribeNotifyFn - *in* <EPTF_Var_GenericFn> - the postProc function to add
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addUnsubscribeNotifyFn(in integer pl_idx, in EPTF_Var_GenericFn pl_unsubscribeNotifyFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].unsubscribeNotifyFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i] == pl_unsubscribeNotifyFn) {
return; // already added
}
}
v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[sizeof(v_EPTF_Vars[pl_idx].unsubscribeNotifyFns)] := pl_unsubscribeNotifyFn;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeUnsubscribeNotifyFn
//
// Purpose:
// Removes the unsubscribe function
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_unsubscribeNotifyFn - *in* <EPTF_Var_PostProcFn> - the postProc function to remove
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeUnsubscribeNotifyFn(in integer pl_idx, in EPTF_Var_GenericFn pl_unsubscribeNotifyFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].unsubscribeNotifyFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i] == pl_unsubscribeNotifyFn) {
v_EPTF_Vars[pl_idx].unsubscribeNotifyFns[i] := {null,{}};
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callSubsCanAdjustNotifyFns
//
// Purpose:
// Calls the subsCanAdjustNotifyFn functions if possible
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callSubsCanAdjustNotifyFns(in integer pl_idx) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns); i:=i+1) {
if (v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i].funcRef != null) {
f_EPTF_Var_debug(log2str("Calling subsCanAdjustNotifyFn of var ",pl_idx,": ", v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i].funcRef,
" args: ",v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i].argList));
v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i].funcRef.apply(pl_idx,v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i].argList);
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addSubsCanAdjustNotifyFn
//
// Purpose:
// Adds a new subsCanAdjustNotify function to the pl_idx variable. Checks if it had been added already
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_subsCanAdjustNotifyFn - *in* <EPTF_Var_GenericFn> - the subsCanAdjustNotify function to add
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addSubsCanAdjustNotifyFn(in integer pl_idx, in EPTF_Var_GenericFn pl_subsCanAdjustNotifyFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i] == pl_subsCanAdjustNotifyFn) {
return; // already added
}
}
v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[sizeof(v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns)] := pl_subsCanAdjustNotifyFn;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeSubsCanAdjustNotifyFn
//
// Purpose:
// Removes the subsCanAdjustNotify function
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_subsCanAdjustNotifyFn - *in* <EPTF_Var_GenericFn> - the subsCanAdjustNotify function to remove
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeSubsCanAdjustNotifyFn(in integer pl_idx, in EPTF_Var_GenericFn pl_subsCanAdjustNotifyFn) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns);i:=i+1) {
if (v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i] == pl_subsCanAdjustNotifyFn) {
v_EPTF_Vars[pl_idx].subsCanAdjustNotifyFns[i] := {null,{}};
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_callSyncCallBackFns
//
// Purpose:
// Calls the syncCallbackFn functions if possible
//
// Parameters:
// pl_syncState - *in* <EPTF_Var_SyncState> - state of the sync event (begin or end)
// pl_refreshRateId - *in* *integer* - the refreshRateId in v_syncBuffer (default:0 default refresh rate)
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_callSyncCallBackFns(in EPTF_Var_SyncState pl_syncState, in integer pl_refreshRateId := 0) runs on EPTF_Var_CT {
if (pl_refreshRateId>=sizeof(v_EPTF_Var_syncCallbackFns)) {
return; // index out of range, no callbacks for that rate
}
for(var integer i:=0; i<sizeof(v_EPTF_Var_syncCallbackFns[pl_refreshRateId]); i:=i+1) {
if (v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i].funcRef != null) {
// calback function is only called at the specified sync state:
if (pl_syncState == v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i].syncState) {
v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i].funcRef.apply(v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i].argList);
}
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addSyncCallBackFn
//
// Purpose:
// Adds a new callback to the list of syncCallBacks that will be called at the sync event before the timelines are sent.
// Checks if it had been added already
//
// Parameters:
// pl_funcRef - *in* <EPTF_Var_fcb_SyncCallbackFn> - the reference to callback function to add to the syncCallback list
// pl_argList - *in* <EPTF_IntegerList> - list of indexes used by the function. This arglist will be passed to funcRef as its arguments
// pl_syncState - *in* <EPTF_Var_SyncState> - the function is called only at this syncState.
// Can be only c_EPTF_Var_syncBegin, or c_EPTF_Var_syncEnd. Default: c_EPTF_Var_syncBegin
// pl_refreshRateId - *in* *integer* - the refreshRateId in v_syncBuffer (default:0 default refresh rate)
//
// Return Value:
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_addSyncCallBackFn(
in EPTF_Var_fcb_SyncCallbackFn pl_funcRef,
in EPTF_IntegerList pl_argList,
in EPTF_Var_SyncState pl_syncState := c_EPTF_Var_syncBegin,
in integer pl_refreshRateId := 0
) runs on EPTF_Var_CT {
var EPTF_Var_SyncCallbackFn vl_syncCallbackFn := {
pl_funcRef,
pl_argList,
pl_syncState
};
if (pl_refreshRateId>=sizeof(v_EPTF_Var_syncCallbackFns)) {
v_EPTF_Var_syncCallbackFns[pl_refreshRateId] := {}; // index out of range, no callbacks for that rate
}
for(var integer i:=0; i<sizeof(v_EPTF_Var_syncCallbackFns[pl_refreshRateId]);i:=i+1) {
if (v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i] == vl_syncCallbackFn) {
return; // already added
}
}
v_EPTF_Var_syncCallbackFns[pl_refreshRateId][sizeof(v_EPTF_Var_syncCallbackFns[pl_refreshRateId])] := vl_syncCallbackFn;
// schedule sync event if not scheduled (for 0 rate it is scheduled in init function):
if (v_syncBuffer[pl_refreshRateId].eventIdx == -1) {
if(f_EPTF_SchedulerComp_scheduleAction(
pl_when := f_EPTF_Base_getRelTimeInSecs()+int2float(v_syncBuffer[pl_refreshRateId].refreshRate)*v_minSyncInterval,
pl_actionHandler := refers(f_EPTF_Var_syncTimeoutHandler),
pl_action := {pl_refreshRateId},
pl_eventIndex := v_syncBuffer[pl_refreshRateId].eventIdx
)) {/*remove the warning*/};
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeSyncCallBackFn
//
// Purpose:
// Removes the syncCallback function
//
// Parameters:
// pl_syncCallbackFn - *in* <EPTF_Var_SyncCallbackFn> - the postProc function to remove
// pl_refreshRateId - *in* *integer* - the refreshRateId in v_syncBuffer (default:0 default refresh rate)
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeSyncCallBackFn(in EPTF_Var_SyncCallbackFn pl_syncCallbackFn, in integer pl_refreshRateId := 0) runs on EPTF_Var_CT {
if (pl_refreshRateId>=sizeof(v_EPTF_Var_syncCallbackFns)) {
return; // index out of range, no callbacks for that rate
}
for(var integer i:=0; i<sizeof(v_EPTF_Var_syncCallbackFns[pl_refreshRateId]);i:=i+1) {
if (v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i] == pl_syncCallbackFn) {
v_EPTF_Var_syncCallbackFns[pl_refreshRateId][i] := {null,{},c_EPTF_Var_syncBegin};
return;
}
}
}
} // group UserHandlers
///////////////////////////////////////////////////////////
// Group: UpdateContent
//
// Purpose:
// Functions that will nofity the library about the value change of
// an EPTF Variable.
//
// Elements:
///////////////////////////////////////////////////////////
group UpdateContent {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_refreshContent
//
// Purpose:
// Requests the library to recalculate the content of the EPTF_Var.
// Also notifies all of its subscribers about the new value
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This function can be used to invoke the refresh mechanism of the library
// after the content of the variable was changed by the user (e.g. refrenced variables).
// Also for EPTF Variables with local provider the calcfn function is called
// Then all subscribers are notified about the value change.
// This function can be called for EPTF Variables with any kind of provider.
// But to change the value of an EPTF Variable with remote or empty provider, use the
// function <f_EPTF_Var_adjustContent> instead.
// The refresh mechanism makes it possible to update the value of all subscribers
// when the owner changes its value.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_refreshContent(in integer pl_idx) runs on EPTF_Var_CT {
var EPTF_Var_DirectContent vl_contentNew;
f_EPTF_Var_callCalcFn(pl_idx,vl_contentNew);
f_EPTF_Var_registerRefresh(pl_idx,vl_contentNew);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getSubsCanAdjust
//
// Purpose:
// Returns the subsCanAdjust flag for the variable.
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// boolean - the value of the subsCanAdjust flag
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getSubsCanAdjust(in integer pl_idx)
runs on EPTF_Var_CT
return boolean {
return v_EPTF_Vars[pl_idx].subsCanAdjust;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setSubsCanAdjust
//
// Purpose:
// Sets the subsCanAdjust flag for the variable.
// Also notifies all of its subscribers about the new value
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_subsCanAdjust - *in* *boolean* - the new value of the subsCanAdjust flag
//
// Return Value:
// -
//
// Errors:
// If it is called for a Variable with a local or remote provider.
//
// Detailed Comments:
// This function can be called for EPTF Variables without a provider (provider empty).
// If the new falue of the flag is the same as the current value, nothing happens.
// The callbacks registered by <f_EPTF_Var_addSubsCanAdjustNotifyFn> are called.
// All the subscribers are notified about the value change, and their callbacks are called also.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setSubsCanAdjust(in integer pl_idx, in boolean pl_subsCanAdjust) runs on EPTF_Var_CT {
if (not ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
f_EPTF_Var_error(log2str("Cannot set the subsCanAdjust flag of the EPTF_Var[",pl_idx,"], it has a provider: ", v_EPTF_Vars[pl_idx]));
}
if (v_EPTF_Vars[pl_idx].subsCanAdjust == pl_subsCanAdjust) {
return;
}
v_EPTF_Vars[pl_idx].subsCanAdjust := pl_subsCanAdjust;
f_EPTF_Var_callSubsCanAdjustNotifyFns(pl_idx);
f_EPTF_Var_setSubsCanAdjustInAllSubscribers(pl_idx);
}
private function f_EPTF_Var_setSubsCanAdjustInAllSubscribers(in integer pl_idx) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subscribers); i:=i+1) {
f_EPTF_Var_setSubsCanAdjustInSubscriber(pl_idx, v_EPTF_Vars[pl_idx].subscribers[i]);
}
}
private function f_EPTF_Var_setSubsCanAdjustInSubscriber(in integer pl_idx, in EPTF_Var_Subscriber pl_subscriber) runs on EPTF_Var_CT {
if(ischosen(pl_subscriber.local)) {
// subscriber is local
return;
}
if(ischosen(pl_subscriber.remote)) {
f_EPTF_Var_send(
{setSubsCanAdjust:={
pl_subscriber.remote.varRef,v_EPTF_Vars[pl_idx].subsCanAdjust}},
pl_subscriber.remote.varRef.compRef);
}
}
// calls user handler
private function f_EPTF_Var_adjustContentRespHandlerForPull(
in integer pl_idx,
in EPTF_Var_DirectContent pl_content,
in boolean pl_result,
in EPTF_IntegerList pl_argList
) runs on EPTF_Var_CT {
var integer vl_myIdx := pl_argList[0];
var integer vl_respHandlerId := pl_argList[1];
// call user handler:
var EPTF_Var_adjustContentResp_handler vl_respHandler;
if (f_EPTF_getEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,vl_respHandlerId,vl_respHandler)) {
vl_respHandler.handlerFn.apply(vl_myIdx, pl_content, pl_result, vl_respHandler.argList);
// release the stack:
f_EPTF_deleteEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,vl_respHandlerId);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustContent
//
// Purpose:
// Requests the library to adjust the content of the EPTF_Var.
// Also notifies all of its subscribers about the new value
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_newContent - *in* <EPTF_Var_DirectContent> - the new value to try to set
// pl_respHandler - <EPTF_Var_adjustContentNack_handler> - user handler to call when the adjust is ready (i.e. when adjustResp arrives, or when the guards accept the new value)
// but before the value of the variable is refreshed
//
// Return Value:
// -
//
// Errors:
// For EPTF Variables with local provider, the function stops with an error.
// Adjustment of calculated variables is not allowed. Call <f_EPTF_Var_refreshContent> instead.
//
// Detailed Comments:
// For EPTF Variables with remote provider a request is sent for its remote provider to
// adjust the value. If accepted, the new value is written into the content, if not,
// the prevoius value is set into the content.
// Using the adjust mechanism for EPTF Variables with remote provider too often
// might indicate incorrect design.
//
// For EPTF Variables with no provider the new value is checked by the guardFns
// before it is written into the content.
//
// After a successful adjust, all subscribers of the owner EPTF Variable
// are notified about the new value. Then the postProc functions are called.
//
// The adjust mechanism allows the user to modify the value of a local parameter (i.e. an EPTF variable with no provider)
// or to be able to modify the original EPTF Variable from a remote subscriber.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_adjustContent(in integer pl_idx, in EPTF_Var_DirectContent pl_newContent, in EPTF_Var_adjustContentResp_handler pl_respHandler := {null, {}}) runs on EPTF_Var_CT {
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. It has a local provider! ", v_EPTF_Vars[pl_idx]));
if (pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx, pl_newContent, false, pl_respHandler.argList);
}
return;
}
if (ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
// I am a "parameter", adjust allowed after the guard fns accept the new value.
//call the guard fns:
var boolean vl_result := f_EPTF_Var_callGuardFns(pl_idx,pl_newContent);
// call the adjustResp handler:
if (pl_respHandler.handlerFn != null) {
// call the user handler:
pl_respHandler.handlerFn.apply(pl_idx, pl_newContent, vl_result, pl_respHandler.argList);
}
if (not vl_result) {
// content not accepted
} else {
// refreshContent is called to notify subscribers:
// and set the received content into the current:
f_EPTF_Var_registerRefresh(pl_idx,pl_newContent);
}
return;
}
// remote provider:
if (ischosen(v_EPTF_Vars[pl_idx].provider.remote)) {
if (v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode == pull) {
v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter := v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter + 1;
var boolean vl_useOriginalProvider := v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter >= cg_EPTF_Var_routeUpdatePeriod;
if (vl_useOriginalProvider) {
v_EPTF_Vars[pl_idx].provider.remote.routeUpdateCounter:=0;
}
var EPTF_Var_adjustContentResp_handler vl_respHandler;
// store function params into the stack (if not null):
var integer vl_respHandlerId := -1;
if (pl_respHandler.handlerFn != null) {
vl_respHandlerId := f_EPTF_setNewEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_respHandler);
vl_respHandler := {refers(f_EPTF_Var_adjustContentRespHandlerForPull), {pl_idx,vl_respHandlerId}}
} else {
vl_respHandler := pl_respHandler;
}
if (v_EPTF_Vars[pl_idx].provider.remote.varRef.idx != -1 and not vl_useOriginalProvider) {
f_EPTF_Var_adjustRemoteContentByIdx(
v_EPTF_Vars[pl_idx].provider.remote.varRef.compRef,
v_EPTF_Vars[pl_idx].provider.remote.varRef.idx,
pl_newContent,
vl_respHandler
);
} else {
f_EPTF_Var_adjustRemoteContent(
v_EPTF_Vars[pl_idx].provider.remote.compRef,
v_EPTF_Vars[pl_idx].provider.remote.name,
pl_newContent,
vl_respHandler
);
}
return;
}
if (v_EPTF_Vars[pl_idx].provider.remote.varRef.idx<0) {
// subscription is in progress. Have to wait for response to execute the actual adjust:
// just store the new value now:
f_EPTF_Var_setContent(pl_idx, pl_newContent);
// flag this variable that adjust was buffered:
v_EPTF_Vars[pl_idx].provider.remote.varRef.idx := -2;
// refresh will be done when subscribeResp arrives
return;
}
if (not v_EPTF_Vars[pl_idx].subsCanAdjust) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. The subsCanAdjust flag is false! ", v_EPTF_Vars[pl_idx]));
if (pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx, pl_newContent, false, pl_respHandler.argList);
}
return;
}
// check top provider type:
if (v_EPTF_Vars[pl_idx].provider.remote.topProviderType == local) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. It has a local top-provider! ", v_EPTF_Vars[pl_idx]));
if (pl_respHandler.handlerFn != null) {
pl_respHandler.handlerFn.apply(pl_idx, pl_newContent, false, pl_respHandler.argList);
}
return;
}
// store function params into the stack (if not null):
var integer vl_respHandlerId := -1;
if (pl_respHandler.handlerFn != null) {
vl_respHandlerId := f_EPTF_setNewEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_respHandler);
}
// send adjust message to the remote provider:
f_EPTF_Var_send(
{adjustContent:={
{{{self,pl_idx}},0},
v_EPTF_Vars[pl_idx].provider.remote.varRef,
pl_newContent,
vl_respHandlerId
}},
v_EPTF_Vars[pl_idx].provider.remote.varRef.compRef
);
return;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustContent_Blocking
//
// Purpose:
// The blocking version of <f_EPTF_Var_adjustContent> it returns the result of the adjust
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_newContent - *in* <EPTF_Var_DirectContent> - the new value to try to set
//
// Return Value:
// *boolean* - false if adjust failed; true if successful
//
// Errors:
// For EPTF Variables with local provider, the function stops with an error.
// Adjustment of calculated variables is not allowed. Call <f_EPTF_Var_refreshContent> instead.
//
// Detailed Comments:
// For EPTF Variables with remote provider a request is sent for its remote provider to
// adjust the value. If accepted, the new value is written into the content, if not,
// the prevoius value is set into the content.
// Using the adjust mechanism for EPTF Variables with remote provider too often
// might indicate incorrect design.
//
// For EPTF Variables with no provider the new value is checked by the guardFns
// before it is written into the content.
//
// After a successful adjust, all subscribers of the owner EPTF Variable
// are notified about the new value. Then the postProc functions are called.
//
// The adjust mechanism allows the user to modify the value of a local parameter (i.e. an EPTF variable with no provider)
// or to be able to modify the original EPTF Variable from a remote subscriber.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_adjustContent_Blocking(in integer pl_idx, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_Var_CT return boolean {
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. It has a local provider! ", v_EPTF_Vars[pl_idx]));
return false;
}
var boolean vl_result := true;
if (ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
// I am a "parameter", adjust allowed after the guard fns accept the new value.
//call the guard fns:
vl_result := f_EPTF_Var_callGuardFns(pl_idx,pl_newContent);
if (not vl_result) {
// content not accepted
} else {
// refreshContent is called to notify subscribers:
// and set the received content into the current:
f_EPTF_Var_registerRefresh(pl_idx,pl_newContent);
}
return vl_result;
}
// remote provider:
if (ischosen(v_EPTF_Vars[pl_idx].provider.remote)) {
if (v_EPTF_Vars[pl_idx].provider.remote.varRef.idx<0) {
// subscription is in progress. Have to wait for response:
// wait until subscribed:
timer t_waitForSubscr := 0.0;
t_waitForSubscr.start;
timer t_maxWait := v_Var_maxWaitTime;
t_maxWait.start;
alt {
[f_EPTF_Var_isSubscribeRemoteFinished(pl_idx)] t_waitForSubscr.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_warning(log2str("No response received for subscribe for variable #", pl_idx, ": ",v_EPTF_Vars[pl_idx]));
return false;
}
}
}
if (not v_EPTF_Vars[pl_idx].subsCanAdjust) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. The subsCanAdjust flag is false! ", v_EPTF_Vars[pl_idx]));
return false;
}
// check top provider type:
if (v_EPTF_Vars[pl_idx].provider.remote.topProviderType == local) {
f_EPTF_Var_debug(log2str("Cannot adjust the content of the EPTF_Var[",pl_idx,"]. It has a local top-provider! ", v_EPTF_Vars[pl_idx]));
return false;
}
// send adjust message to the remote provider:
f_EPTF_Var_send(
{adjustContent:={
{{{self,pl_idx}},0},
v_EPTF_Vars[pl_idx].provider.remote.varRef,
pl_newContent,-1 // no handler
}},
v_EPTF_Vars[pl_idx].provider.remote.varRef.compRef
);
// blocks execution until response arrives:
as_EPTF_Var_handle_AdjustContentResp(pl_idx, pl_newContent, vl_result);
return vl_result;
}
return vl_result;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getRemoteContent
//
// Purpose:
// This function returns the content of a remote EPTF Variable (without subscription)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - reference to the remote component
// pl_remoteVarName - *in* *charstring* - name of the EPTF Variable in the remote component
// pl_content - *out* <EPTF_Var_DirectContent> - the value of the remote EPTF Variable
//
// Return Value:
// boolean - false, if content is not available, true, if the returned content is valid
//
// Errors:
// -
//
// Detailed Comments:
// This function blocks the execution until the response is received.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getRemoteContent(in EPTF_Var_CT pl_remoteCompRef, in charstring pl_remoteVarName, out EPTF_Var_DirectContent pl_content) runs on EPTF_Var_CT return boolean {
var EPTF_Var_Ref vl_provider;
var boolean vl_subsCanAdjust;
return f_EPTF_Var_getRemoteContentById(pl_remoteCompRef,{name := pl_remoteVarName},pl_content,vl_provider,vl_subsCanAdjust);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getRemoteContentById
//
// Purpose:
// This function returns the content of a remote EPTF Variable (without subscription)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - reference to the remote component
// pl_remoteVarId - *in* <EPTF_Var_VarId> - id of the EPTF Variable in the remote component
// pl_content - *out* <EPTF_Var_DirectContent> - the value of the remote EPTF Variable
// pl_subsCanAdjust - *out* *boolean* - the value of the subsCanAdjust flag of the remote EPTF Variable
//
// Return Value:
// boolean - false, if content is not available, true, if the returned content is valid
//
// Errors:
// -
//
// Detailed Comments:
// This function blocks the execution until the response is received.
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_getRemoteContentById(in EPTF_Var_CT pl_remoteCompRef, in EPTF_Var_VarId pl_remoteVarId,
out EPTF_Var_DirectContent pl_content,
out EPTF_Var_Ref pl_provider,
out boolean pl_subsCanAdjust
) runs on EPTF_Var_CT return boolean {
if (pl_remoteCompRef==self) {
var integer vl_idx;
if (ischosen(pl_remoteVarId.name)) {
vl_idx := f_EPTF_Var_getId(pl_remoteVarId.name);
} else {
vl_idx := pl_remoteVarId.idx;
}
if (vl_idx==-1) {
pl_provider:={null,vl_idx};
pl_content:={unknownVal:={omit}}
pl_subsCanAdjust := false;
return false;
}
// request original provider if getRemoteContent uses name
if (f_EPTF_Var_checkSubscriptionMode(vl_idx,pull) and ischosen(pl_remoteVarId.name)) {
v_EPTF_Vars[vl_idx].provider.remote.routeUpdateCounter := cg_EPTF_Var_routeUpdatePeriod;
}
f_EPTF_Var_getContent(vl_idx,pl_content);
pl_provider:={self,vl_idx};
if (f_EPTF_Var_checkSubscriptionMode(vl_idx,pull)
and v_EPTF_Vars[vl_idx].provider.remote.varRef.idx != -1
) {
pl_provider := v_EPTF_Vars[vl_idx].provider.remote.varRef; // replace myself with my provider
}
pl_subsCanAdjust := v_EPTF_Vars[vl_idx].subsCanAdjust;
return true;
}
f_EPTF_Var_addConnection(pl_remoteCompRef);
var integer vl_blockingFlagIdx := f_EPTF_setNewboolean(v_booleanPool,false);
var integer vl_responseIdx := f_EPTF_setNewboolean(v_booleanPool,false);
f_EPTF_Var_send({getRemoteContent := {pl_remoteVarId,vl_blockingFlagIdx,vl_responseIdx}}, pl_remoteCompRef);
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_Var_maxWaitTime; // maximum wait
t_minWait.start;
t_maxWait.start;
// wait until response is received:
alt {
[f_EPTF_getValueboolean(v_booleanPool,vl_blockingFlagIdx)] t_minWait.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_warning(log2str("No response received for getRemoteContent for: ", pl_remoteVarId, " from: ", pl_remoteCompRef));
}
}
// response is received here, boolean at vl_responseIdx is set to the appropriate value
var boolean vl_result := f_EPTF_getValueboolean(v_booleanPool,vl_responseIdx);
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,vl_blockingFlagIdx);
f_EPTF_deleteboolean(v_booleanPool,vl_responseIdx);
if (vl_result==false) {
f_EPTF_Var_warning(log2str("Content is not available for remote variable: ", pl_remoteVarId, " on component ", pl_remoteCompRef));
pl_content := {unknownVal := {omit}};
pl_provider := {null,-1};
pl_subsCanAdjust := false;
} else {
pl_content := v_EPTF_Var_getRemoteContentResultList[vl_responseIdx].content;
pl_provider := v_EPTF_Var_getRemoteContentResultList[vl_responseIdx].provider;
pl_subsCanAdjust := v_EPTF_Var_getRemoteContentResultList[vl_responseIdx].subsCanAdjust;
}
return vl_result;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustRemoteContent
//
// Purpose:
// This function send an adjust request to adjust the content of a remote EPTF Variable (without subscription)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - reference to the remote component
// pl_remoteVarName - *in* *charstring* - name of the EPTF Variable in the remote component
// pl_content - *in* <EPTF_Var_DirectContent> - the new value to be adjusted on the remote EPTF Variable
// pl_respHandler - <EPTF_Var_adjustContentResp_handler> - user handler to call when the adjust is ready (i.e. when adjustResp arrives, or when the guards accept the new value)
// but before the value of the variable is refreshed
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// Note, that pl_respHandler is always called with pl_idx argument set to -1, because there is no EPTF Variable in the local component.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_adjustRemoteContent(in EPTF_Var_CT pl_remoteCompRef, in charstring pl_remoteVarName, in EPTF_Var_DirectContent pl_content, in EPTF_Var_adjustContentResp_handler pl_respHandler := {null, {}}) runs on EPTF_Var_CT {
f_EPTF_Var_addConnection(pl_remoteCompRef);
// store function params into the stack (if not null):
var integer vl_respHandlerId := -1;
if (pl_respHandler.handlerFn != null) {
vl_respHandlerId := f_EPTF_setNewEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_respHandler);
}
f_EPTF_Var_send({adjustRemoteContent := {varId := {name := pl_remoteVarName}, content := pl_content, respHandlerId := vl_respHandlerId,
blockingFlagIdx := -1, responseIdx := -1}}, pl_remoteCompRef);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustRemoteContentByIdx
//
// Purpose:
// This function send an adjust request to adjust the content of a remote EPTF Variable (without subscription)
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - reference to the remote component
// pl_remoteVarIdx - *in* *integer* - idx of the EPTF Variable in the remote component
// pl_content - *in* <EPTF_Var_DirectContent> - the new value to be adjusted on the remote EPTF Variable
// pl_respHandler - <EPTF_Var_adjustContentResp_handler> - user handler to call when the adjust is ready (i.e. when adjustResp arrives, or when the guards accept the new value)
// but before the value of the variable is refreshed
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// Note, that pl_respHandler is always called with pl_idx argument set to -1, because there is no EPTF Variable in the local component.
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_adjustRemoteContentByIdx(in EPTF_Var_CT pl_remoteCompRef, in integer pl_remoteVarIdx, in EPTF_Var_DirectContent pl_content, in EPTF_Var_adjustContentResp_handler pl_respHandler := {null, {}}) runs on EPTF_Var_CT {
f_EPTF_Var_addConnection(pl_remoteCompRef);
// store function params into the stack (if not null):
var integer vl_respHandlerId := -1;
if (pl_respHandler.handlerFn != null) {
vl_respHandlerId := f_EPTF_setNewEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_respHandler);
}
f_EPTF_Var_send({adjustRemoteContent := {varId := {idx := pl_remoteVarIdx}, content := pl_content, respHandlerId := vl_respHandlerId,
blockingFlagIdx := -1, responseIdx := -1}}, pl_remoteCompRef);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustRemoteContent_Blocking
//
// Purpose:
// The blocking version of the function <f_EPTF_Var_adjustRemoteContent>
//
// Parameters:
// pl_remoteCompRef - *in* <EPTF_Var_CT> - reference to the remote component
// pl_remoteVarName - *in* *charstring* - name of the EPTF Variable in the remote component
// pl_content - *in* <EPTF_Var_DirectContent> - the new value to be adjusted on the remote EPTF Variable
//
// Return Value:
// boolean - false, if adjust failed
//
// Errors:
// -
//
// Detailed Comments:
// This function blocks the execution until the response is received
// and until all respHandlers returned.
// This means that the response handlers are called before the function returns.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_adjustRemoteContent_Blocking(in EPTF_Var_CT pl_remoteCompRef, in charstring pl_remoteVarName, in EPTF_Var_DirectContent pl_content, in EPTF_Var_adjustContentResp_handler pl_respHandler := {null, {}}) runs on EPTF_Var_CT return boolean {
f_EPTF_Var_addConnection(pl_remoteCompRef);
var integer vl_blockingFlagIdx := f_EPTF_setNewboolean(v_booleanPool,false);
var integer vl_responseIdx := f_EPTF_setNewboolean(v_booleanPool,false);
// store function params into the stack (if not null):
var integer vl_respHandlerId := -1;
if (pl_respHandler.handlerFn != null) {
vl_respHandlerId := f_EPTF_setNewEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_respHandler);
}
f_EPTF_Var_send({adjustRemoteContent := {varId := {name := pl_remoteVarName}, content := pl_content, respHandlerId := vl_respHandlerId,
blockingFlagIdx := vl_blockingFlagIdx, responseIdx := vl_responseIdx}}, pl_remoteCompRef);
// blocks execution until response arrives:
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_Var_maxWaitTime; // maximum wait
t_minWait.start;
t_maxWait.start;
// wait until response is received:
alt {
[f_EPTF_getValueboolean(v_booleanPool,vl_blockingFlagIdx)] t_minWait.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_warning(log2str("No response received for adjustRemoteContent for: ", pl_remoteVarName, " from: ", pl_remoteCompRef));
}
}
// response is received here, boolean at vl_responseIdx is set to the appropriate value
var boolean vl_result := f_EPTF_getValueboolean(v_booleanPool,vl_responseIdx);
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,vl_blockingFlagIdx);
f_EPTF_deleteboolean(v_booleanPool,vl_responseIdx);
if (vl_result==false) {
f_EPTF_Var_warning(log2str("AdjustRemoteContent is not allowed for remote variable: ", pl_remoteVarName, " on component ", pl_remoteCompRef));
}
return vl_result;
}
} // group UpdateContent
///////////////////////////////////////////////////////////
// Group: Cleanup
//
// Purpose:
// Functions that will cleanup the <EPTF_Var_CT> before exit.
//
// Elements:
///////////////////////////////////////////////////////////
group Cleanup {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_cleanup_CT
//
// Purpose:
// This function should be called before the EPTF_Var_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 ETPF_Var_CT component.
// This function makes it possible to be able to shut down the
// EPTF_Var_CT component gracefully.
// It sends a notification to all connected components,
// and disconnects from all remote components when the response for the notification is received,
// before the component terminates.
// This function can be called inside or outside the main alt-loop. The main alt-loop
// will terminate after all connections had been shut down if there is no 'repeat'
// statement after calling f_EPTF_Var_cleanup_CT.
// The function blocks execution until the last response for bye messages
// have received, or until 0.5secs between byeAck-s elapsed.
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_cleanup_CT() runs on EPTF_Var_CT {
if (v_EPTF_Var_initialized == false) {
return;
}
v_EPTF_Var_Msg_Buffer := {};
v_EPTF_Var_Msg_BufferStartIdx := 0;
v_EPTF_Var_nofPendingMsgs := 0;
// wait until all pending connetions establised:
if (v_EPTF_Var_numPendingHellos>0) {
f_EPTF_Var_debug(log2str("Waiting for ", v_EPTF_Var_numPendingHellos, " number of pending hello messages..."));
timer t_pendingMaxWait := v_EPTF_Var_maxWaitTimeForByeAck;
timer t_event := 0.0;
t_event.start;
t_pendingMaxWait.start;
alt {
[v_EPTF_Var_numPendingHellos==0] t_event.timeout {
f_EPTF_Var_debug(log2str("All response is received for hello messages. Continuing cleanup..."));
}
[] t_pendingMaxWait.timeout {
f_EPTF_Var_debug(log2str("Max wait time expired. No response is received for hello in ", v_EPTF_Var_numPendingHellos, " number of cases. Continuing cleanup..."));
}
}
}
var boolean vl_waitForResponse := false;
v_EPTF_Var_pendingByeNum := 0;
var EPTF_IntegerList vl_byeSentCompIds := {};
for(var integer vl_refreshRateId := 0; vl_refreshRateId<sizeof(v_syncBuffer); vl_refreshRateId:=vl_refreshRateId+1) {
for(var integer i:=0; i<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef != null) {
// check if bye was already sent for this comp:
var boolean vl_sent := false;
var integer vl_currentCompId := f_EPTF_Base_upcast(v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef);
for(var integer c:=0; c<sizeof(vl_byeSentCompIds); c:=c+1) {
if (vl_currentCompId == vl_byeSentCompIds[c]) {
vl_sent := true;
break;
}
}
if (not vl_sent) {
vl_byeSentCompIds[sizeof(vl_byeSentCompIds)] := vl_currentCompId;
// Note: buffer is intentionally not sent at cleanup.
f_EPTF_Var_send({bye:={}},v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef);
//v_syncBuffer[vl_refreshRateId].syncBuffer[i] := {
// remoteCompRef := null,
// flushCounter:=0,
// compBufferData := {}
//}
vl_waitForResponse := true;
v_EPTF_Var_pendingByeNum := v_EPTF_Var_pendingByeNum + 1;
}
}
}
if (v_syncBuffer[vl_refreshRateId].eventIdx!=-1) {
if(f_EPTF_SchedulerComp_CancelEvent(v_syncBuffer[vl_refreshRateId].eventIdx)){/*remove the warning*/};
v_syncBuffer[vl_refreshRateId].eventIdx := -1;
}
}
f_EPTF_Var_setRefreshSubscribersPeriod(-1.0); // stop the local variable refresh
if (vl_waitForResponse) {
timer t_wait := v_EPTF_Var_maxWaitTimeForByeAck;
t_wait.start;
var EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg;
var EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender;
// bye and byeAck messages are processed, all others are ignored
alt {
[] as_EPTF_Var_handle_ByeAck(t_wait);
[] as_EPTF_Var_handle_Bye();
[] EPTF_Var_MgmtIf.receive(?) -> value vl_EPTF_Var_MgmtIf_msg sender vl_EPTF_Var_MgmtIf_msg_sender {
f_EPTF_Var_debug(log2str("Unexpected message received from ",vl_EPTF_Var_MgmtIf_msg_sender," during cleanup. Message dropped: ",vl_EPTF_Var_MgmtIf_msg));
repeat;
}
}
}
if (v_EPTF_Var_enableName2Id) {
f_EPTF_str2int_HashMap_Delete("EPTF_Var_Hashmap_Name2Id");
v_EPTF_Var_Hashmap_Name2Id := -1;
}
if (v_EPTF_Var_enableCompRef2Id) {
f_EPTF_oct2int_HashMap_Delete("EPTF_Var_Hashmap_CompRef2Id");
v_EPTF_Var_Hashmap_CompRef2Id := -1;
}
f_EPTF_str2int_HashMap_Delete("EPTF_Var_Hashmap_Provider2Id");
v_EPTF_Var_Hashmap_Provider2Id := -1
f_EPTF_str2int_HashMap_Delete("EPTF_Var_Hashmap_SyncBuffer");
v_EPTF_Var_Hashmap_SyncBuffer := -1;
deactivate(v_EPTF_Var_def);
v_EPTF_Var_def := null;
v_EPTF_Var_initialized := false;
if (tsp_EPTF_Var_debug) {
f_EPTF_Var_CT_LogAll("----- VAR CLEANUP DONE -------");
} else {
f_EPTF_Var_debug("----- VAR CLEANUP DONE -------");
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setMaxWaitTimeForByeAck
//
// Purpose:
// Set the maximimum wait time for ByeAck messages during cleanup
//
// Parameters:
// pl_waitTime - *in* *float* - the time to wait
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setMaxWaitTimeForByeAck(in float pl_waitTime) runs on EPTF_Var_CT {
v_EPTF_Var_maxWaitTimeForByeAck := pl_waitTime;
if (v_EPTF_Var_maxWaitTimeForByeAck<0.0) {
v_EPTF_Var_maxWaitTimeForByeAck := 0.0;
}
}
} // group Cleanup
///////////////////////////////////////////////////////////
// Group: Timeline
//
// Purpose:
// Functions that handle the timeline of a buffered EPTF Variable.
//
// Elements:
///////////////////////////////////////////////////////////
group Timeline {
// returns true if variable has a timeLine subscriber
private function f_EPTF_Var_hasTimeLineSubscriber(in integer pl_idx) runs on EPTF_Var_CT return boolean {
return v_EPTF_Vars[pl_idx].nofTimelineSubscribers>0;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getVarRefreshRate
//
// Purpose:
// Returns the refresh rate for a given variable.
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// integer - the refresh rate (-1 if no refresh rate found)
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getVarRefreshRate(in integer pl_idx) runs on EPTF_Var_CT return integer {
f_EPTF_Base_assert(%definitionId&": Invalid var index: "&int2str(pl_idx), pl_idx>=0 and pl_idx<sizeof(v_EPTF_Vars));
if (not ischosen(v_EPTF_Vars[pl_idx].provider.remote)) {
return -1; // no refresh rate
}
return v_EPTF_Vars[pl_idx].provider.remote.refreshRate;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getRefreshPeriod
//
// Purpose:
// Returns the refresh rate for a given refreshRateId.
//
// Parameters:
// pl_refreshRateId - *in* *integer* - the refreshRateId in v_syncBuffer
//
// Return Value:
// float - the refresh period in seconds
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getRefreshPeriod(in integer pl_refreshRateId) runs on EPTF_Var_CT return float {
f_EPTF_Base_assert(%definitionId&": Invalid refreshRateId: "&int2str(pl_refreshRateId), pl_refreshRateId>=0 and pl_refreshRateId<sizeof(v_syncBuffer));
if (pl_refreshRateId==0) {
return v_syncInterval;
}
return int2float(v_syncBuffer[pl_refreshRateId].refreshRate) * v_minSyncInterval;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getRefreshRate
//
// Purpose:
// Returns the refresh rate for a given refreshRateId.
//
// Parameters:
// pl_refreshRateId - *in* *integer* - the refreshRateId in v_syncBuffer
//
// Return Value:
// integer - the refresh rate
//
// Errors:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getRefreshRate(in integer pl_refreshRateId) runs on EPTF_Var_CT return integer {
f_EPTF_Base_assert(%definitionId&": Invalid refreshRateId: "&int2str(pl_refreshRateId), pl_refreshRateId>=0 and pl_refreshRateId<sizeof(v_syncBuffer));
return v_syncBuffer[pl_refreshRateId].refreshRate;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getRefreshRateId
//
// Purpose:
// Returns the refresh rate id for a given refreshRate.
//
// Parameters:
// pl_refreshRate - *in* *integer* - the refreshRate
//
// Return Value:
// integer - the id of the refresh rate in v_syncBuffer. -1 if not found
//
// Errors:
// -
//
// Detailed Comments:
// If pl_refreshRateId == -1, the timeLine belonging to the refreshRate of the remote provider is returned
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getRefreshRateId(in integer pl_refreshRate) runs on EPTF_Var_CT return integer {
var integer vl_refreshRateId := 0;
var integer vl_compBufferIdx;
f_EPTF_Var_checkConnection(null,pl_refreshRate,vl_refreshRateId,vl_compBufferIdx);
return vl_refreshRateId;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getTimeLine
//
// Purpose:
// Returns the timeLine for a variable for a given refreshRateId.
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_timeLine - *in* <EPTF_Var_TimeLine> - the idx of the EPTF_Var
// pl_refreshRateId - *in* *integer* - the refreshRateId
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// If pl_refreshRateId == -1, the timeLine belonging to the refreshRate of the remote provider is returned
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getTimeLine(in integer pl_idx, out EPTF_Var_TimeLine pl_timeLine, in integer pl_refreshRateId := -1) runs on EPTF_Var_CT {
pl_timeLine.size := 0;
pl_timeLine.timeLineData := {};
if (pl_refreshRateId==-1) {
// return the timeLine for the subscription's refreshRate:
// the refreshRateId is retrieved from the remote provider:
// FIXME: timeLine needed for sampled also because UIHandlerWidgetFunctions uses it?
if (f_EPTF_Var_checkSubscriptionMode(pl_idx,timeLine)
or f_EPTF_Var_checkSubscriptionMode(pl_idx,sampled) or f_EPTF_Var_checkSubscriptionMode(pl_idx,sampledAtSync)) {
var integer vl_compBufferIdx;
f_EPTF_Var_checkConnection(null,v_EPTF_Vars[pl_idx].provider.remote.refreshRate,pl_refreshRateId,vl_compBufferIdx);
}
if (pl_refreshRateId==-1) {
// no timeline is available
return;
}
}
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer);i:=i+1) {
if (v_EPTF_Vars[pl_idx].timeLineBuffer[i].refreshRateId == pl_refreshRateId) {
pl_timeLine := v_EPTF_Vars[pl_idx].timeLineBuffer[i].timeLine;
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_updateTimeLine
//
// Purpose:
// Appends new content to the timeLine if the variable is buffered, uses the current time for timeStamp if no timestamp is specified.
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_contentNew - *in* <EPTF_Var_DirectContent> - the content to be added
// pl_timeStamp - *in* *float* *optional* - the timestamp for the data. If not specified, current time is used.
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_updateTimeLine(in integer pl_idx, in EPTF_Var_DirectContent pl_contentNew, in float pl_timeStamp := -1.0) runs on EPTF_Var_CT {
// if i am a buffered subscriber (i.e. my provider is remote buffered):
if (ischosen(v_EPTF_Vars[pl_idx].provider.remote) and
( v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode == sampled or v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode == sampledAtSync
or v_EPTF_Vars[pl_idx].provider.remote.subscriptionMode == timeLine )) {
return;
}
var float vl_timeStamp := pl_timeStamp;
if (vl_timeStamp<0.0) {
vl_timeStamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime())
}
// update the timeline for all refreshRates:
for(var integer vl_refreshRateIdInTimeLineBuffer := 0;vl_refreshRateIdInTimeLineBuffer<sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer);vl_refreshRateIdInTimeLineBuffer:=vl_refreshRateIdInTimeLineBuffer+1) {
// if i don't have a buffered subscriber:
if (v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum==0) {
continue; // nothing to do
}
var integer vl_refreshRateId := v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].refreshRateId;
if (f_EPTF_Var_hasTimeLineSubscriber(pl_idx)) {
// append the new sample into the timeLine:
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.timeLineData[v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size] := {
vl_timeStamp,
pl_contentNew
};
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size := v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size + 1;
} else {
// set the new sample into the timeLine == overwrite/create the 0-th element in the timeline
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.timeLineData[0] := {
vl_timeStamp,
pl_contentNew
};
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size := 1; // store only the last value
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setSyncInterval
//
// Purpose:
// Sets the timeLine sync interval.
//
// Parameters:
// pl_syncInterval - *in* *float* - the new sync interval
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This sync interval is used to send the buffered timeLines periodically
// to the subscribers (with default refreshRate(=zero)).
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setSyncInterval(in float pl_syncInterval) runs on EPTF_Var_CT {
v_syncInterval := pl_syncInterval;
// reschedule the default event:
var integer vl_refreshRateId := 0; // default refresh method
f_EPTF_SchedulerComp_CancelEvent(v_syncBuffer[vl_refreshRateId].eventIdx);
if(f_EPTF_SchedulerComp_scheduleAction(
pl_when := f_EPTF_Base_getRelTimeInSecs()+v_syncInterval,
pl_actionHandler := refers(f_EPTF_Var_syncTimeoutHandler),
pl_action := {vl_refreshRateId},
pl_eventIndex := v_syncBuffer[vl_refreshRateId].eventIdx
)){/*remove the warning*/};
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setMinSyncInterval
//
// Purpose:
// Sets the minima of the sync interval for refreshRates.
//
// Parameters:
// pl_minSyncInterval - *in* *float* - the new minima of sync interval
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This sync interval is used to send the buffered timeLines periodically
// to the subscribers. The length of the period is calculated as
// minSyncInterval * refreshRate, where refreshRate is a positive integer
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setMinSyncInterval(in float pl_minSyncInterval) runs on EPTF_Var_CT {
v_minSyncInterval := pl_minSyncInterval;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_setMaxWaitTime
//
// Purpose:
// Sets the minima of the sync interval for refreshRates.
//
// Parameters:
// pl_maxWaitTime - *in* *float* - the new maximal waiting time for responses
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// This parameter is used when a response is expected from another
// component. This function sets the maximal time to wait for the response.
// If the time expires, an error/false result is generated.
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_setMaxWaitTime(in float pl_maxWaitTime)
runs on EPTF_Var_CT{
v_Var_maxWaitTime := pl_maxWaitTime;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_sendTimeLine
//
// Purpose:
// Sends the timeLine for the given EPTF Var only for all of its remote subscribers.
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_sendTimeLine(in integer pl_idx) runs on EPTF_Var_CT {
// send timeLines
var EPTF_Var_TimeLineList vl_refreshTimeLineList;
for(var integer vl_refreshRateId:=0;vl_refreshRateId<sizeof(v_syncBuffer);vl_refreshRateId:=vl_refreshRateId+1) {
for(var integer i:=0; i<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef!=null) {
vl_refreshTimeLineList := {};
for(var integer j:=0; j<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData); j:=j+1) {
var integer vl_varIdx := v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].localIdx;
if (pl_idx == vl_varIdx) {
// find timeLine for the refreshRate:
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer ii := 0; ii<sizeof(v_EPTF_Vars[vl_varIdx].timeLineBuffer); ii:=ii+1) {
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[ii].refreshRateId == vl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := ii;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer!=-1) {
// there is timeline for this variable with this refreshRate
// only add to message if timeLine is not empty:
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size>0) {
// if subscription mode of the variable is timeLine
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == timeLine) {
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine
}
} else if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == sampled) {
// sampled: send only the last element in the timeLine:
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
{1,{v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.timeLineData[v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size-1]}}
}
}
}
}
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == sampledAtSync) {
// sampledAtSync: send only the current content in the timeLine:
var EPTF_Var_DirectContent vl_currentContent;
var float vl_timestamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime());
f_EPTF_Var_getContent(vl_varIdx, vl_currentContent);
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].prevContent != vl_currentContent) {
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
{1,{{vl_timestamp,vl_currentContent}}}
}
// store current value for sampledAtSync
v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].prevContent := vl_currentContent;
}
}
}
}
// no 'if' needed: send empty message in case of no change
if (tsp_EPTF_Var_enableEmptyTimeLine or sizeof(vl_refreshTimeLineList)>0) {
f_EPTF_Var_send(
{refreshTimeLines := {v_syncBuffer[vl_refreshRateId].refreshRate, v_syncBuffer[vl_refreshRateId].syncBuffer[i].flushCounter, vl_refreshTimeLineList}},
v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef
);
// increase the counter:
v_syncBuffer[vl_refreshRateId].syncBuffer[i].flushCounter := v_syncBuffer[vl_refreshRateId].syncBuffer[i].flushCounter+1;
}
}
}
// reset timeLines:
for(var integer i:=0; i<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef!=null) {
for(var integer j:=0; j<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData); j:=j+1) {
var integer vl_varIdx := v_syncBuffer[vl_refreshRateId].syncBuffer[i].compBufferData[j].localIdx;
if (pl_idx == vl_varIdx) {
// find timeLine for the refreshRate:
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer ii := 0; ii<sizeof(v_EPTF_Vars[vl_varIdx].timeLineBuffer); ii:=ii+1) {
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[ii].refreshRateId == vl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := ii;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer==-1) {
continue; // no timeline for this variable with this refreshRate
}
// only reset timeLine if timeLine is not empty:
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size>0) {
v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine := {0,{}};
}
}
}
}
}
}
}
} // group Timeline
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_content2str
//
// Purpose:
// Returns the value of the content for the EPTF Variable as a charstring
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_content2str(in integer pl_idx) runs on EPTF_Var_CT return charstring {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx, vl_currentContent);
return f_EPTF_Var_directContent2str(vl_currentContent);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_str2content
//
// Purpose:
// Sets the value of the content for the EPTF Variable from a charstring
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
// pl_valueStr - *in* *charstring* - the value of the variable as charsting
// (same format as retuned by <f_EPTF_Var_content2str>)
//
// Return Value:
// *integer* - error code: 0 if successful, nonzero if conversion failed
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_str2content(in integer pl_idx, in charstring pl_valueStr) runs on EPTF_Var_CT return integer {
var EPTF_Var_DirectContent vl_content;
f_EPTF_Var_getContent(pl_idx,vl_content);
var integer vl_errorCode := f_EPTF_Var_str2directContent(pl_valueStr,vl_content);
if (vl_errorCode==0) {
f_EPTF_Var_adjustContent(pl_idx,vl_content);
}
return vl_errorCode;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_content2string
//
// Purpose:
// Returns the the content for the EPTF Variable as a charstring in module parameter format
//
// Parameters:
// pl_idx - *in* *integer* - the idx of the EPTF_Var
//
// Return Value:
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_content2string(in integer pl_idx) runs on EPTF_Var_CT return charstring {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(pl_idx, vl_currentContent);
return f_EPTF_Var_directContent2string(vl_currentContent);
}
// externals:
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_upcast
//
// Purpose:
// Cast EPTF_Var_CT to EPTF_Base_CT
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_upcast(in EPTF_Var_CT pl_compRef) return EPTF_Base_CT;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_downcast
//
// Purpose:
// Cast EPTF_Base_CT to EPTF_Var_CT
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_downcast(in EPTF_Base_CT pl_baseCompRef) return EPTF_Var_CT;
// External functions needed for the implemented types:
// integer
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getIntRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getIntRef(in integer pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefInt
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefInt(in octetstring pl_compVarRef) return integer;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyIntRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyIntRefValue(in octetstring pl_compVarRef, in integer pl_newValue);
// float
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getFloatRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getFloatRef(in float pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefFloat
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefFloat(in octetstring pl_compVarRef) return float;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyFloatRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyFloatRefValue(in octetstring pl_compVarRef, in float pl_newValue);
// boolean
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getBoolRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getBoolRef(in boolean pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefBool
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefBool(in octetstring pl_compVarRef) return boolean;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyBoolRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyBoolRefValue(in octetstring pl_compVarRef, in boolean pl_newValue);
// charstring
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getCharstringRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getCharstringRef(in charstring pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefCharstring
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefCharstring(in octetstring pl_compVarRef) return charstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyCharstringRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyCharstringRefValue(in octetstring pl_compVarRef, in charstring pl_newValue);
// octetstring
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getOctetstringRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getOctetstringRef(in octetstring pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefOctetstring
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefOctetstring(in octetstring pl_compVarRef) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyOctetstringRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyOctetstringRefValue(in octetstring pl_compVarRef, in octetstring pl_newValue);
// hexstring
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getHexstringRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getHexstringRef(in hexstring pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefHexstring
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefHexstring(in octetstring pl_compVarRef) return hexstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyHexstringRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyHexstringRefValue(in octetstring pl_compVarRef, in hexstring pl_newValue);
// bitstring
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getBitstringRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getBitstringRef(in bitstring pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefBitstring
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefBitstring(in octetstring pl_compVarRef) return bitstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyBitstringRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyBitstringRefValue(in octetstring pl_compVarRef, in bitstring pl_newValue);
// integerlist
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getIntegerlistRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getIntegerlistRef(in EPTF_IntegerList pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefIntegerlist
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefIntegerlist(in octetstring pl_compVarRef) return EPTF_IntegerList;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyIntegerlistRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyIntegerlistRefValue(in octetstring pl_compVarRef, in EPTF_IntegerList pl_newValue);
// floatlist
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getFloatlistRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getFloatlistRef(in EPTF_FloatList pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefFloatlist
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefFloatlist(in octetstring pl_compVarRef) return EPTF_FloatList;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyFloatlistRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyFloatlistRefValue(in octetstring pl_compVarRef, in EPTF_FloatList pl_newValue);
// charstringlist
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getCharstringlistRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getCharstringlistRef(in EPTF_CharstringList pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefCharstringlist
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefCharstringlist(in octetstring pl_compVarRef) return EPTF_CharstringList;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyCharstringlistRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyCharstringlistRefValue(in octetstring pl_compVarRef, in EPTF_CharstringList pl_newValue);
// statusLED
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getStatusLEDRef
//
// Purpose:
// Returns the address of the component variable
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_getStatusLEDRef(in EPTF_StatusLED pl_compVar) return octetstring;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_derefStatusLED
//
// Purpose:
// Returns the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_derefStatusLED(in octetstring pl_compVarRef) return EPTF_StatusLED;
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_modifyStatusLEDRefValue
//
// Purpose:
// Modifies the value of the component variable at the given address
///////////////////////////////////////////////////////////
public external function f_EPTF_Var_modifyStatusLEDRefValue(in octetstring pl_compVarRef, in EPTF_StatusLED pl_newValue);
//...
} // group Public
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// private:
//////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Group: Private
//
// Purpose:
// Private functions. These functions must not be used by the user of <EPTF_Var_CT>
//
// Elements:
///////////////////////////////////////////////////////////
group Private {
// enable/disable compRef2id
public function f_EPTF_Var_useCompRef2Id(in boolean pl_enableCompRef2Id) runs on EPTF_Var_CT {
if (pl_enableCompRef2Id != v_EPTF_Var_enableCompRef2Id) {
v_EPTF_Var_enableCompRef2Id := pl_enableCompRef2Id;
if (v_EPTF_Var_enableCompRef2Id) {
v_EPTF_Var_Hashmap_CompRef2Id := f_EPTF_oct2int_HashMap_New("EPTF_Var_Hashmap_CompRef2Id");
}
}
}
// enable/disable name2id
public function f_EPTF_Var_useName2Id(in boolean pl_enableName2Id) runs on EPTF_Var_CT {
if (pl_enableName2Id != v_EPTF_Var_enableName2Id) {
v_EPTF_Var_enableName2Id := pl_enableName2Id;
if (v_EPTF_Var_enableName2Id) {
v_EPTF_Var_Hashmap_Name2Id := f_EPTF_str2int_HashMap_New("EPTF_Var_Hashmap_Name2Id");
}
}
}
public function f_EPTF_Var_getHashmap_Hashmap_CompRef2Id() runs on EPTF_Var_CT return integer {
return v_EPTF_Var_Hashmap_CompRef2Id;
}
public function f_EPTF_Var_getHashmap_Name2Id() runs on EPTF_Var_CT return integer {
return v_EPTF_Var_Hashmap_Name2Id;
}
// VARIABLE HANDLING
const EPTF_Var c_newVar := {
provider := { empty := {} }, // the provider, those varible(s) that value is used to calculate this var's value
subscribers := {}, // subscriber list, who should be notified if the value of this var changes
name := "", // name of the variable
subsCanAdjust := true, // if false: subscribers cannot adjust the content
content := {invalid := {}}, // content (value or reference to a value) of the variable
postProcFns := {}, // called by the library after the value of the EPTF Variable was changed
guardFns := {}, // function pointers to the guard functions
unsubscribeNotifyFns := {}, // functions called after the variable is unsubsribed (or when bye is received). Notifies the user about the unsubscribe
subsCanAdjustNotifyFns := {}, // called by the library after the value of subsCanAdjust of the EPTF Variable was changed
timeLineBuffer := {}, // buffered timeLine for subscribers for each refresh rate
nofTimelineSubscribers := 0 // the number of timeLine subscribers
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addNew
//
// Purpose:
// Creates a new EPTF Variable and returns its idx
///////////////////////////////////////////////////////////
private function f_EPTF_Var_addNew(out integer pl_idx, in charstring pl_name := "") runs on EPTF_Var_CT {
var integer vl_idx;
if (f_EPTF_Var_checkName(pl_name,vl_idx) == false) {
f_EPTF_Var_error(log2str("New EPTF Variable name is not unique: ", pl_name," Already defined by EPTF_Var[",vl_idx,"]: ", v_EPTF_Vars[vl_idx]));
//f_EPTF_Base_stop();
}
pl_idx := sizeof(v_EPTF_Vars);
f_EPTF_Var_initVar(pl_idx);
v_EPTF_Vars[pl_idx].name := pl_name;
// register the name into the hashmap:
if (v_EPTF_Var_enableName2Id and pl_name != "") {
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_Name2Id,pl_name,pl_idx);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_checkName
//
// Purpose:
// Checks if the name is valid (unique in the current component),
// returns true (pl_idx = -1) if ok; returns false (pl_idx = index of the variable) if the name exists
///////////////////////////////////////////////////////////
public function f_EPTF_Var_checkName(in charstring pl_name, out integer pl_idx) runs on EPTF_Var_CT return boolean {
pl_idx := -1;
if (pl_name=="") {
return true;
}
// find the name:
pl_idx := f_EPTF_Var_getId(pl_name);
if (pl_idx == -1) {
return true;
}
return false; // name is not unique
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_initVar
//
// Purpose:
// Initializes the variable at the given idx,
///////////////////////////////////////////////////////////
private function f_EPTF_Var_initVar(in integer pl_idx) runs on EPTF_Var_CT {
v_EPTF_Vars[pl_idx] := c_newVar;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeVar
//
// Purpose:
// Removes the variable
///////////////////////////////////////////////////////////
public function f_EPTF_Var_removeVar(in integer pl_idx) runs on EPTF_Var_CT {
if (not ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
f_EPTF_Var_warning(log2str(%definitionId, ": Cannot remove variable ", v_EPTF_Vars[pl_idx].name, " : It has a provider. Unsubscribe it first!"));
return;
}
if (v_EPTF_Var_enableName2Id and v_EPTF_Vars[pl_idx].name != "") {
f_EPTF_str2int_HashMap_Erase(v_EPTF_Var_Hashmap_Name2Id,v_EPTF_Vars[pl_idx].name);
}
f_EPTF_Var_initVar(pl_idx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_initContentRef
//
// Purpose:
// Sets the content to a reference
///////////////////////////////////////////////////////////
private function f_EPTF_Var_initContentRef(in integer pl_idx, in EPTF_Var_ReferencedContent pl_contentRef) runs on EPTF_Var_CT {
v_EPTF_Vars[pl_idx].content := {
reference := pl_contentRef
}
// register the variable ref into the hashmap:
if (v_EPTF_Var_enableCompRef2Id) {
f_EPTF_oct2int_HashMap_Insert(v_EPTF_Var_Hashmap_CompRef2Id,pl_contentRef.valueRef,pl_idx);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_initContent
//
// Purpose:
// Sets the content to a directContent
///////////////////////////////////////////////////////////
private function f_EPTF_Var_initContent(in integer pl_idx, in EPTF_Var_DirectContent pl_content) runs on EPTF_Var_CT {
v_EPTF_Vars[pl_idx].content := {
direct := pl_content
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_initContentInvalid
//
// Purpose:
// Sets the content to a invalid
///////////////////////////////////////////////////////////
private function f_EPTF_Var_initContentInvalid(in integer pl_idx) runs on EPTF_Var_CT {
v_EPTF_Vars[pl_idx].content := {
invalid := {}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_content2direct
//
// Purpose:
// Converts the content of an EPTF variable to direct content (dereferences if it is a reference)
///////////////////////////////////////////////////////////
private function f_EPTF_Var_content2direct(in EPTF_Var_Content pl_content, out EPTF_Var_DirectContent pl_directContent) runs on EPTF_Var_CT {
if (ischosen(pl_content.invalid)) {
//f_EPTF_Var_error(log2str("ERROR:","Cannot convert invalid content to direct content ",pl_directContent,"."));
//f_EPTF_Base_stop();
pl_directContent := {unknownVal := {omit}};
return;
}
if (ischosen(pl_content.direct)) {
pl_directContent := pl_content.direct;
return;
}
// referenced content
if (pl_content.reference.refType == intType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { intVal := 0 };
return;
}
pl_directContent := { intVal := f_EPTF_Var_derefInt(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == floatType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { floatVal := 0.0 };
return;
}
pl_directContent := { floatVal := f_EPTF_Var_derefFloat(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == boolType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { boolVal := false };
return;
}
pl_directContent := { boolVal := f_EPTF_Var_derefBool(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == charstringType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { charstringVal := "" };
return;
}
pl_directContent := { charstringVal := f_EPTF_Var_derefCharstring(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == octetstringType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { octetstringVal := ''O };
return;
}
pl_directContent := { octetstringVal := f_EPTF_Var_derefOctetstring(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == hexstringType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { hexstringVal := ''H };
return;
}
pl_directContent := { hexstringVal := f_EPTF_Var_derefHexstring(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == bitstringType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { bitstringVal := ''B };
return;
}
pl_directContent := { bitstringVal := f_EPTF_Var_derefBitstring(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == integerlistType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { integerlistVal := {} };
return;
}
pl_directContent := { integerlistVal := f_EPTF_Var_derefIntegerlist(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == floatlistType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { floatlistVal := {} };
return;
}
pl_directContent := { floatlistVal := f_EPTF_Var_derefFloatlist(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == charstringlistType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { charstringlistVal := {} };
return;
}
pl_directContent := { charstringlistVal := f_EPTF_Var_derefCharstringlist(pl_content.reference.valueRef) };
return;
}
if (pl_content.reference.refType == statusLEDType) {
if (not f_EPTF_Base_cleanupIsInProgress()) {
// cleanup is in progress: if referred variable accessed: default value is returned
pl_directContent := { statusLEDVal := {color:=led_black,text:="N/A"} };
return;
}
pl_directContent := { statusLEDVal := f_EPTF_Var_derefStatusLED(pl_content.reference.valueRef) };
return;
}
//...
f_EPTF_Var_error(log2str("ERROR:","Cannot convert this content to direct content: ",pl_content));
//f_EPTF_Base_stop();
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_direct2content
//
// Purpose:
// Converts a direct content of an EPTF variable to content (dereferences if it is a reference)
// Returns true on success, fail on error
///////////////////////////////////////////////////////////
private function f_EPTF_Var_direct2content(in EPTF_Var_DirectContent pl_directContent, inout EPTF_Var_Content pl_content) runs on EPTF_Var_CT
return boolean {
if (ischosen(pl_content.invalid)) {
if (not ischosen(pl_directContent.unknownVal)) {
f_EPTF_Var_warning(log2str("ERROR:","Cannot convert direct content ",pl_directContent," to invalid content."));
return false;
//f_EPTF_Base_stop();
} else {
return true; // Do nothing, leave it invalid
}
}
if (ischosen(pl_content.direct)) {
if (ischosen(pl_content.direct.intVal) and ischosen(pl_directContent.intVal)) {
pl_content.direct.intVal := pl_directContent.intVal;
return true;
}
if (ischosen(pl_content.direct.floatVal) and ischosen(pl_directContent.floatVal)) {
pl_content.direct.floatVal := pl_directContent.floatVal;
return true;
}
if (ischosen(pl_content.direct.boolVal) and ischosen(pl_directContent.boolVal)) {
pl_content.direct.boolVal := pl_directContent.boolVal;
return true;
}
if (ischosen(pl_content.direct.charstringVal) and ischosen(pl_directContent.charstringVal)) {
pl_content.direct.charstringVal := pl_directContent.charstringVal;
return true;
}
if (ischosen(pl_content.direct.octetstringVal) and ischosen(pl_directContent.octetstringVal)) {
pl_content.direct.octetstringVal := pl_directContent.octetstringVal;
return true;
}
if (ischosen(pl_content.direct.hexstringVal) and ischosen(pl_directContent.hexstringVal)) {
pl_content.direct.hexstringVal := pl_directContent.hexstringVal;
return true;
}
if (ischosen(pl_content.direct.bitstringVal) and ischosen(pl_directContent.bitstringVal)) {
pl_content.direct.bitstringVal := pl_directContent.bitstringVal;
return true;
}
if (ischosen(pl_content.direct.integerlistVal) and ischosen(pl_directContent.integerlistVal)) {
pl_content.direct.integerlistVal := pl_directContent.integerlistVal;
return true;
}
if (ischosen(pl_content.direct.floatlistVal) and ischosen(pl_directContent.floatlistVal)) {
pl_content.direct.floatlistVal := pl_directContent.floatlistVal;
return true;
}
if (ischosen(pl_content.direct.charstringlistVal) and ischosen(pl_directContent.charstringlistVal)) {
pl_content.direct.charstringlistVal := pl_directContent.charstringlistVal;
return true;
}
if (ischosen(pl_content.direct.statusLEDVal) and ischosen(pl_directContent.statusLEDVal)) {
pl_content.direct.statusLEDVal := pl_directContent.statusLEDVal;
return true;
}
if (ischosen(pl_content.direct.unknownVal) and ischosen(pl_directContent.unknownVal)) {
pl_content.direct.unknownVal := pl_directContent.unknownVal;
return true;
}
//...
f_EPTF_Var_warning(log2str("ERROR:","Cannot convert direct content ",pl_directContent," to direct content ",pl_content,". Types are incompatible"));
return false;
//f_EPTF_Base_stop();
}
// referenced content
if (not f_EPTF_Base_cleanupIsInProgress()) {
return true;// cleanup is in progress: referred variable is not modified
}
if ((pl_content.reference.refType == intType) and ischosen(pl_directContent.intVal)) {
f_EPTF_Var_modifyIntRefValue(pl_content.reference.valueRef, pl_directContent.intVal);
return true;
}
if ((pl_content.reference.refType == floatType) and ischosen(pl_directContent.floatVal)) {
f_EPTF_Var_modifyFloatRefValue(pl_content.reference.valueRef, pl_directContent.floatVal);
return true;
}
if ((pl_content.reference.refType == boolType) and ischosen(pl_directContent.boolVal)) {
f_EPTF_Var_modifyBoolRefValue(pl_content.reference.valueRef, pl_directContent.boolVal);
return true;
}
if ((pl_content.reference.refType == charstringType) and ischosen(pl_directContent.charstringVal)) {
f_EPTF_Var_modifyCharstringRefValue(pl_content.reference.valueRef, pl_directContent.charstringVal);
return true;
}
if ((pl_content.reference.refType == octetstringType) and ischosen(pl_directContent.octetstringVal)) {
f_EPTF_Var_modifyOctetstringRefValue(pl_content.reference.valueRef, pl_directContent.octetstringVal);
return true;
}
if ((pl_content.reference.refType == hexstringType) and ischosen(pl_directContent.hexstringVal)) {
f_EPTF_Var_modifyHexstringRefValue(pl_content.reference.valueRef, pl_directContent.hexstringVal);
return true;
}
if ((pl_content.reference.refType == bitstringType) and ischosen(pl_directContent.bitstringVal)) {
f_EPTF_Var_modifyBitstringRefValue(pl_content.reference.valueRef, pl_directContent.bitstringVal);
return true;
}
if ((pl_content.reference.refType == integerlistType) and ischosen(pl_directContent.integerlistVal)) {
f_EPTF_Var_modifyIntegerlistRefValue(pl_content.reference.valueRef, pl_directContent.integerlistVal);
return true;
}
if ((pl_content.reference.refType == floatlistType) and ischosen(pl_directContent.floatlistVal)) {
f_EPTF_Var_modifyFloatlistRefValue(pl_content.reference.valueRef, pl_directContent.floatlistVal);
return true;
}
if ((pl_content.reference.refType == charstringlistType) and ischosen(pl_directContent.charstringlistVal)) {
f_EPTF_Var_modifyCharstringlistRefValue(pl_content.reference.valueRef, pl_directContent.charstringlistVal);
return true;
}
if ((pl_content.reference.refType == statusLEDType) and ischosen(pl_directContent.statusLEDVal)) {
f_EPTF_Var_modifyStatusLEDRefValue(pl_content.reference.valueRef, pl_directContent.statusLEDVal);
return true;
}
//...
f_EPTF_Var_warning(log2str("ERROR:","Cannot convert direct content ",pl_directContent," to referenced content ",pl_content));
return false;
//f_EPTF_Base_stop();
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_directContent2str
//
// Purpose:
// Converts direct content to charstring
///////////////////////////////////////////////////////////
public function f_EPTF_Var_directContent2str(in EPTF_Var_DirectContent pl_directContent) return charstring {
if (ischosen(pl_directContent.intVal)) {
return int2str(pl_directContent.intVal);
}
if (ischosen(pl_directContent.floatVal)) {
return float2str(pl_directContent.floatVal);
}
if (ischosen(pl_directContent.boolVal)) {
if (pl_directContent.boolVal) {
return "true";
}
return "false";
}
if (ischosen(pl_directContent.charstringVal)) {
return pl_directContent.charstringVal;
}
if (ischosen(pl_directContent.octetstringVal)) {
return oct2str(pl_directContent.octetstringVal);
}
if (ischosen(pl_directContent.hexstringVal)) {
return hex2str(pl_directContent.hexstringVal);
}
if (ischosen(pl_directContent.bitstringVal)) {
return bit2str(pl_directContent.bitstringVal);
}
if (ischosen(pl_directContent.integerlistVal)) {
var charstring vl_result := "{ ";
for (var integer i:=0; i<sizeof(pl_directContent.integerlistVal); i:=i+1) {
if (i>0) {
vl_result := vl_result & ", ";
}
vl_result := vl_result & int2str(pl_directContent.integerlistVal[i]);
}
vl_result := vl_result & " }";
return vl_result;
}
if (ischosen(pl_directContent.floatlistVal)) {
var charstring vl_result := "{ ";
for (var integer i:=0; i<sizeof(pl_directContent.floatlistVal); i:=i+1) {
if (i>0) {
vl_result := vl_result & ", ";
}
vl_result := vl_result & float2str(pl_directContent.floatlistVal[i]);
}
vl_result := vl_result & " }";
return vl_result;
}
if (ischosen(pl_directContent.charstringlistVal)) {
var charstring vl_result := "{ ";
for (var integer i:=0; i<sizeof(pl_directContent.charstringlistVal); i:=i+1) {
if (i>0) {
vl_result := vl_result & ", ";
}
vl_result := vl_result & log2str(pl_directContent.charstringlistVal[i]);
}
vl_result := vl_result & " }";
return vl_result;
}
if (ischosen(pl_directContent.statusLEDVal))
{
var charstring vl_ledText := "";
if (ispresent(pl_directContent.statusLEDVal.text)) {
vl_ledText:=pl_directContent.statusLEDVal.text;
}
if (pl_directContent.statusLEDVal.color == led_blue) { return "[led:blue]" & vl_ledText }
else if (pl_directContent.statusLEDVal.color == led_black) { return "[led:black]" & vl_ledText }
else if (pl_directContent.statusLEDVal.color == led_yellow) { return "[led:yellow]" & vl_ledText }
else if (pl_directContent.statusLEDVal.color == led_green) { return "[led:green]" & vl_ledText }
else if (pl_directContent.statusLEDVal.color == led_red) { return "[led:red]" & vl_ledText }
return "[led:black]" & vl_ledText & " ERROR:color of LED is not supported! Color set to BLACK.";
}
if (ischosen(pl_directContent.unknownVal)) {
return "unknownValueOfType "&ttcn2string(pl_directContent.unknownVal);
}
//...
f_EPTF_Common_error(log2str("ERROR:","Cannot convert direct content ",pl_directContent," to string."));
//f_EPTF_Logging_error(true,log2str("Cannot convert direct content ",pl_directContent," to string."));
stop;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_str2directContent
//
// Purpose:
// Converts charstring to direct content
// The pl_directContent determines the type of the result
//
// Return Value:
// *integer* - error code: 0 if OK, nonzero if conversion failed
///////////////////////////////////////////////////////////
public function f_EPTF_Var_str2directContent(in charstring pl_valueStr, inout EPTF_Var_DirectContent pl_directContent) return integer {
if (ischosen(pl_directContent.intVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_integerNumber&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr!="") {
pl_directContent.intVal := str2int(vl_currentValueStr);
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.floatVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_floatNumber&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr!="") {
pl_directContent.floatVal := str2float(vl_currentValueStr);
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.boolVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_anyWord&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr == "true" or vl_currentValueStr == "false" ) {
pl_directContent.boolVal := "true" == vl_currentValueStr
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.charstringVal)) {
pl_directContent.charstringVal := pl_valueStr;
return 0; // OK
}
if (ischosen(pl_directContent.octetstringVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_octetstringNumber&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr!="") {
pl_directContent.octetstringVal := str2oct(vl_currentValueStr);
} else if ("" == regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_anyWord&c_EPTF_Var_whitespace,0)) {
pl_directContent.octetstringVal := ''O;
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.hexstringVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_hexstringNumber&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr!="") {
pl_directContent.hexstringVal := str2hex(vl_currentValueStr);
} else if ("" == regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_anyWord&c_EPTF_Var_whitespace,0)) {
pl_directContent.hexstringVal := ''H;
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.bitstringVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_bitstringNumber&c_EPTF_Var_whitespace,0);
if (vl_currentValueStr!="") {
pl_directContent.bitstringVal := str2bit(vl_currentValueStr);
} else if ("" == regexp(pl_valueStr,c_EPTF_Var_whitespace&c_EPTF_Var_anyWord&c_EPTF_Var_whitespace,0)) {
pl_directContent.bitstringVal := ''B;
} else {
return 1; // error
}
return 0; // OK
}
if (ischosen(pl_directContent.integerlistVal)) {
pl_directContent.integerlistVal := {};
var charstring vl_remaining := regexp(pl_valueStr,c_EPTF_Var_whitespace&"{"&c_EPTF_Var_whitespace&c_EPTF_Var_everything&c_EPTF_Var_whitespace&"}"&c_EPTF_Var_whitespace,0); // trim down the {}-s
var charstring vl_emptyList := regexp(pl_valueStr,c_EPTF_Var_whitespace&"({"&c_EPTF_Var_whitespace&"})"&c_EPTF_Var_whitespace,0); // check empty list
if (vl_emptyList!="") { // empty list
return 0; // OK
}
if (vl_remaining=="" // not matched or empty list
and "" == vl_emptyList) { // not empty list
return 1; // syntax error
}
var charstring vl_currentValueStr := regexp(vl_remaining,c_EPTF_Var_integerNumber&c_EPTF_Var_everything,0); // first element
if (vl_remaining != "" and vl_currentValueStr == "") {
return 1; // syntax error: string does not begin with integer
}
for(var integer i:=0; vl_currentValueStr != ""; i:=i+1) {
pl_directContent.integerlistVal[i] := str2int(vl_currentValueStr);
vl_remaining := regexp(vl_remaining,c_EPTF_Var_integerNumber&c_EPTF_Var_whitespace&"[,]#(0,1)"&c_EPTF_Var_whitespace&c_EPTF_Var_everything,1); // the rest
vl_currentValueStr := regexp(vl_remaining,c_EPTF_Var_integerNumber&c_EPTF_Var_everything,0); // next element
if (vl_remaining != "" and vl_currentValueStr == "") {
return 1; // syntax error: string does not begin with integer
}
}
return 0; // OK
}
if (ischosen(pl_directContent.floatlistVal)) {
pl_directContent.floatlistVal := {};
var charstring vl_remaining := regexp(pl_valueStr,c_EPTF_Var_whitespace&"{"&c_EPTF_Var_whitespace&c_EPTF_Var_everything&c_EPTF_Var_whitespace&"}"&c_EPTF_Var_whitespace,0); // trim down the {}-s
var charstring vl_emptyList := regexp(pl_valueStr,c_EPTF_Var_whitespace&"({"&c_EPTF_Var_whitespace&"})"&c_EPTF_Var_whitespace,0); // check empty list
if (vl_emptyList!="") { // empty list
return 0; // OK
}
if (vl_remaining=="" // not matched or empty list
and "" == vl_emptyList) { // not empty list
return 1; // syntax error
}
var charstring vl_currentValueStr := regexp(vl_remaining,c_EPTF_Var_floatNumber&c_EPTF_Var_everything,0); // first element
if (vl_remaining != "" and vl_currentValueStr == "") {
return 1; // syntax error: string does not begin with float
}
for(var integer i:=0; vl_currentValueStr != ""; i:=i+1) {
pl_directContent.floatlistVal[i] := str2float(vl_currentValueStr);
vl_remaining := regexp(vl_remaining,c_EPTF_Var_floatNumber&c_EPTF_Var_whitespace&"[,]#(0,1)"&c_EPTF_Var_whitespace&c_EPTF_Var_everything,2); // the rest
vl_currentValueStr := regexp(vl_remaining,c_EPTF_Var_floatNumber&c_EPTF_Var_everything,0); // next element
if (vl_remaining != "" and vl_currentValueStr == "") {
return 1; // syntax error: string does not begin with float
}
}
return 0; // OK
}
if (ischosen(pl_directContent.charstringlistVal)) {
pl_directContent.charstringlistVal := {};
var charstring vl_remaining := regexp(pl_valueStr,c_EPTF_Var_whitespace&"{"&c_EPTF_Var_whitespace&c_EPTF_Var_everything&c_EPTF_Var_whitespace&"}"&c_EPTF_Var_whitespace,0); // trim down the {}-s
var charstring vl_emptyList := regexp(pl_valueStr,c_EPTF_Var_whitespace&"({"&c_EPTF_Var_whitespace&"})"&c_EPTF_Var_whitespace,0); // check empty list
if (vl_emptyList!="") { // empty list
return 0; // OK
}
if (vl_remaining=="" // not matched or empty list
and "" == vl_emptyList) { // not empty list
return 1; // syntax error
}
for(var integer i:=0; vl_remaining != ""; i:=i+1) {
var charstring vl_currentValueStr := regexp(vl_remaining,c_EPTF_Var_charstringValue&c_EPTF_Var_everything,0); // next element
if (vl_remaining != "" and vl_currentValueStr == "" // current value does not match or string is empty
and "" == regexp(vl_remaining,"("""")"&c_EPTF_Var_everything,0)) { // not starts with empty string
return 1; // syntax error: string does not begin with string
}
vl_remaining := regexp(vl_remaining,c_EPTF_Var_charstringValue&c_EPTF_Var_whitespace&"[,]#(0,1)"&c_EPTF_Var_whitespace&c_EPTF_Var_everything,1); // the rest
pl_directContent.charstringlistVal[i] := vl_currentValueStr;
}
return 0; // OK
}
if (ischosen(pl_directContent.statusLEDVal))
{
var charstring vl_ledColor := regexp(pl_valueStr,c_EPTF_Var_whitespace&"\\["&c_EPTF_Var_anyWord&"\\]"&c_EPTF_Var_everything,0);
var charstring vl_ledText := regexp(pl_valueStr,c_EPTF_Var_whitespace&"\\["&c_EPTF_Var_anyWord&"\\]"&c_EPTF_Var_everything,1);
if (vl_ledText != "") {
pl_directContent.statusLEDVal.text := vl_ledText;
} else {
pl_directContent.statusLEDVal.text := omit;
}
if (vl_ledColor == "led:blue") { pl_directContent.statusLEDVal.color := led_blue }
else if (vl_ledColor == "led:black") { pl_directContent.statusLEDVal.color := led_black }
else if (vl_ledColor == "led:yellow") { pl_directContent.statusLEDVal.color := led_yellow }
else if (vl_ledColor == "led:green") { pl_directContent.statusLEDVal.color := led_green }
else if (vl_ledColor == "led:red") { pl_directContent.statusLEDVal.color := led_red }
else {
return 1; // invalid color
}
return 0; // OK
}
if (ischosen(pl_directContent.unknownVal)) {
var charstring vl_currentValueStr := regexp(pl_valueStr,c_EPTF_Var_whitespace&"unknownValueOfType "&c_EPTF_Var_everything,0);
if (vl_currentValueStr!="") {
string2ttcn(vl_currentValueStr, pl_directContent.unknownVal.dataType);
} else {
return 1; // error
}
return 0; // OK
}
//...
return 1; // error (never executed)
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_directContent2string
//
// Purpose:
// Converts direct content to charstring (cfg file format)
///////////////////////////////////////////////////////////
private function f_EPTF_Var_directContent2string(in EPTF_Var_DirectContent pl_directContent) return charstring {
if (ischosen(pl_directContent.intVal)) {
return "{ intVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.floatVal)) {
return "{ floatVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.boolVal)) {
return "{ boolVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.charstringVal)) {
return "{ charstringVal := \"" &f_EPTF_Var_directContent2str(pl_directContent)&"\" }";
}
if (ischosen(pl_directContent.octetstringVal)) {
return "{ octetstringVal := '" &f_EPTF_Var_directContent2str(pl_directContent)&"'O }";
}
if (ischosen(pl_directContent.hexstringVal)) {
return "{ hexstringVal := '" &f_EPTF_Var_directContent2str(pl_directContent)&"'H }";
}
if (ischosen(pl_directContent.bitstringVal)) {
return "{ bitstringVal := '" &f_EPTF_Var_directContent2str(pl_directContent)&"'B }";
}
if (ischosen(pl_directContent.integerlistVal)) {
return "{ integerlistVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.floatlistVal)) {
return "{ floatlistVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.charstringlistVal)) {
return "{ charstringlistVal := " &f_EPTF_Var_directContent2str(pl_directContent)&" }";
}
if (ischosen(pl_directContent.statusLEDVal)) {
var charstring vl_ledText := "";
if (ispresent(pl_directContent.statusLEDVal.text)) {
vl_ledText:=pl_directContent.statusLEDVal.text;
}
var charstring vl_ledColor := "led_black";
if (pl_directContent.statusLEDVal.color == led_blue) { vl_ledColor := "led_blue" }
else if (pl_directContent.statusLEDVal.color == led_black) { vl_ledColor := "led_black" }
else if (pl_directContent.statusLEDVal.color == led_yellow) { vl_ledColor := "led_yellow" }
else if (pl_directContent.statusLEDVal.color == led_green) { vl_ledColor := "led_green" }
else if (pl_directContent.statusLEDVal.color == led_red) { vl_ledColor := "led_red" }
return "{ statusLEDVal := { color := "&vl_ledColor&", text := \""&vl_ledText&"\" } }";
}
//...
f_EPTF_Common_error(log2str("ERROR:","Cannot convert direct content ",pl_directContent," to string."));
//f_EPTF_Logging_error(true,log2str("Cannot convert direct content ",pl_directContent," to string."));
stop;
}
// SUBSCRIBING
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addLocalSubscriber
//
// Purpose:
// Adds the pl_idx variable as a local subscriber to the local variables given by pl_argList
///////////////////////////////////////////////////////////
private function f_EPTF_Var_addLocalSubscriber(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_Var_CT {
var integer vl_last, vl_providerIdx;
for(var integer i:=0; i<sizeof(pl_argList); i:=i+1) {
vl_providerIdx := pl_argList[i];
vl_last := sizeof(v_EPTF_Vars[vl_providerIdx].subscribers);
v_EPTF_Vars[vl_providerIdx].subscribers[vl_last] := {
local := pl_idx
}
if (not f_EPTF_Var_checkSubscriptionMode(vl_providerIdx,pull) and not f_EPTF_Var_checkLocalSubscriptionMode(vl_providerIdx,pull)) {
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_getContent(vl_providerIdx,vl_currentContent);
f_EPTF_Var_registerRefresh(vl_providerIdx,vl_currentContent);
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeLocalSubscriber
//
// Purpose:
// Removes the pl_idx variable as a local subscriber from the local variables given by pl_argList
///////////////////////////////////////////////////////////
private function f_EPTF_Var_removeLocalSubscriber(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_Var_CT {
var integer vl_last, vl_providerIdx;
var EPTF_Var_Subscribers vl_oldSubscribers;
for(var integer i:=0; i<sizeof(pl_argList); i:=i+1) {
vl_providerIdx := pl_argList[i];
vl_oldSubscribers := v_EPTF_Vars[vl_providerIdx].subscribers;
vl_last := sizeof(vl_oldSubscribers);
v_EPTF_Vars[vl_providerIdx].subscribers := {};
for (var integer j:=0; j<vl_last; j:=j+1) {
if (not (ischosen(vl_oldSubscribers[j].local) and vl_oldSubscribers[j].local == pl_idx) ) {
v_EPTF_Vars[vl_providerIdx].subscribers[sizeof(v_EPTF_Vars[vl_providerIdx].subscribers)] := vl_oldSubscribers[j]
}
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addRemoteSubscriber
//
// Purpose:
// Adds the remote provider as a remote subscriber to the pl_idx variable,
// the subscription mode can be set in the remote provider
///////////////////////////////////////////////////////////
private function f_EPTF_Var_addRemoteSubscriber(in integer pl_idx, in EPTF_Var_SubscriberRemote pl_remoteProvider) runs on EPTF_Var_CT {
var integer vl_last := sizeof(v_EPTF_Vars[pl_idx].subscribers);
v_EPTF_Vars[pl_idx].subscribers[vl_last] := {
remote := pl_remoteProvider
}
if (pl_remoteProvider.subscriptionMode == timeLine) {
v_EPTF_Vars[pl_idx].nofTimelineSubscribers := v_EPTF_Vars[pl_idx].nofTimelineSubscribers + 1;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeRemoteSubscriber
//
// Purpose:
// Removes the remote provider as a remote subscriber from the pl_idx variable
// the subscription mode can be set in the remote provider
///////////////////////////////////////////////////////////
private function f_EPTF_Var_removeRemoteSubscriber(in integer pl_idx, in EPTF_Var_Ref pl_remoteProvider) runs on EPTF_Var_CT {
var integer vl_last;
var EPTF_Var_Subscribers vl_oldSubscribers;
vl_oldSubscribers := v_EPTF_Vars[pl_idx].subscribers;
vl_last := sizeof(vl_oldSubscribers);
v_EPTF_Vars[pl_idx].subscribers := {};
for (var integer j:=0; j<vl_last; j:=j+1) {
if (not (ischosen(vl_oldSubscribers[j].remote) and vl_oldSubscribers[j].remote.varRef == pl_remoteProvider) ) {
v_EPTF_Vars[pl_idx].subscribers[sizeof(v_EPTF_Vars[pl_idx].subscribers)] := vl_oldSubscribers[j]
} else {
if (vl_oldSubscribers[j].remote.subscriptionMode == timeLine) {
v_EPTF_Vars[pl_idx].nofTimelineSubscribers := v_EPTF_Vars[pl_idx].nofTimelineSubscribers - 1;
}
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getTopProviderType
//
// Purpose:
// Returns the top provider type of the given EPTF Variable
///////////////////////////////////////////////////////////
public function f_EPTF_Var_getTopProviderType(in integer pl_idx, out EPTF_TopProviderType pl_topProviderType) runs on EPTF_Var_CT {
if (ischosen(v_EPTF_Vars[pl_idx].provider.empty)) {
pl_topProviderType := empty;
return;
}
if (ischosen(v_EPTF_Vars[pl_idx].provider.local)) {
pl_topProviderType := local;
return;
}
pl_topProviderType := v_EPTF_Vars[pl_idx].provider.remote.topProviderType;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_findSubscription
//
// Purpose:
// Finds the variable that has subscribed for pl_remoteProviderRef,
// if not found pl_idx is set to -1.
// Buffered and non-buffered subscriptions modes are treated the same way (subscriptions mode flag is ignored)
// This makes it impossible to subscribe in a non-buffered way and then subscribe in buffered way
// to the same variable
///////////////////////////////////////////////////////////
private function f_EPTF_Var_findSubscription(in EPTF_Var_CT pl_remoteCompRef, in charstring pl_remoteProviderVarName, out integer pl_idx) runs on EPTF_Var_CT {
pl_idx := -1;
if (f_EPTF_str2int_HashMap_Find(v_EPTF_Var_Hashmap_Provider2Id,log2str(pl_remoteCompRef)&"."&pl_remoteProviderVarName,pl_idx)) {
//remove the warning
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_sendSubscribe
//
// Purpose:
// Sends the subscribe message to the remote provider
///////////////////////////////////////////////////////////
private function f_EPTF_Var_sendSubscribe(
in integer pl_idx,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
in integer pl_refreshRate,
in integer pl_blockingFlagIdx := -1
) runs on EPTF_Var_CT {
f_EPTF_Var_addConnection(pl_remoteCompRef);
f_EPTF_Var_send({subscribe := {v_EPTF_Vars[pl_idx].name,{self,pl_idx},pl_remoteProviderVarName,pl_subscriptionMode,pl_refreshRate,pl_blockingFlagIdx}}, pl_remoteCompRef);
}
// removes the pl_idx variable as a remote subscriber from the remote provider
private function f_EPTF_sendUnsubscribe(in integer pl_idx, in EPTF_Var_Ref pl_remoteProviderRef, in EPTF_Var_SubscriptionMode pl_subscriptionMode, in integer pl_refreshRate) runs on EPTF_Var_CT {
f_EPTF_Var_send({unsubscribe := {{self,pl_idx},pl_remoteProviderRef,pl_subscriptionMode,pl_refreshRate}}, pl_remoteProviderRef.compRef);
f_EPTF_Var_removeConnection(pl_idx, pl_remoteProviderRef);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_sendSubscribe_nonBlocking
//
// Purpose:
// Nonblocking version of <f_EPTF_Var_sendSubscribe>.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_sendSubscribe_nonBlocking(
in integer pl_idx,
in EPTF_Var_CT pl_remoteCompRef,
in charstring pl_remoteProviderVarName,
in EPTF_Var_SubscriptionMode pl_subscriptionMode,
in integer pl_refreshRate
) runs on EPTF_Var_CT {
var EPTF_Var_MgmtMsg vl_msgToSend := {
subscribe := {
subscriberVarName := v_EPTF_Vars[pl_idx].name,
subscriber := {self,pl_idx},
providerVarName := pl_remoteProviderVarName,
subscriptionMode := pl_subscriptionMode,
refreshRate := pl_refreshRate,
blockingFlagIdx := -1
}
}
if (f_EPTF_Var_isConnected(pl_remoteCompRef)){
f_EPTF_Var_send(vl_msgToSend, pl_remoteCompRef);
}else{ // if not connected buffering the messages until HelloAck arrives
var integer vl_bufferIdx := f_EPTF_Base_upcast(pl_remoteCompRef);
if(not isbound(v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx])){
v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx] := {};
}
v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx][sizeof(v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx])] := {
msg := vl_msgToSend,
destinationCompRef := pl_remoteCompRef
}
f_EPTF_Var_addConnection_nonBlocking(pl_remoteCompRef);
}
}
private function f_EPTF_Var_connectCallback(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT {
var integer vl_bufferIdx := f_EPTF_Base_upcast(pl_remoteCompRef);
if(f_EPTF_Var_isConnected(pl_remoteCompRef)){
for(var integer i:= 0; i<sizeof(v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx]); i:=i+1) {
f_EPTF_Var_send(v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx][i].msg,v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx][i].destinationCompRef);
}
}else{
if(sizeof(v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx])>0){
f_EPTF_Var_warning(log2str(%definitionId, ": No connection towards component ", pl_remoteCompRef, ". Message is not sent, ignored."));
}
}
v_EPTF_Var_msgBufferBeforeConnect[vl_bufferIdx] := {};
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addConnection
//
// Purpose:
// Checks if there is a connection towards the pl_remoteProvider. if connection does not exist creates it.
// uses the 0-th syncBuffer for that. The variable is only added to the syncBuffer if the subscription is buffered,
// but the sync buffer for that component is always created.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_addConnection(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT {
if (f_EPTF_Var_getConnectionState(pl_remoteCompRef) == terminated) {
// no more connection possible
f_EPTF_Var_warning(log2str(%definitionId, ": Cannot create new connection towards component ", pl_remoteCompRef, " : Component has already terminated!"));
return;
}
// if not connected:
if (not f_EPTF_Var_isConnected(pl_remoteCompRef)) {
f_EPTF_Var_connect(pl_remoteCompRef);
// f_EPTF_Var_registerConnection is called when helloAck arrives in f_EPTF_Var_handle_HelloAck
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_addConnection_nonBlocking
//
// Purpose:
// Nonblocking version of <f_EPTF_Var_addConnection>.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_addConnection_nonBlocking(
in EPTF_Var_CT pl_remoteCompRef
) runs on EPTF_Var_CT {
if (f_EPTF_Var_getConnectionState(pl_remoteCompRef) == terminated) {
// no more connection possible
f_EPTF_Var_warning(log2str(%definitionId, ": Cannot create new connection towards component ", pl_remoteCompRef, " : Component has already terminated!"));
// call handler function
f_EPTF_Var_connectCallback(pl_remoteCompRef);
return;
}
// if not connected:
if (not f_EPTF_Var_isConnected(pl_remoteCompRef)) {
f_EPTF_Var_connect_nonBlocking(pl_remoteCompRef);
// f_EPTF_Var_registerConnection is called when helloAck arrives in f_EPTF_Var_handle_HelloAck
}else { // already connected therefore call the connect handler
f_EPTF_Var_connectCallback(pl_remoteCompRef);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_connect
//
// Purpose:
// Sets up a connection towards the remote component.
// If the setup is successful (helloAck arrives) it continues execution.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_connect(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT {
connect(self:EPTF_Var_MgmtIf,pl_remoteCompRef:EPTF_Var_MgmtIf);
// send hello and wait for the answer
var integer vl_trID := f_EPTF_setNewboolean(v_booleanPool,false);
EPTF_Var_MgmtIf.send(
{hello:={
vl_trID
}}
) to pl_remoteCompRef;
v_EPTF_Var_numPendingHellos := v_EPTF_Var_numPendingHellos + 1;
// create a blocking flag & block execution until helloAck arrives
timer t_minWait := 0.0; // zero wait
timer t_maxWait := v_EPTF_Var_maxWaitTimeForByeAck; // maximum wait
t_minWait.start;
t_maxWait.start;
// wait until response is received:
alt {
[f_EPTF_getValueboolean(v_booleanPool,vl_trID)] t_minWait.timeout;
[] t_maxWait.timeout {
f_EPTF_Var_warning(log2str("Connection establishment is unsuccessful: No response received for hello from: ", pl_remoteCompRef));
}
}
// remove the bool from the pool:
f_EPTF_deleteboolean(v_booleanPool,vl_trID);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_connect_nonBlocking
//
// Purpose:
// Non-blocking version of <f_EPTF_Var_connect>.
// It does not wait until the helloAck arrives.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_connect_nonBlocking(
in EPTF_Var_CT pl_remoteCompRef
) runs on EPTF_Var_CT {
v_EPTF_Var_nonBlockingEnabled[f_EPTF_Base_upcast(pl_remoteCompRef)] := true;
connect(self:EPTF_Var_MgmtIf,pl_remoteCompRef:EPTF_Var_MgmtIf);
// send hello and don't wait for the answer
var integer vl_trID := f_EPTF_setNewboolean(v_booleanPool,false);
EPTF_Var_MgmtIf.send(
{hello:={
vl_trID
}}
) to pl_remoteCompRef;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_isConnected
//
// Purpose:
// Checks if there is a connection towards the pl_remoteCompRef. if connection exists returns true,
// else it returns false.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_isConnected(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT return boolean {
return f_EPTF_Var_getConnectionState(pl_remoteCompRef) == connected;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_checkConnection
//
// Purpose:
// Checks if there is a connection towards the pl_remoteCompRef for a given refreshRate. if connection exists sets pl_refreshRateId and pl_compBufferIdx to its idx,
// else it is set to -1.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_checkConnection(in EPTF_Var_CT pl_remoteCompRef, in integer pl_refreshRate, out integer pl_refreshRateId, out integer pl_compBufferIdx) runs on EPTF_Var_CT {
pl_compBufferIdx := -1;
pl_refreshRateId := -1;
for(var integer r := 0; r<sizeof(v_syncBuffer); r:=r+1) {
if (v_syncBuffer[r].refreshRate == pl_refreshRate) {
pl_refreshRateId := r;
break;
}
}
if (pl_refreshRateId==-1) {
return;
}
if (pl_remoteCompRef==null) {
return; // do not search for compBufferIdx
}
for(var integer i:=0; i<sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].remoteCompRef == pl_remoteCompRef) {
pl_compBufferIdx := i;
return;
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_registerConnection
//
// Purpose:
// Adds a new connection to the syncBuffer for a given refreshRate
///////////////////////////////////////////////////////////
private function f_EPTF_Var_registerConnection(in EPTF_Var_CT pl_remoteCompRef, in integer pl_refreshRate, out integer pl_refreshRateId, out integer pl_compBufferIdx) runs on EPTF_Var_CT {
pl_refreshRateId := -1;
for(var integer r := 0; r<sizeof(v_syncBuffer); r:=r+1) {
if (v_syncBuffer[r].refreshRate == pl_refreshRate) {
pl_refreshRateId := r;
break;
}
}
if (pl_refreshRateId==-1) {
pl_refreshRateId := sizeof(v_syncBuffer);
v_syncBuffer[pl_refreshRateId].refreshRate := pl_refreshRate;
v_syncBuffer[pl_refreshRateId].eventIdx := -1; // invalid index
v_syncBuffer[pl_refreshRateId].syncBuffer := {};
}
pl_compBufferIdx := sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer);
v_syncBuffer[pl_refreshRateId].syncBuffer[pl_compBufferIdx]:= {
remoteCompRef := pl_remoteCompRef,
flushCounter := 0,
compBufferData := {}
}
v_EPTF_Var_Connections[f_EPTF_Base_upcast(pl_remoteCompRef)] := connected;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_removeConnection
//
// Purpose:
// The variable is only removed from the syncBuffer if the subscription is buffered,
// but the sync buffer for that component is not removed.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_removeConnection(in integer pl_idx, in EPTF_Var_Ref pl_remoteProviderRef) runs on EPTF_Var_CT {
// nothing to do
//If you implement it, take care of
//f_EPTF_Var_checkConnection and f_EPTF_Var_registerConnection functions.
//Continuity must be checked there
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_deregisterConnection
//
// Purpose:
// Removed a connection from the syncBuffer
//
// Returns:
// *boolean* - true if there are still alive connections, false if all connections are closed
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_deregisterConnection(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT return boolean {
var boolean vl_result := false;
for(var integer vl_refreshRateId := 0; vl_refreshRateId<sizeof(v_syncBuffer); vl_refreshRateId := vl_refreshRateId+1) {
for(var integer i:=0; i<sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer); i:=i+1) {
// remove connection from database:
if (v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef == pl_remoteCompRef) {
v_syncBuffer[vl_refreshRateId].syncBuffer[i] := {
remoteCompRef := null,
flushCounter := 0,
compBufferData := {}
}
} else if (vl_result==false and v_syncBuffer[vl_refreshRateId].syncBuffer[i].remoteCompRef != null ) {
vl_result := true; // other connections still exist
}
}
}
v_EPTF_Var_Connections[f_EPTF_Base_upcast(pl_remoteCompRef)] := terminated;
return vl_result;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_getConnectionState
//
// Purpose:
// Returns the connection state towards the given remote component
//
// Returns:
// <EPTF_Var_ConnectionState> - state of the connection towards the remote component
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_getConnectionState(in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT return EPTF_Var_ConnectionState {
if (not isbound(v_EPTF_Var_Connections[f_EPTF_Base_upcast(pl_remoteCompRef)])) {
return idle;
}
return v_EPTF_Var_Connections[f_EPTF_Base_upcast(pl_remoteCompRef)];
}
// SEND FUNCTION
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_send
//
// Purpose:
// Send a message on the Variable interface
///////////////////////////////////////////////////////////
private function f_EPTF_Var_send(in EPTF_Var_MgmtMsg pl_EPTF_Var_MgmtMsg, in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT {
if (not f_EPTF_Var_isConnected(pl_remoteCompRef)) {
return; // no connection towards remote component
}
if (ischosen(pl_EPTF_Var_MgmtMsg.subscribe)) {
//action("*** Msg added to buffer");
var integer vl_bufferSize := sizeof(v_EPTF_Var_Msg_Buffer);
if (vl_bufferSize==0) {
t_EPTF_Var_Msg_Buffer_timer.start;
}
v_EPTF_Var_Msg_Buffer[vl_bufferSize] := { pl_EPTF_Var_MgmtMsg, pl_remoteCompRef };
} else {
EPTF_Var_MgmtIf.send(pl_EPTF_Var_MgmtMsg) to pl_remoteCompRef;
}
}
private function f_EPTF_Var_calculateNofMsgsToSend() runs on EPTF_Var_CT return integer {
var integer vl_buffSize := sizeof(v_EPTF_Var_Msg_Buffer);
var integer vl_nofMsgsToSend := v_EPTF_Var_Msg_BufferBurstSize;
if (vl_buffSize<vl_nofMsgsToSend + v_EPTF_Var_Msg_BufferStartIdx) {
vl_nofMsgsToSend := vl_buffSize - v_EPTF_Var_Msg_BufferStartIdx;
} //else {
//action("*** BUFFER SIZE: ", sizeof(v_EPTF_Var_Msg_Buffer));
//action("*** msgs to send: ", vl_nofMsgsToSend-v_EPTF_Var_Msg_BufferStartIdx);
//action("*** msgs remain: ", vl_buffSize-vl_nofMsgsToSend);
//action("*** Time delay : ", f_EPTF_Base_getRelTimeInSecs() - v_EPTF_Var_startTime);
//action("*** buffer content: ", v_EPTF_Var_Msg_Buffer);
//}
// if pending messages would exceed limit, send less messages:
if (v_EPTF_Var_maxNofPendingMsgs<v_EPTF_Var_nofPendingMsgs+vl_nofMsgsToSend) {
vl_nofMsgsToSend := v_EPTF_Var_maxNofPendingMsgs-v_EPTF_Var_nofPendingMsgs;
//action("*** maxNofPendingMsgs reached!: ", v_EPTF_Var_nofPendingMsgs, " msgs to send: ", vl_nofMsgsToSend);
}
//action("*** vl_nofMsgsToSend:", vl_nofMsgsToSend);
return vl_nofMsgsToSend;
}
private altstep as_EPTF_Var_Msg_Buffer_Handler() runs on EPTF_Var_CT {
[sizeof(v_EPTF_Var_Msg_Buffer) != 0 and f_EPTF_Var_calculateNofMsgsToSend()>0] t_EPTF_Var_Msg_Buffer_timer.timeout {
// TODO: send buffer with clustering
var integer vl_buffSize := sizeof(v_EPTF_Var_Msg_Buffer);
var integer vl_lastIdx := v_EPTF_Var_Msg_BufferStartIdx + f_EPTF_Var_calculateNofMsgsToSend();
for(var integer i:=v_EPTF_Var_Msg_BufferStartIdx; i<vl_lastIdx; i:=i+1) {
if (f_EPTF_Var_isConnected(v_EPTF_Var_Msg_Buffer[i].destinationCompRef)) {
EPTF_Var_MgmtIf.send(v_EPTF_Var_Msg_Buffer[i].msg) to v_EPTF_Var_Msg_Buffer[i].destinationCompRef;
}
}
//action("***sent messages: ", vl_lastIdx-v_EPTF_Var_Msg_BufferStartIdx, " remained in buffer: ", vl_buffSize-vl_lastIdx);
//increase number of pending getData counter with the number of messages sent:
v_EPTF_Var_nofPendingMsgs := v_EPTF_Var_nofPendingMsgs + vl_lastIdx - v_EPTF_Var_Msg_BufferStartIdx;
v_EPTF_Var_Msg_BufferStartIdx := vl_lastIdx;
if (v_EPTF_Var_Msg_BufferStartIdx==vl_buffSize) {
v_EPTF_Var_Msg_BufferStartIdx := 0;
v_EPTF_Var_Msg_Buffer := {};
} else {
// there are still messages left in the buffer
t_EPTF_Var_Msg_Buffer_timer.start(0.001);
//action("**** msgs remain: ", vl_buffSize-v_EPTF_Var_Msg_BufferStartIdx);
}
repeat;
}
}
// RECEIVING MESSAGES
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_IsPresentRemote
//
// Purpose:
// Handler for IsPresentRemoteResp message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_IsPresentRemote(in EPTF_Var_Msg_IsPresentRemote pl_isPresentRemote, in EPTF_Var_CT pl_remoteCompRef) runs on EPTF_Var_CT {
var EPTF_Var_Msg_IsPresentRemoteResp vl_isPresentRemoteResp := {
remoteVarName := pl_isPresentRemote.remoteVarName,
blockingFlagIdx := pl_isPresentRemote.blockingFlagIdx,
responseIdx := pl_isPresentRemote.responseIdx,
isPresent := (-1 != f_EPTF_Var_getId(pl_isPresentRemote.remoteVarName))
};
f_EPTF_Var_addConnection(pl_remoteCompRef);
f_EPTF_Var_send({isPresentRemoteResp:=vl_isPresentRemoteResp},pl_remoteCompRef);
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_IsPresentRemoteResp
//
// Purpose:
// Handler for IsPresentRemoteResp message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_IsPresentRemoteResp(in EPTF_Var_Msg_IsPresentRemoteResp pl_isPresentRemoteResp) runs on EPTF_Var_CT {
// set the responseValue to the boolean pool:
if (pl_isPresentRemoteResp.responseIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_isPresentRemoteResp.responseIdx,pl_isPresentRemoteResp.isPresent);
}
// disable blocking if it was requested:
if (pl_isPresentRemoteResp.blockingFlagIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_isPresentRemoteResp.blockingFlagIdx,true);
}
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_SubscribeResp
//
// Purpose:
// Handler for SubscribeResp message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_SubscribeResp(in EPTF_Var_Msg_SubscribeResp pl_subscribeResp, in EPTF_Var_CT pl_sender) runs on EPTF_Var_CT {
if (pl_subscribeResp.content == omit) {
f_EPTF_Var_error(log2str("Variable ",pl_subscribeResp.subscriberVarName, " on component ",pl_subscribeResp.provider.compRef," does not exist. Subscribe failed by the subscriber: ", pl_subscribeResp.subscriber));
//f_EPTF_Base_stop();
}
var integer vl_myIdx := pl_subscribeResp.subscriber.idx;
// change subscription mode to pull if provider is a pull mode subscriber:
if (ispresent(pl_subscribeResp.content) and ischosen(pl_subscribeResp.content.unknownVal)) {
v_EPTF_Vars[vl_myIdx].provider.remote.subscriptionMode := pull;
}
if (ischosen(v_EPTF_Vars[vl_myIdx].content.invalid) and not f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull)) {
v_EPTF_Vars[vl_myIdx].content := { direct := pl_subscribeResp.content };
}
// get response handler
var EPTF_Var_resubscribeRemoteResp_handler vl_respHandler := cg_EPTF_Var_resubscribeRemoteResp_handler_null;
if(isbound(v_EPTF_Var_resubscribeRemoteResp_handler_DB[vl_myIdx]) and v_EPTF_Var_resubscribeRemoteResp_handler_DB[vl_myIdx].handlerFn != null){
vl_respHandler := v_EPTF_Var_resubscribeRemoteResp_handler_DB[vl_myIdx];
v_EPTF_Var_resubscribeRemoteResp_handler_DB[vl_myIdx] := cg_EPTF_Var_resubscribeRemoteResp_handler_null;
}
if(ischosen(v_EPTF_Vars[vl_myIdx].provider.empty)) {
f_EPTF_Var_warning(log2str(%definitionId, ": Subscribe resp is ignored for variable ", v_EPTF_Vars[vl_myIdx].name, " : remote component exited."));
// disable blocking if it was requested:
if (pl_subscribeResp.blockingFlagIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_subscribeResp.blockingFlagIdx,true);
}
if(vl_respHandler.handlerFn != null) {
vl_respHandler.handlerFn.apply(vl_myIdx,false,vl_respHandler.argList); // resubscribe is unsuccessful
}
return;
}
var boolean vl_bufferedAdjust := v_EPTF_Vars[vl_myIdx].provider.remote.varRef.idx == -2;
var EPTF_Var_DirectContent vl_bufferedContent;
if (vl_bufferedAdjust) {
f_EPTF_Var_getContent(vl_myIdx,vl_bufferedContent);
}
v_EPTF_Vars[vl_myIdx].provider.remote.topProviderType := pl_subscribeResp.topProviderType;
v_EPTF_Vars[vl_myIdx].provider.remote.varRef.idx := pl_subscribeResp.provider.idx;
v_EPTF_Vars[vl_myIdx].provider.remote.varRef.compRef := pl_subscribeResp.provider.compRef;
// update the timeLine of the subscriber if subscription mode is sampled, sampledAtSync or timeLine:
if (
f_EPTF_Var_checkSubscriptionMode(vl_myIdx,timeLine)
or f_EPTF_Var_checkSubscriptionMode(vl_myIdx,sampled) or f_EPTF_Var_checkSubscriptionMode(vl_myIdx,sampledAtSync)) {
// add the timeLine from subscribeResp to the variable:
f_EPTF_Var_handle_RefreshTimeLines({
refreshRate := v_EPTF_Vars[vl_myIdx].provider.remote.refreshRate,
flushCounter := 1,
timeLineList := {
{
idx := vl_myIdx,
timeLine := {
size := 1,
timeLineData := { {
timestamp := pl_subscribeResp.timestamp,
content := pl_subscribeResp.content
} }
}
}
}
});
}
if (v_EPTF_Vars[vl_myIdx].name == "") {
var charstring vl_autoName := pl_subscribeResp.subscriberVarName;
var integer vl_idx;
if (f_EPTF_Var_checkName(vl_autoName,vl_idx)) {
v_EPTF_Vars[vl_myIdx].name := vl_autoName;
// register the variable name into the hashmap:
if (v_EPTF_Var_enableName2Id) {
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_Name2Id,vl_autoName,vl_myIdx);
}
} else {
f_EPTF_Var_error(log2str("Auto-generated name ",vl_autoName," for subscriber EPTF_Var[",vl_myIdx,"] is not unique. Already defined by EPTF_Var[",vl_idx,"]: ", v_EPTF_Vars[vl_idx]));
//f_EPTF_Base_stop();
}
}
if (v_EPTF_Vars[vl_myIdx].subsCanAdjust != pl_subscribeResp.subsCanAdjust) {
v_EPTF_Vars[vl_myIdx].subsCanAdjust := pl_subscribeResp.subsCanAdjust;
f_EPTF_Var_callSubsCanAdjustNotifyFns(vl_myIdx);
f_EPTF_Var_setSubsCanAdjustInAllSubscribers(vl_myIdx);
}
// call response handler
if(vl_respHandler.handlerFn != null) {
vl_respHandler.handlerFn.apply(vl_myIdx,true,vl_respHandler.argList); // resubscribe is successful
}
// disable blocking if it was requested:
if (pl_subscribeResp.blockingFlagIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_subscribeResp.blockingFlagIdx,true);
}
// do not refresh for pull mode subscription:
if (not f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull)) {
f_EPTF_Var_registerRefresh(vl_myIdx,pl_subscribeResp.content);
}
if (vl_bufferedAdjust) {
f_EPTF_Var_adjustContent(vl_myIdx,vl_bufferedContent);
}
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_GetRemoteContentResp
//
// Purpose:
// Handler for GetRemoteContentResp message. Returns false if content is invalid
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_GetRemoteContentResp(in EPTF_Var_Msg_GetRemoteContentResp pl_getRemoteContentResp) runs on EPTF_Var_CT {
if (pl_getRemoteContentResp.content == omit) {
if (pl_getRemoteContentResp.responseIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_getRemoteContentResp.responseIdx,false);
}
} else {
if (pl_getRemoteContentResp.responseIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_getRemoteContentResp.responseIdx,true);
v_EPTF_Var_getRemoteContentResultList[pl_getRemoteContentResp.responseIdx] := {{null,-1},pl_getRemoteContentResp.content,pl_getRemoteContentResp.subsCanAdjust}
if (ispresent(pl_getRemoteContentResp.provider)) {
v_EPTF_Var_getRemoteContentResultList[pl_getRemoteContentResp.responseIdx].provider := pl_getRemoteContentResp.provider;
}
}
}
// disable blocking if it was requested:
if (pl_getRemoteContentResp.blockingFlagIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_getRemoteContentResp.blockingFlagIdx,true);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_AdjustRemoteContentResp
//
// Purpose:
// Handler for AdjustRemoteContentResp message. Returns false if content is invalid
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_AdjustRemoteContentResp(in EPTF_Var_Msg_AdjustRemoteContentResp pl_adjustRemoteContentResp) runs on EPTF_Var_CT {
// call user handler:
if (pl_adjustRemoteContentResp.adjust.respHandlerId != -1) {
// find handler data in the stack:
var EPTF_Var_adjustContentResp_handler vl_respHandler;
if (f_EPTF_getEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_adjustRemoteContentResp.adjust.respHandlerId,vl_respHandler)) {
// call the user handler (cannot be null: for null the respHandlerId was set to -1):
var integer vl_myIdx := -1; // invalid
vl_respHandler.handlerFn.apply(vl_myIdx, pl_adjustRemoteContentResp.adjust.content, pl_adjustRemoteContentResp.result, vl_respHandler.argList);
// release the stack:
f_EPTF_deleteEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_adjustRemoteContentResp.adjust.respHandlerId);
} else {
// this is never called (just to remove the warning):
f_EPTF_Var_error("Callback function for AdjustRemoteContentResp handler not found. Database error!");
//f_EPTF_Base_stop();
}
}
// set the responseValue to the boolean pool:
if (pl_adjustRemoteContentResp.adjust.responseIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_adjustRemoteContentResp.adjust.responseIdx,pl_adjustRemoteContentResp.result);
}
// disable blocking if it was requested:
if (pl_adjustRemoteContentResp.adjust.blockingFlagIdx != -1) {
f_EPTF_setValueboolean(v_booleanPool,pl_adjustRemoteContentResp.adjust.blockingFlagIdx,true);
}
}
///////////////////////////////////////////////////////////
// Function: as_EPTF_Var_handle_ByeAck
//
// Purpose:
// Handler for ByeAck message
///////////////////////////////////////////////////////////
private altstep as_EPTF_Var_handle_ByeAck(timer t_wait) runs on EPTF_Var_CT {
var EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg;
var EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender;
[] EPTF_Var_MgmtIf.receive({byeAck:=?}) -> value vl_EPTF_Var_MgmtIf_msg sender vl_EPTF_Var_MgmtIf_msg_sender {
if (f_EPTF_Var_handle_ByeAck(vl_EPTF_Var_MgmtIf_msg_sender)) {
t_wait.stop; t_wait.start;
repeat;
}
}
[] t_wait.timeout {
f_EPTF_Var_warning("--VAR CLEANUP TIMEOUT-- Not all responses received for bye messages.");
}
}
///////////////////////////////////////////////////////////
// Function: as_EPTF_Var_handle_Bye
//
// Purpose:
// Handler for Bye message
///////////////////////////////////////////////////////////
private altstep as_EPTF_Var_handle_Bye() runs on EPTF_Var_CT {
var EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg;
var EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender;
[] EPTF_Var_MgmtIf.receive({bye:=?}) -> value vl_EPTF_Var_MgmtIf_msg sender vl_EPTF_Var_MgmtIf_msg_sender {
f_EPTF_Var_handle_Bye(vl_EPTF_Var_MgmtIf_msg_sender);
repeat;
}
}
// REFRESH CONTENT
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_registerRefresh
//
// Purpose:
// Requests the library to register the content refresh of the EPTF_Var.
// (the content of the variable can be updated before calling this function)
// Also notifies all of its subscribers about the new value and calls postProcFns
///////////////////////////////////////////////////////////
private function f_EPTF_Var_registerRefresh(in integer pl_idx, in EPTF_Var_DirectContent pl_contentNew, in float pl_timeStamp := -1.0) runs on EPTF_Var_CT {
// set the new content into the current:
f_EPTF_Var_setContent(pl_idx,pl_contentNew);
// updates the timeLine with the new value
f_EPTF_Var_updateTimeLine(pl_idx,pl_contentNew,pl_timeStamp);
// call postProc functions:
f_EPTF_Var_callPostProcFns(pl_idx);
// update new value after postproc
f_EPTF_Var_content2direct(v_EPTF_Vars[pl_idx].content,pl_contentNew);
// notify subscribers:
f_EPTF_Var_notifyAllSubscribers(pl_idx,pl_contentNew);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_notifyAllSubscribers
//
// Purpose:
// Notifies all subscribers of the EPTF_Var pl_idx with the new content
///////////////////////////////////////////////////////////
private function f_EPTF_Var_notifyAllSubscribers(in integer pl_idx, in EPTF_Var_DirectContent pl_contentNew) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subscribers); i:=i+1) {
f_EPTF_Var_notifySubscriber(v_EPTF_Vars[pl_idx].subscribers[i],pl_contentNew);
}
if (v_EPTF_Var_refreshSubscribersPeriod<0.0) {
// instant update:
var float vl_timeStamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime());
for(var integer vl_idx:=f_EPTF_Var_getVarToUpdate(); vl_idx!=-1; vl_idx := f_EPTF_Var_getVarToUpdate()) {
// list is not empty, there are more vars to update
// refresh selected variable:
//f_EPTF_Var_refreshContent(vl_idx);
var EPTF_Var_DirectContent vl_contentNew;
f_EPTF_Var_callCalcFn(vl_idx,vl_contentNew);
f_EPTF_Var_registerRefresh(vl_idx,vl_contentNew,vl_timeStamp);
}
}
}
// sets the refresh period for subscribers (local subscribers)
private function f_EPTF_Var_setRefreshSubscribersPeriod(in float pl_refreshSubscribersPeriod := tsp_EPTF_Var_refreshSubscribersPeriod) runs on EPTF_Var_CT {
v_EPTF_Var_refreshSubscribersPeriod := pl_refreshSubscribersPeriod;
if (v_EPTF_Var_refreshSubscribersPeriod>=0.0) {
t_EPTF_Var_refreshSubscribers.start(v_EPTF_Var_refreshSubscribersPeriod);
} else {
t_EPTF_Var_refreshSubscribers.stop;
}
}
// handler of the refreshSubscribers timer
// updates all variables in the v_EPTF_Var_varsToUpdate database in order
private altstep as_EPTF_Var_refreshSubscribers() runs on EPTF_Var_CT {
[v_EPTF_Var_refreshSubscribersPeriod>=0.0 and sizeof(v_EPTF_Var_varsToUpdate)>1] t_EPTF_Var_refreshSubscribers.timeout {
t_EPTF_Var_refreshSubscribers.start(v_EPTF_Var_refreshSubscribersPeriod);
// select the first var in the list and update its content:
var float vl_timeStamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime());
for(var integer vl_idx:=f_EPTF_Var_getVarToUpdate();
vl_idx!=-1;
vl_idx := f_EPTF_Var_getVarToUpdate()) {
// list is not empty, there are more vars to update
// refresh selected variable:
//f_EPTF_Var_refreshContent(vl_idx);
var EPTF_Var_DirectContent vl_contentNew;
f_EPTF_Var_callCalcFn(vl_idx,vl_contentNew);
f_EPTF_Var_registerRefresh(vl_idx,vl_contentNew,vl_timeStamp);
}
repeat;
}
}
// inserts a new element into v_EPTF_Var_varsToUpdate
private function f_EPTF_Var_addVarToUpdate(in integer pl_idx) runs on EPTF_Var_CT {
// if the list was empty:
if (sizeof(v_EPTF_Var_varsToUpdate)<=1) {
// add the first element to the list, 0-th item is the headIdx
v_EPTF_Var_varsToUpdate := {1,pl_idx};
return;
}
var integer vl_headIdx := v_EPTF_Var_varsToUpdate[0];
for(var integer i:=sizeof(v_EPTF_Var_varsToUpdate)-1; i>0;i:=i-1) {
if (v_EPTF_Var_varsToUpdate[i]==pl_idx and vl_headIdx<=i) {
return; // already in the list
}
}
var integer vl_currentPos := sizeof(v_EPTF_Var_varsToUpdate);
for(var integer i:=sizeof(v_EPTF_Var_varsToUpdate)-1; i>0;i:=i-1) {
if (v_EPTF_Var_varsToUpdate[i]>pl_idx and vl_headIdx<=i) {
// move old item one position back:
v_EPTF_Var_varsToUpdate[vl_currentPos] := v_EPTF_Var_varsToUpdate[i];
vl_currentPos := i;
} else {
// position found, insert new element there:
v_EPTF_Var_varsToUpdate[vl_currentPos] := pl_idx;
return;
}
}
// position found, insert new element to the first place:
v_EPTF_Var_varsToUpdate[vl_currentPos] := pl_idx;
}
// removes the head element from v_EPTF_Var_varsToUpdate, returns its value
private function f_EPTF_Var_getVarToUpdate() runs on EPTF_Var_CT return integer {
if (sizeof(v_EPTF_Var_varsToUpdate)==0) {
// if empty:
v_EPTF_Var_varsToUpdate := {0}; // empty
return -1;
}
if (v_EPTF_Var_varsToUpdate[0]==0) {
// empty:
return -1;
}
var integer vl_headIdx := v_EPTF_Var_varsToUpdate[0];
v_EPTF_Var_varsToUpdate[0] := vl_headIdx+1;
var integer vl_idx := v_EPTF_Var_varsToUpdate[vl_headIdx];
// reset the structure automatically if last element is removed:
if (v_EPTF_Var_varsToUpdate[0]==sizeof(v_EPTF_Var_varsToUpdate)) {
v_EPTF_Var_varsToUpdate := {};
}
return vl_idx;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_notifySubscriber
//
// Purpose:
// Notifies the pl_subscriberIdx-th subscriber of pl_idx about the new value of the content.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_notifySubscriber(in EPTF_Var_Subscriber pl_subscriber, in EPTF_Var_DirectContent pl_contentNew) runs on EPTF_Var_CT {
if(ischosen(pl_subscriber.local)) {
// subscriber is local
var integer vl_idx := pl_subscriber.local;
f_EPTF_Var_addVarToUpdate(vl_idx);
return;
}
if(ischosen(pl_subscriber.remote)) {
// if buffered: do not notify
if (pl_subscriber.remote.subscriptionMode == sampled or pl_subscriber.remote.subscriptionMode == sampledAtSync or pl_subscriber.remote.subscriptionMode == timeLine) {
return; // nothing to do
}
f_EPTF_Var_send(
{refreshContent:={
pl_subscriber.remote.varRef,pl_contentNew}},
pl_subscriber.remote.varRef.compRef);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_checkRemoteSubscriber
//
// Purpose:
// Checks if the given remote variable is really a subscriber (needed by the handleAdjustContentNack function)
///////////////////////////////////////////////////////////
private function f_EPTF_Var_checkRemoteSubscriber(in integer pl_idx, in EPTF_Var_Ref pl_subscriberVar) runs on EPTF_Var_CT return boolean {
for (var integer i:=0; i<sizeof(v_EPTF_Vars[pl_idx].subscribers); i:=i+1) {
if (ischosen(v_EPTF_Vars[pl_idx].subscribers[i].remote)) {
if (v_EPTF_Vars[pl_idx].subscribers[i].remote.varRef==pl_subscriberVar) {
return true;
}
}
}
return false;
}
// TIMELINE
// SYNC BUFFER TIMER
function f_EPTF_Var_syncTimeoutHandler(
in EPTF_ScheduledAction pl_action, in integer pl_eventIndex
) runs on EPTF_Var_CT return boolean {
var integer vl_refreshRateId := pl_action.actionId[0];
var float vl_syncInterval := v_syncInterval;
if (vl_refreshRateId>0) {
vl_syncInterval := int2float(v_syncBuffer[vl_refreshRateId].refreshRate)*v_minSyncInterval
}
f_EPTF_Var_handle_syncTimeout(vl_refreshRateId);
//action("Event rescheduled for vl_refreshRate: ", v_syncBuffer[vl_refreshRateId].refreshRate, " with period: ",vl_syncInterval);
//action("v_EPTF_Vars: ", v_EPTF_Vars);
if (f_EPTF_SchedulerComp_scheduleAction(
pl_when := pl_action.when+vl_syncInterval,
pl_actionHandler := pl_action.actionHandler,
pl_action := {vl_refreshRateId},
pl_eventIndex := v_syncBuffer[vl_refreshRateId].eventIdx
)){/*remove the warning*/};
return true;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_syncTimeout
//
// Purpose:
// Handler for sync timer
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_syncTimeout(in integer pl_refreshRateId := 0) runs on EPTF_Var_CT {
// call the syncCallback functions:
f_EPTF_Var_callSyncCallBackFns(c_EPTF_Var_syncBegin,pl_refreshRateId);
// send timeLines
var EPTF_Var_TimeLineList vl_refreshTimeLineList;
var float vl_timestamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime());
for(var integer i:=0; i<sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].remoteCompRef!=null) {
vl_refreshTimeLineList := {};
for(var integer j:=0; j<sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData); j:=j+1) {
var integer vl_varIdx := v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].localIdx;
if (ischosen(v_EPTF_Vars[vl_varIdx].provider.remote)
and v_EPTF_Vars[vl_varIdx].provider.remote.refreshRate == v_syncBuffer[pl_refreshRateId].refreshRate
and( (v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == sampled) or
(v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == sampledAtSync) or
(v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == timeLine) )) {
// if I am a buffered subscriber: timeLine is not sent for the provider's refreshRate!
// it was forwarded when the timeLine was received from the provider,
// since then it did not change
} else {
// find timeLine for the refreshRate:
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer ii := 0; ii<sizeof(v_EPTF_Vars[vl_varIdx].timeLineBuffer); ii:=ii+1) {
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[ii].refreshRateId == pl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := ii;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer!=-1) {
// there is timeline for this variable with this refreshRate
// only add to message if timeLine is not empty:
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size>0) {
// if subscription mode of the variable is timeLine
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == timeLine) {
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine
}
} else if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == sampled) {
// sampled: send only the last element in the timeLine:
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
{1,{v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.timeLineData[v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size-1]}}
}
}
}
}
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].subscriptionMode == sampledAtSync) {
// sampledAtSync: calcFn and prostProc-s are called for the variable and send only the current content:
var EPTF_Var_DirectContent vl_currentContent;
// f_EPTF_Var_refreshContent(vl_varIdx);
// f_EPTF_Var_getContent(vl_varIdx, vl_currentContent);
if (f_EPTF_Var_checkSubscriptionMode(vl_varIdx,pull)) {
f_EPTF_Var_getContent(vl_varIdx, vl_currentContent);
} else {
// store current content:
var EPTF_Var_DirectContent vl_prevContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_varIdx].content,vl_prevContent);//f_EPTF_Var_getContent(vl_varIdx, vl_prevContent);
// call calcFn:
f_EPTF_Var_callCalcFn(vl_varIdx,vl_currentContent);
// update content for postProc functions:
f_EPTF_Var_setContent(vl_varIdx,vl_currentContent);
f_EPTF_Var_callPostProcFns(vl_varIdx);
// postProc may update the content, so reread current content:
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_varIdx].content,vl_currentContent);//f_EPTF_Var_getContent(vl_varIdx, vl_currentContent);
// restore the original content:
f_EPTF_Var_setContent(vl_varIdx, vl_prevContent);
}
// if (ischosen(v_EPTF_Vars[vl_varIdx].provider.local)) {
// f_EPTF_Var_callCalcFn(vl_varIdx,vl_currentContent);
// } else {
// f_EPTF_Var_getContent(vl_varIdx, vl_currentContent);
// }
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].prevContent != vl_currentContent) {
vl_refreshTimeLineList[sizeof(vl_refreshTimeLineList)] := {
v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].remoteIdx,
{1,{{vl_timestamp,vl_currentContent}}}
}
// store current value for sampledAtSync
v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].prevContent := vl_currentContent;
}
}
}
}
// no 'if' needed: send empty message in case of no change
if (tsp_EPTF_Var_enableEmptyTimeLine or sizeof(vl_refreshTimeLineList)>0) {
f_EPTF_Var_send(
{refreshTimeLines := {v_syncBuffer[pl_refreshRateId].refreshRate, v_syncBuffer[pl_refreshRateId].syncBuffer[i].flushCounter, vl_refreshTimeLineList}},
v_syncBuffer[pl_refreshRateId].syncBuffer[i].remoteCompRef
);
// increase the counter:
v_syncBuffer[pl_refreshRateId].syncBuffer[i].flushCounter := v_syncBuffer[pl_refreshRateId].syncBuffer[i].flushCounter+1;
}
}
}
// reset timeLines:
for(var integer i:=0; i<sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer); i:=i+1) {
if (v_syncBuffer[pl_refreshRateId].syncBuffer[i].remoteCompRef!=null) {
for(var integer j:=0; j<sizeof(v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData); j:=j+1) {
var integer vl_varIdx := v_syncBuffer[pl_refreshRateId].syncBuffer[i].compBufferData[j].localIdx;
if (ischosen(v_EPTF_Vars[vl_varIdx].provider.remote)
and v_EPTF_Vars[vl_varIdx].provider.remote.refreshRate == v_syncBuffer[pl_refreshRateId].refreshRate
and( (v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == sampled) or
(v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == sampledAtSync) or
(v_EPTF_Vars[vl_varIdx].provider.remote.subscriptionMode == timeLine) )) {
// if I am a buffered subscriber: timeLine is not reset!
} else {
// find timeLine for the refreshRate:
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer ii := 0; ii<sizeof(v_EPTF_Vars[vl_varIdx].timeLineBuffer); ii:=ii+1) {
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[ii].refreshRateId == pl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := ii;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer!=-1) {
// there is timeline for this variable with this refreshRate
// only reset timeLine if timeLine is not empty:
if (v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine.size>0) {
v_EPTF_Vars[vl_varIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine := {0,{}};
}
}
}
}
}
}
// call the syncCallback functions:
f_EPTF_Var_callSyncCallBackFns(c_EPTF_Var_syncEnd,pl_refreshRateId);
}
//***************************************************************************************************
// altsteps
//***************************************************************************************************
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_lookupName
//
// Purpose:
// Returns the idx of the EPTF Variable with the given name
// returns -1 if not found
///////////////////////////////////////////////////////////
private function f_EPTF_Var_lookupName(in charstring pl_varName) runs on EPTF_Var_CT return integer {
for(var integer i:=0; i<sizeof(v_EPTF_Vars); i:=i+1) {
if (v_EPTF_Vars[i].name == pl_varName) {
return i;
}
}
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_lookupCompRef
//
// Purpose:
// Returns the idx of the EPTF Variable that refers to the given reference.
// -1 is retured if no variable found.
///////////////////////////////////////////////////////////
private function f_EPTF_Var_lookupCompRef(in EPTF_Var_ReferencedContent pl_compRef) runs on EPTF_Var_CT return integer {
//log("pl_compRef: ", pl_compRef);
for(var integer i:=0; i<sizeof(v_EPTF_Vars); i:=i+1) {
//log("v_EPTF_Vars[i].content.reference: ",v_EPTF_Vars[i].content.reference);
if (ischosen(v_EPTF_Vars[i].content.reference) and
v_EPTF_Vars[i].content.reference == pl_compRef) {
return i;
}
}
return -1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_Subscribe
//
// Purpose:
// Handles the received subscribe message
// is registers the new subscriber for the provider
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_Subscribe(in EPTF_Var_Msg_Subscribe pl_subscribe) runs on EPTF_Var_CT {
var EPTF_Var_Ref vl_subscriber := pl_subscribe.subscriber;
var charstring vl_providerVarName := pl_subscribe.providerVarName;
var EPTF_Var_SubscriptionMode vl_subscriptionMode := pl_subscribe.subscriptionMode;
var integer vl_refreshRate := pl_subscribe.refreshRate;
var integer vl_refreshRateId := -1;
var EPTF_Var_CT vl_remoteCompRef := vl_subscriber.compRef;
var integer vl_compBufferIdx;
f_EPTF_Var_checkConnection(vl_remoteCompRef,vl_refreshRate,vl_refreshRateId,vl_compBufferIdx);
// newRefreshRate event is needed if vl_refreshRateId!=0 (not default), but not found in database (==-1)
var boolean vl_needNewRefreshRate := (vl_refreshRateId==-1 and vl_subscriptionMode != pull);
// if not connected:
if (vl_compBufferIdx==-1) {
f_EPTF_Var_registerConnection(vl_remoteCompRef,vl_refreshRate,vl_refreshRateId,vl_compBufferIdx);
}
if (vl_needNewRefreshRate) {
//action("Event scheduled for vl_refreshRate: ", vl_refreshRate, " with period: ",int2float(vl_refreshRate)*v_minSyncInterval);
if(f_EPTF_SchedulerComp_scheduleAction(
pl_when := f_EPTF_Base_getRelTimeInSecs()+int2float(vl_refreshRate)*v_minSyncInterval,
pl_actionHandler := refers(f_EPTF_Var_syncTimeoutHandler),
pl_action := {vl_refreshRateId},
pl_eventIndex := v_syncBuffer[vl_refreshRateId].eventIdx
)) {/*remove the warning*/};
}
// generate auto-name:
var charstring vl_subscriberVarName := pl_subscribe.subscriberVarName;
if (vl_subscriberVarName == "") {
vl_subscriberVarName := f_EPTF_Base_selfName() & "." & vl_providerVarName;
}
var integer vl_myIdx := f_EPTF_Var_getId(vl_providerVarName);
if (vl_myIdx<0) {
// send invalid resp
// send vl_providerVarName instead of vl_subscriberVarName: this is the name of the variable that is not found
vl_subscriberVarName := vl_providerVarName & " (subscribed name: " & vl_subscriberVarName & ")"
f_EPTF_Var_send({subscribeResp := {vl_subscriberVarName, vl_subscriber,{self,vl_myIdx}, 0.0, omit, empty, pl_subscribe.blockingFlagIdx, false}}, vl_remoteCompRef);
return;
}
if (vl_subscriptionMode == sampled or vl_subscriptionMode == sampledAtSync or vl_subscriptionMode == timeLine) {
f_EPTF_Var_registerBufferedVar(vl_myIdx, vl_subscriber.idx, vl_subscriptionMode, vl_refreshRateId, vl_compBufferIdx);
}
if (vl_subscriptionMode != pull) {
f_EPTF_Var_addRemoteSubscriber(vl_myIdx, {vl_subscriberVarName,vl_subscriber,vl_subscriptionMode, vl_refreshRateId});
}
var EPTF_TopProviderType vl_topProviderType;
f_EPTF_Var_getTopProviderType(vl_myIdx, vl_topProviderType);
var EPTF_Var_DirectContent vl_providerDirectContent := {unknownVal := {omit}}; // this is sent if subscription needs to be changed to pull mode
if (vl_subscriptionMode != pull and not (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull) or f_EPTF_Var_checkLocalSubscriptionMode(vl_myIdx,pull))) {
// content is only sent if not pull mode subscription and I am not a pull mode subscriber and not pull mode local subscriber
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_myIdx].content,vl_providerDirectContent);
//f_EPTF_Var_getContent(vl_myIdx, vl_providerDirectContent);
}
var EPTF_Var_Ref vl_provider := {self,vl_myIdx};
// if I am a pull subscriber, replace myself with my provider:
// TODO: replace myself always if I am a subscriber?
if (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull)) {
vl_provider := v_EPTF_Vars[vl_myIdx].provider.remote.varRef; // replace myself with my provider
}
f_EPTF_Var_send({subscribeResp := {
vl_subscriberVarName,
vl_subscriber,
vl_provider,
f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime()),
vl_providerDirectContent,
vl_topProviderType,
pl_subscribe.blockingFlagIdx,
v_EPTF_Vars[vl_myIdx].subsCanAdjust
}}, vl_remoteCompRef);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_registerBufferedVar
//
// Purpose:
// Adds the pl_idx variable to the compBuffer (if not already added)
// also initializes the timeLineBuffer of v_EPTF_Var[pl_idx]
// pl_remoteIdx is the index of the subscriber on the remote component, pl_subscriptionMode is the subscription mode
///////////////////////////////////////////////////////////
private function f_EPTF_Var_registerBufferedVar(in integer pl_idx, in integer pl_remoteIdx, in EPTF_Var_SubscriptionMode pl_subscriptionMode, in integer pl_refreshRateId, in integer pl_compBufferIdx) runs on EPTF_Var_CT {
var integer vl_syncBufferIdx;
if (f_EPTF_str2int_HashMap_Find(v_EPTF_Var_Hashmap_SyncBuffer,log2str(pl_idx,".",pl_remoteIdx,".",pl_refreshRateId,".",pl_compBufferIdx),vl_syncBufferIdx)) {
return; // already in the compBuffer
}
var integer vl_refreshRateId := pl_refreshRateId;
vl_syncBufferIdx := sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData);
v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData[vl_syncBufferIdx] := {
localIdx := pl_idx,
remoteIdx := pl_remoteIdx,
subscriptionMode := pl_subscriptionMode,
prevContent := omit
}
f_EPTF_str2int_HashMap_Insert(v_EPTF_Var_Hashmap_SyncBuffer,log2str(pl_idx,".",pl_remoteIdx,".",pl_refreshRateId,".",pl_compBufferIdx),vl_syncBufferIdx);
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer i := 0; i<sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer); i:=i+1) {
if (v_EPTF_Vars[pl_idx].timeLineBuffer[i].refreshRateId == vl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := i;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer==-1) {
vl_refreshRateIdInTimeLineBuffer := sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer);
}
if (sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer) <= vl_refreshRateIdInTimeLineBuffer) {
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].refreshRateId := vl_refreshRateId;
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum := 0;
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine := {
size := 0,
//It's always continuous.
timeLineData := {}
};
}
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum := v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum + 1;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_deregisterBufferedVar
//
// Purpose:
// Removes the pl_idx variable from the compBuffer (if not already removed)
///////////////////////////////////////////////////////////
private function f_EPTF_Var_deregisterBufferedVar(in integer pl_idx, in integer pl_refreshRateId, in integer pl_compBufferIdx) runs on EPTF_Var_CT {
var integer vl_refreshRateId := pl_refreshRateId;
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer i := 0; i<sizeof(v_EPTF_Vars[pl_idx].timeLineBuffer); i:=i+1) {
if (v_EPTF_Vars[pl_idx].timeLineBuffer[i].refreshRateId == vl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := i;
break;
}
}
if(vl_refreshRateIdInTimeLineBuffer!=-1) {
// timeline exists for this refresh rate in this variable
v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum := v_EPTF_Vars[pl_idx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum - 1;
}
var EPTF_Var_CompBufferData vl_old_EPTF_Var_CompBufferData := v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData;
v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData := {};
for (var integer i:=0; i< sizeof(vl_old_EPTF_Var_CompBufferData); i:=i+1) {
if (vl_old_EPTF_Var_CompBufferData[i].localIdx != pl_idx) {
v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData[sizeof(v_syncBuffer[vl_refreshRateId].syncBuffer[pl_compBufferIdx].compBufferData)] := vl_old_EPTF_Var_CompBufferData[i];
} else {
var integer vl_remoteIdx := vl_old_EPTF_Var_CompBufferData[i].remoteIdx;
f_EPTF_str2int_HashMap_Erase(v_EPTF_Var_Hashmap_SyncBuffer,log2str(pl_idx,".",vl_remoteIdx,".",pl_refreshRateId,".",pl_compBufferIdx));
}
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_Unsubscribe
//
// Purpose:
// Handler for Unsubscribe message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_Unsubscribe(in EPTF_Var_Msg_Unsubscribe pl_unsubscribe) runs on EPTF_Var_CT {
var EPTF_Var_Ref vl_subscriber := pl_unsubscribe.subscriber;
var EPTF_Var_Ref vl_provider := pl_unsubscribe.provider;
var EPTF_Var_SubscriptionMode vl_subscriptionMode := pl_unsubscribe.subscriptionMode;
var integer vl_refreshRate := pl_unsubscribe.refreshRate;
var integer vl_refreshRateId := -1;
var EPTF_Var_CT vl_remoteCompRef := vl_subscriber.compRef;
var integer vl_compBufferIdx;
f_EPTF_Var_checkConnection(vl_remoteCompRef,vl_refreshRate,vl_refreshRateId,vl_compBufferIdx);
// if not connected:
if (vl_compBufferIdx==-1) {
// this can never happen
f_EPTF_Var_error(log2str("SyncBuffer does not contain data for component ", vl_remoteCompRef));
//f_EPTF_Base_stop();
}
if (vl_subscriptionMode == sampled or vl_subscriptionMode == sampledAtSync or vl_subscriptionMode == timeLine) {
f_EPTF_Var_deregisterBufferedVar(vl_provider.idx, vl_refreshRateId, vl_compBufferIdx);
}
f_EPTF_Var_removeRemoteSubscriber(vl_provider.idx, vl_subscriber);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_RefreshContent
//
// Purpose:
// Handler for RefreshContent message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_RefreshContent(in EPTF_Var_Msg_RefreshContent pl_refreshContent) runs on EPTF_Var_CT {
var integer vl_myIdx := pl_refreshContent.subscriber.idx;
if (ischosen(v_EPTF_Vars[vl_myIdx].content.invalid)) {
// this can never happen
v_EPTF_Vars[vl_myIdx].content := { direct := pl_refreshContent.content };
return;
}
// update current value
f_EPTF_Var_registerRefresh(vl_myIdx,pl_refreshContent.content);
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_AdjustContent
//
// Purpose:
// Handler for AdjustContent message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_AdjustContent(in EPTF_Var_Msg_AdjustContent pl_adjustContent) runs on EPTF_Var_CT {
var integer vl_myIdx := pl_adjustContent.provider.idx;
if (vl_myIdx==-1) {
// FIXME: this adjust should not have been sent
f_EPTF_Var_error(log2str("Adjust request ignored: invalid adjust received: ", pl_adjustContent));
return;
}
if (ischosen(v_EPTF_Vars[vl_myIdx].provider.local)) {
f_EPTF_Var_error(log2str("Cannot adjust the content of the EPTF_Var[",vl_myIdx,"]. It has a local provider! ",v_EPTF_Vars[vl_myIdx]," EPTF_Var_Msg_AdjustContent message dropped."));
//f_EPTF_Base_stop();
}
if (ischosen(v_EPTF_Vars[vl_myIdx].provider.empty)) {
// I am a "parameter", adjust allowed after the guard fns accept the new value.
// check if subsCanAdjust is true:
if(not v_EPTF_Vars[vl_myIdx].subsCanAdjust) {
// send adjustContentResp/failed to sender:
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_myIdx].content,vl_currentContent);
//f_EPTF_Var_getContent(vl_myIdx,vl_currentContent);
f_EPTF_Var_send(
{adjustContentResp:={ false, // adjust failed
pl_adjustContent.subscribers,vl_currentContent,pl_adjustContent.respHandlerId
}},
pl_adjustContent.subscribers.varList[pl_adjustContent.subscribers.lastIdx].compRef
);
return;
}
//call the guard fns:
var boolean vl_result := f_EPTF_Var_callGuardFns(vl_myIdx,pl_adjustContent.content);
if (not vl_result) {
// send adjustContentResp/failed to sender:
var EPTF_Var_DirectContent vl_currentContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_myIdx].content,vl_currentContent);
//f_EPTF_Var_getContent(vl_myIdx,vl_currentContent);
f_EPTF_Var_send(
{adjustContentResp:={ false, // adjust failed
pl_adjustContent.subscribers,vl_currentContent,pl_adjustContent.respHandlerId
}},
pl_adjustContent.subscribers.varList[pl_adjustContent.subscribers.lastIdx].compRef
);
} else {
f_EPTF_Var_send(
{adjustContentResp:={ true, // adjust successful
pl_adjustContent.subscribers,pl_adjustContent.content,pl_adjustContent.respHandlerId
}},
pl_adjustContent.subscribers.varList[pl_adjustContent.subscribers.lastIdx].compRef
);
// registerRefresh is called to notify subscribers:
f_EPTF_Var_registerRefresh(vl_myIdx,pl_adjustContent.content);
}
return;
}
if (ischosen(v_EPTF_Vars[vl_myIdx].provider.remote)) {
if (v_EPTF_Vars[vl_myIdx].provider.remote.varRef.idx<0) {
// subscription is in progress. Have to wait for response to execute the actual adjust:
// just store the new value now:
f_EPTF_Var_setContent(vl_myIdx, pl_adjustContent.content);
// flag this variable that adjust was buffered:
v_EPTF_Vars[vl_myIdx].provider.remote.varRef.idx := -2;
// refresh will be done when subscribeResp arrives
return;
}
// this replaces sender information, so the response will not be sent to the subscriber who originally requested the adjust:
//f_EPTF_Var_adjustContent(vl_myIdx,pl_adjustContent.content);
// forward adjust content for remote provider, but keep sender information:
var EPTF_Var_MessageRoute vl_route := pl_adjustContent.subscribers;
vl_route.lastIdx := vl_route.lastIdx + 1;
vl_route.varList[vl_route.lastIdx] := {self,vl_myIdx};
f_EPTF_Var_send(
{adjustContent:={
vl_route,
v_EPTF_Vars[vl_myIdx].provider.remote.varRef,
pl_adjustContent.content,pl_adjustContent.respHandlerId
}},
v_EPTF_Vars[vl_myIdx].provider.remote.varRef.compRef
);
}
return;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_AdjustContentResp
//
// Purpose:
// Handler for AdjustContentResp message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_AdjustContentResp(in EPTF_Var_Msg_AdjustContentResp pl_adjustContentResp) runs on EPTF_Var_CT {
var integer vl_lastIdx := pl_adjustContentResp.subscribers.lastIdx;
var integer vl_myIdx := pl_adjustContentResp.subscribers.varList[vl_lastIdx].idx;
if (vl_lastIdx==0) {
// end of route reached
// the value of the content should not be changed, refreshContent will do it later
// if (pl_adjustContentResp.result == false) {
// // for failed adjust content is only updated if it has changed:
// var EPTF_Var_DirectContent vl_currentContent;
// f_EPTF_Var_getContent(vl_myIdx,vl_currentContent);
//
// // if received value is different from current:
// if (vl_currentContent!=pl_adjustContentResp.content) {
// // update current value
// f_EPTF_Var_registerRefresh(vl_myIdx,pl_adjustContentResp.content);
// }
// // if received value is the same as the current, no refresh is
// // needed, because the original value was not changed,
// // this response is for a failed adjust
// // (failed adjusts cannot trigger refresh)
// }
// call the user handler:
if (pl_adjustContentResp.respHandlerId != -1) {
// find handler data in the stack:
var EPTF_Var_adjustContentResp_handler vl_respHandler;
if (f_EPTF_getEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_adjustContentResp.respHandlerId,vl_respHandler)) {
// call the user handler (cannot be null: for null the respHandlerId was set to -1):
vl_respHandler.handlerFn.apply(vl_myIdx, pl_adjustContentResp.content, pl_adjustContentResp.result, vl_respHandler.argList);
// release the stack:
f_EPTF_deleteEPTF_Var_adjustContentResp_handler(adjustContentResp_handler_ParamStack,pl_adjustContentResp.respHandlerId);
} else {
// this is never called (just to remove the warning):
f_EPTF_Var_error("Callback function not found. Database error!");
//f_EPTF_Base_stop();
}
}
} else {
// Forward the message to the previous subscriber:
vl_lastIdx := vl_lastIdx-1;
//check if there the previous subscriber is still a subscriber (he might have unsubscribed):
var boolean vl_stillSubscribed := f_EPTF_Var_checkRemoteSubscriber(vl_myIdx,pl_adjustContentResp.subscribers.varList[vl_lastIdx]);
if (vl_stillSubscribed) {
f_EPTF_Var_send(
{adjustContentResp:={ pl_adjustContentResp.result,
{pl_adjustContentResp.subscribers.varList,vl_lastIdx},
pl_adjustContentResp.content,pl_adjustContentResp.respHandlerId
}},
pl_adjustContentResp.subscribers.varList[vl_lastIdx].compRef
);
} else {
f_EPTF_Var_warning(log2str("Cannot forward adjustcontentNack to variable",pl_adjustContentResp.subscribers.varList[vl_lastIdx],". Not a subscriber of EPTF_Var[",vl_myIdx,"]"));
}
return;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_GetRemoteContent
//
// Purpose:
// Handler for GetRemoteContent message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_GetRemoteContent(in EPTF_Var_Msg_GetRemoteContent pl_getRemoteContent, in EPTF_Var_CT pl_senderCompRef) runs on EPTF_Var_CT {
var integer vl_compBufferIdx;
var integer vl_refreshRateId := 0;
// if not connected:
if (not f_EPTF_Var_isConnected(pl_senderCompRef)) {
// use 0 for refreshRate and refreshRateId: default
f_EPTF_Var_registerConnection(pl_senderCompRef,vl_refreshRateId,vl_refreshRateId,vl_compBufferIdx);
}
var integer vl_myIdx;
if (ischosen(pl_getRemoteContent.varId.name)) {
vl_myIdx := f_EPTF_Var_getId(pl_getRemoteContent.varId.name);
} else {
vl_myIdx := pl_getRemoteContent.varId.idx;
}
if (vl_myIdx<0) {
f_EPTF_Var_warning(log2str("EPTF_Var_Msg_GetRemoteContent is received for a nonexistent EPTF Variable: ", pl_getRemoteContent.varId));
f_EPTF_Var_send({getRemoteContentResp := {omit, omit,omit,pl_getRemoteContent.blockingFlagIdx,pl_getRemoteContent.responseIdx}}, pl_senderCompRef);
return;
}
// request original provider if getRemoteContent uses name
if (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull) and ischosen(pl_getRemoteContent.varId.name)) {
v_EPTF_Vars[vl_myIdx].provider.remote.routeUpdateCounter := cg_EPTF_Var_routeUpdatePeriod;
}
var EPTF_Var_DirectContent vl_providerDirectContent;
if (ischosen(v_EPTF_Vars[vl_myIdx].provider.local) and not f_EPTF_Var_checkLocalSubscriptionMode(vl_myIdx,pull)) {
// in case of pull, it will be updated in f_EPTF_Var_getContent
//f_EPTF_Var_refreshContent(vl_myIdx); without registerRefresh:
var EPTF_Var_DirectContent vl_prevContent;
f_EPTF_Var_content2direct(v_EPTF_Vars[vl_myIdx].content,vl_prevContent);
f_EPTF_Var_callCalcFn(vl_myIdx,vl_providerDirectContent);
if (vl_prevContent!=vl_providerDirectContent) {
f_EPTF_Var_setContent(vl_myIdx,vl_providerDirectContent);
f_EPTF_Var_updateTimeLine(vl_myIdx,vl_providerDirectContent);
f_EPTF_Var_callPostProcFns(vl_myIdx);
}
} else {
f_EPTF_Var_getContent(vl_myIdx, vl_providerDirectContent);
}
var EPTF_Var_Msg_GetRemoteContentResp vl_getRemoteContentResp := {
omit, vl_providerDirectContent,v_EPTF_Vars[vl_myIdx].subsCanAdjust,pl_getRemoteContent.blockingFlagIdx,pl_getRemoteContent.responseIdx
}
// re-route pull subscription:
if (ischosen(pl_getRemoteContent.varId.name)) {
vl_getRemoteContentResp.provider := {self,vl_myIdx}
}
if (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull)
and v_EPTF_Vars[vl_myIdx].provider.remote.varRef.idx != -1
) {
vl_getRemoteContentResp.provider := v_EPTF_Vars[vl_myIdx].provider.remote.varRef; // replace myself with my provider
}
f_EPTF_Var_send({getRemoteContentResp := vl_getRemoteContentResp}, pl_senderCompRef);
}
///////////////////////////////////////////////////////////
// Function: as_EPTF_Var_handle_AdjustContentResp
//
// Purpose:
// Waits for a positive or negative response for an adjust to the given varibale with the given content,
// returns true if adjust successful, else false
///////////////////////////////////////////////////////////
private altstep as_EPTF_Var_handle_AdjustContentResp(in integer pl_idx, in EPTF_Var_DirectContent pl_content, out boolean pl_result) runs on EPTF_Var_CT {
var EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg;
var EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender;
[] EPTF_Var_MgmtIf.receive({adjustContentResp:={?,{?,0},pl_content,?}}) -> value vl_EPTF_Var_MgmtIf_msg sender vl_EPTF_Var_MgmtIf_msg_sender {
pl_result := vl_EPTF_Var_MgmtIf_msg.adjustContentResp.result;
f_EPTF_Var_handle_AdjustContentResp(vl_EPTF_Var_MgmtIf_msg.adjustContentResp);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_adjustRemoteContentResp_handler
//
// Purpose:
// Handler function for adjustRemoteContent in f_EPTF_Var_handle_AdjustRemoteContent to send EPTF_Var_Msg_AdjustRemoteContentResp,
// pl_argList[0]: pl_senderCompRef converted to integer,
// pl_argList[1]: the respHandlerId of the user callback function
///////////////////////////////////////////////////////////
private function f_EPTF_Var_adjustRemoteContentResp_handler(in integer pl_idx, in EPTF_Var_DirectContent pl_content,in boolean pl_result, in EPTF_IntegerList pl_argList) runs on EPTF_Var_CT {
var EPTF_Var_CT pl_senderCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(pl_argList[0]));
if (pl_argList[1] != -1 or pl_argList[2] != -1) {
// if there is a handler or blocking
f_EPTF_Var_send({adjustRemoteContentResp := {{{idx:=pl_idx},pl_content,pl_argList[1],pl_argList[2],pl_argList[3]},pl_result}}, pl_senderCompRef);
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_AdjustRemoteContent
//
// Purpose:
// Handler function for AdjustRemoteContent message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_AdjustRemoteContent(in EPTF_Var_Msg_AdjustRemoteContent pl_adjustRemoteContent, in EPTF_Var_CT pl_senderCompRef) runs on EPTF_Var_CT {
var integer vl_compBufferIdx;
var integer vl_refreshRateId := 0;
// if not connected:
if (not f_EPTF_Var_isConnected(pl_senderCompRef)) {
// use 0 for refreshRate and refreshRateId: default
f_EPTF_Var_registerConnection(pl_senderCompRef,vl_refreshRateId,vl_refreshRateId,vl_compBufferIdx);
}
var integer vl_myIdx;
if (ischosen(pl_adjustRemoteContent.varId.name)) {
vl_myIdx := f_EPTF_Var_getId(pl_adjustRemoteContent.varId.name);
} else {
vl_myIdx := pl_adjustRemoteContent.varId.idx;
}
if (vl_myIdx<0) {
f_EPTF_Var_warning(log2str("EPTF_Var_Msg_AdjustRemoteContent received for a nonexistent EPTF Variable: ", pl_adjustRemoteContent.varId));
f_EPTF_Var_send({adjustRemoteContentResp := {pl_adjustRemoteContent,false}}, pl_senderCompRef);
return;
}
// need to check topProviderType, so that f_EPTF_Var_adjustContent_Blocking would not fail:
var EPTF_TopProviderType vl_topProviderType;
f_EPTF_Var_getTopProviderType(vl_myIdx, vl_topProviderType);
if (vl_topProviderType == local) {
f_EPTF_Var_warning(log2str("EPTF_Var_Msg_AdjustRemoteContent received for an EPTF Variable with local top-provider: ", vl_myIdx));
f_EPTF_Var_send({adjustRemoteContentResp := {pl_adjustRemoteContent,false}}, pl_senderCompRef);
return;
}
// request original provider if adjustRemoteContent uses name
if (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,pull) and ischosen(pl_adjustRemoteContent.varId.name)) {
v_EPTF_Vars[vl_myIdx].provider.remote.routeUpdateCounter := cg_EPTF_Var_routeUpdatePeriod;
}
f_EPTF_Var_adjustContent(vl_myIdx, pl_adjustRemoteContent.content, { refers(f_EPTF_Var_adjustRemoteContentResp_handler),
{f_EPTF_Base_upcast(pl_senderCompRef),pl_adjustRemoteContent.respHandlerId,pl_adjustRemoteContent.blockingFlagIdx,pl_adjustRemoteContent.responseIdx} });
// // blocks execution until response arrives:
// var boolean vl_result := f_EPTF_Var_adjustContent_Blocking(vl_myIdx, pl_adjustRemoteContent.content);
//
// if (vl_result) {
// f_EPTF_Var_send({adjustRemoteContentResp := {pl_adjustRemoteContent,true}}, pl_senderCompRef);
// } else {
// f_EPTF_Var_send({adjustRemoteContentResp := {pl_adjustRemoteContent,false}}, pl_senderCompRef);
// }
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_SetSubsCanAdjust
//
// Purpose:
// Handler function for EPTF_Var_Msg_SetSubsCanAdjust message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_SetSubsCanAdjust(in EPTF_Var_Msg_SetSubsCanAdjust pl_setSubsCanAdjust) runs on EPTF_Var_CT {
var integer vl_myidx := pl_setSubsCanAdjust.subscriber.idx;
v_EPTF_Vars[vl_myidx].subsCanAdjust := pl_setSubsCanAdjust.subsCanAdjust;
f_EPTF_Var_callSubsCanAdjustNotifyFns(vl_myidx);
f_EPTF_Var_setSubsCanAdjustInAllSubscribers(vl_myidx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_Hello
//
// Purpose:
// Handler function for Hello message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_Hello(in EPTF_Var_Msg_Hello pl_hello, in EPTF_Var_CT pl_EPTF_Var_MgmtIf_msg_sender) runs on EPTF_Var_CT {
// register the connection
var integer vl_compBufferIdx;
var integer vl_refreshRateId := 0;
// if not connected register the connection:
if (not f_EPTF_Var_isConnected(pl_EPTF_Var_MgmtIf_msg_sender)) {
// use 0 for refreshRate and refreshRateId: default
f_EPTF_Var_registerConnection(pl_EPTF_Var_MgmtIf_msg_sender,vl_refreshRateId,vl_refreshRateId,vl_compBufferIdx);
}
// send helloAck:
f_EPTF_Var_send({helloAck:={pl_hello.trId}},pl_EPTF_Var_MgmtIf_msg_sender);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_HelloAck
//
// Purpose:
// Handler function for HelloAck message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_HelloAck(in EPTF_Var_Msg_HelloAck pl_helloAck, in EPTF_Var_CT pl_EPTF_Var_MgmtIf_msg_sender) runs on EPTF_Var_CT {
var integer vl_trId := pl_helloAck.trId;
// disable blocking if it was requested:
if (vl_trId != -1) {
f_EPTF_setValueboolean(v_booleanPool,vl_trId,true);
v_EPTF_Var_numPendingHellos := v_EPTF_Var_numPendingHellos - 1;
var integer vl_refreshRateId := 0;
var integer vl_compBufferIdx;
// if not connected:
if (not f_EPTF_Var_isConnected(pl_EPTF_Var_MgmtIf_msg_sender)) {
// only register the connection if the connection setup was successful
// use 0 for refreshRate and refreshRateId: default
f_EPTF_Var_registerConnection(pl_EPTF_Var_MgmtIf_msg_sender,vl_refreshRateId,vl_refreshRateId,vl_compBufferIdx);
}
}
// call HelloAck response handler in case of nonblocking mode
var integer vl_idx := f_EPTF_Base_upcast(pl_EPTF_Var_MgmtIf_msg_sender);
if(isbound(v_EPTF_Var_nonBlockingEnabled[vl_idx]) and v_EPTF_Var_nonBlockingEnabled[vl_idx]){
f_EPTF_Var_connectCallback(pl_EPTF_Var_MgmtIf_msg_sender);
v_EPTF_Var_nonBlockingEnabled[vl_idx] := false;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_Bye
//
// Purpose:
// Handler function for Bye message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_Bye(in EPTF_Var_CT pl_EPTF_Var_MgmtIf_msg_sender) runs on EPTF_Var_CT {
for(var integer i:=0; i<sizeof(v_EPTF_Vars); i:=i+1) {
// remove all remote providers with compRef == sender:
if (ischosen(v_EPTF_Vars[i].provider.remote)) {
if (v_EPTF_Vars[i].provider.remote.varRef.compRef == pl_EPTF_Var_MgmtIf_msg_sender
or v_EPTF_Vars[i].provider.remote.compRef == pl_EPTF_Var_MgmtIf_msg_sender) {
v_EPTF_Vars[i].provider := {empty:={}};
f_EPTF_Var_callUnsubscribeNotifyFns(i);
}
}
// remove all remote subscribers with compRef == sender:
var EPTF_Var_Subscribers vl_oldSubscribers := v_EPTF_Vars[i].subscribers;
var integer vl_last := sizeof(vl_oldSubscribers);
v_EPTF_Vars[i].subscribers := {};
for (var integer j:=0; j<vl_last; j:=j+1) {
if (not (ischosen(vl_oldSubscribers[j].remote) and vl_oldSubscribers[j].remote.varRef.compRef == pl_EPTF_Var_MgmtIf_msg_sender) ) {
v_EPTF_Vars[i].subscribers[sizeof(v_EPTF_Vars[i].subscribers)] := vl_oldSubscribers[j]
} else {
// if remote subscriber is buffered:
if (vl_oldSubscribers[j].remote.subscriptionMode == sampled or vl_oldSubscribers[j].remote.subscriptionMode == sampledAtSync or vl_oldSubscribers[j].remote.subscriptionMode == timeLine) {
var integer vl_compBufferIdx;
var integer vl_refreshRate := v_syncBuffer[vl_oldSubscribers[j].remote.refreshRateId].refreshRate;
f_EPTF_Var_checkConnection(pl_EPTF_Var_MgmtIf_msg_sender,vl_refreshRate,vl_oldSubscribers[j].remote.refreshRateId,vl_compBufferIdx);
f_EPTF_Var_deregisterBufferedVar(i,vl_oldSubscribers[j].remote.refreshRateId,vl_compBufferIdx);
}
}
}
}
// send byeAck:
f_EPTF_Var_send({byeAck:={}},pl_EPTF_Var_MgmtIf_msg_sender);
// remove connection from syncBuffer:
f_EPTF_Var_deregisterConnection(pl_EPTF_Var_MgmtIf_msg_sender);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_ByeAck
//
// Purpose:
// Handler function for Byeack message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_ByeAck(in EPTF_Var_CT pl_EPTF_Var_MgmtIf_msg_sender) runs on EPTF_Var_CT return boolean {
disconnect(self:EPTF_Var_MgmtIf,pl_EPTF_Var_MgmtIf_msg_sender:EPTF_Var_MgmtIf);
v_EPTF_Var_pendingByeNum := v_EPTF_Var_pendingByeNum - 1;
// remove the connection from the database
var boolean vl_result := f_EPTF_Var_deregisterConnection(pl_EPTF_Var_MgmtIf_msg_sender);
if (vl_result == false and v_EPTF_Var_pendingByeNum != 0) {
vl_result := true; // there are unanswered bye messages
f_EPTF_Var_debug("There are unanswered bye messages, cannot exit yet.");
}
return vl_result;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_handle_RefreshTimeLines
//
// Purpose:
// Handler function for RefreshTimeLines message
///////////////////////////////////////////////////////////
private function f_EPTF_Var_handle_RefreshTimeLines(in EPTF_Var_Msg_RefreshTimeLines pl_refreshTimeLines) runs on EPTF_Var_CT {
var integer vl_myIdx;
var EPTF_Var_DirectContent vl_newContent;
var integer vl_refreshRateId := 0;
var integer vl_compBufferIdx;
f_EPTF_Var_checkConnection(null,pl_refreshTimeLines.refreshRate,vl_refreshRateId,vl_compBufferIdx);
if (vl_refreshRateId==-1) {
f_EPTF_Var_debug(%definitionId&": New refresh rate is registered: refresh rate is unknown: "&int2str(pl_refreshTimeLines.refreshRate));
f_EPTF_Var_registerConnection(
pl_remoteCompRef := null,
pl_refreshRate := pl_refreshTimeLines.refreshRate,
pl_refreshRateId := vl_refreshRateId,
pl_compBufferIdx := vl_compBufferIdx
);
//return;
}
var float vl_timeStamp := f_EPTF_Base_getAbsTimeInSecs(f_EPTF_SchedulerComp_snapshotTime());
for(var integer i:=0; i<sizeof(pl_refreshTimeLines.timeLineList); i:=i+1) {
vl_myIdx := pl_refreshTimeLines.timeLineList[i].idx;
// find the timeline for this refreshRate in the variable
var integer vl_refreshRateIdInTimeLineBuffer := -1;
for (var integer ii := 0; ii<sizeof(v_EPTF_Vars[vl_myIdx].timeLineBuffer); ii:=ii+1) {
if (v_EPTF_Vars[vl_myIdx].timeLineBuffer[ii].refreshRateId == vl_refreshRateId) {
vl_refreshRateIdInTimeLineBuffer := ii;
continue;
}
// timeLines for different refreshRate are concatenated for the varible:
v_EPTF_Vars[vl_myIdx].timeLineBuffer[ii].timeLine.size := v_EPTF_Vars[vl_myIdx].timeLineBuffer[ii].timeLine.size + pl_refreshTimeLines.timeLineList[i].timeLine.size;
v_EPTF_Vars[vl_myIdx].timeLineBuffer[ii].timeLine.timeLineData := v_EPTF_Vars[vl_myIdx].timeLineBuffer[ii].timeLine.timeLineData & pl_refreshTimeLines.timeLineList[i].timeLine.timeLineData;
}
// set the new timeline for the current refresRate:
if(vl_refreshRateIdInTimeLineBuffer!=-1) {
// timeline exists for this refresh rate in this variable
// update the timeLine
v_EPTF_Vars[vl_myIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine := pl_refreshTimeLines.timeLineList[i].timeLine;
} else {
// if I am a timeline subscriber:
// FIXME: timeLine needed for sampled also because UIHandlerWidgetFunctions uses it?
//if (f_EPTF_Var_checkSubscriptionMode(vl_myIdx,timeLine)) {
vl_refreshRateIdInTimeLineBuffer := sizeof(v_EPTF_Vars[vl_myIdx].timeLineBuffer);
v_EPTF_Vars[vl_myIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].refreshRateId := vl_refreshRateId;
v_EPTF_Vars[vl_myIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].bufferNum := 0;
v_EPTF_Vars[vl_myIdx].timeLineBuffer[vl_refreshRateIdInTimeLineBuffer].timeLine := pl_refreshTimeLines.timeLineList[i].timeLine;
//}
}
// new content is the last item in the timeLine:
vl_newContent := pl_refreshTimeLines.timeLineList[i].timeLine.timeLineData[pl_refreshTimeLines.timeLineList[i].timeLine.size-1].content;
// update current value
f_EPTF_Var_registerRefresh(vl_myIdx,vl_newContent,vl_timeStamp);
// send timeLine to buffered subscribers with same refreshRate
for(var integer j:=0; j<sizeof(v_EPTF_Vars[vl_myIdx].subscribers); j:=j+1) {
if (ischosen(v_EPTF_Vars[vl_myIdx].subscribers[j].remote) and
v_EPTF_Vars[vl_myIdx].subscribers[j].remote.refreshRateId == vl_refreshRateId and
(v_EPTF_Vars[vl_myIdx].subscribers[j].remote.subscriptionMode == sampled or
v_EPTF_Vars[vl_myIdx].subscribers[j].remote.subscriptionMode == sampledAtSync or
v_EPTF_Vars[vl_myIdx].subscribers[j].remote.subscriptionMode == timeLine) ) {
if (pl_refreshTimeLines.timeLineList[i].timeLine.size>0) {
f_EPTF_Var_send(
{refreshTimeLines := {
pl_refreshTimeLines.refreshRate, pl_refreshTimeLines.flushCounter,
{{v_EPTF_Vars[vl_myIdx].subscribers[j].remote.varRef.idx,pl_refreshTimeLines.timeLineList[i].timeLine}}
}},
v_EPTF_Vars[vl_myIdx].subscribers[j].remote.varRef.compRef
);
}
}
}
}
//action("After refresh: v_EPTF_Vars: ", v_EPTF_Vars);
// send timeLines to subscribers
//f_EPTF_Var_handle_syncTimeout();
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_mainHandler_MgmtIf
//
// Purpose:
// The main handler function of the EPTF_Var_MgmtIf.
// returns true if the repeat, false to exit from the main altsep
///////////////////////////////////////////////////////////
private function f_EPTF_Var_mainHandler_MgmtIf(
in EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg,
in EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender) runs on EPTF_Var_CT return boolean {
v_EPTF_Var_nofPendingMsgs := v_EPTF_Var_nofPendingMsgs - 1;
if (ischosen(vl_EPTF_Var_MgmtIf_msg.subscribe)) {
f_EPTF_Var_handle_Subscribe(vl_EPTF_Var_MgmtIf_msg.subscribe);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.isPresentRemote)) {
f_EPTF_Var_handle_IsPresentRemote(vl_EPTF_Var_MgmtIf_msg.isPresentRemote,vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.isPresentRemoteResp)) {
f_EPTF_Var_handle_IsPresentRemoteResp(vl_EPTF_Var_MgmtIf_msg.isPresentRemoteResp);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.subscribeResp)) {
f_EPTF_Var_handle_SubscribeResp(vl_EPTF_Var_MgmtIf_msg.subscribeResp, vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.unsubscribe)) {
f_EPTF_Var_handle_Unsubscribe(vl_EPTF_Var_MgmtIf_msg.unsubscribe);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.refreshContent)) {
f_EPTF_Var_handle_RefreshContent(vl_EPTF_Var_MgmtIf_msg.refreshContent);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.adjustContent)) {
f_EPTF_Var_handle_AdjustContent(vl_EPTF_Var_MgmtIf_msg.adjustContent);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.adjustContentResp)) {
f_EPTF_Var_handle_AdjustContentResp(vl_EPTF_Var_MgmtIf_msg.adjustContentResp);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.getRemoteContent)) {
f_EPTF_Var_handle_GetRemoteContent(vl_EPTF_Var_MgmtIf_msg.getRemoteContent, vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.adjustRemoteContent)) {
f_EPTF_Var_handle_AdjustRemoteContent(vl_EPTF_Var_MgmtIf_msg.adjustRemoteContent, vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.adjustRemoteContentResp)) {
f_EPTF_Var_handle_AdjustRemoteContentResp(vl_EPTF_Var_MgmtIf_msg.adjustRemoteContentResp);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.hello)) {
f_EPTF_Var_handle_Hello(vl_EPTF_Var_MgmtIf_msg.hello, vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.helloAck)) {
f_EPTF_Var_handle_HelloAck(vl_EPTF_Var_MgmtIf_msg.helloAck, vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.bye)) {
f_EPTF_Var_handle_Bye(vl_EPTF_Var_MgmtIf_msg_sender);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.byeAck)) {
if(not f_EPTF_Var_handle_ByeAck(vl_EPTF_Var_MgmtIf_msg_sender)) {
f_EPTF_Var_debug(log2str(%definitionId, ": all peers disconnected."));
}
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.refreshTimeLines)) {
f_EPTF_Var_handle_RefreshTimeLines(vl_EPTF_Var_MgmtIf_msg.refreshTimeLines);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.getRemoteContentResp)) {
f_EPTF_Var_handle_GetRemoteContentResp(vl_EPTF_Var_MgmtIf_msg.getRemoteContentResp);
return true;
}
if (ischosen(vl_EPTF_Var_MgmtIf_msg.setSubsCanAdjust)) {
f_EPTF_Var_handle_SetSubsCanAdjust(vl_EPTF_Var_MgmtIf_msg.setSubsCanAdjust);
return true;
}
f_EPTF_Var_error(log2str("Unexpected message received from ",vl_EPTF_Var_MgmtIf_msg_sender,": ",vl_EPTF_Var_MgmtIf_msg));
return false;
}
///////////////////////////////////////////////////////////
// Function: as_EPTF_Var_mainHandler_MgmtIf
//
// Purpose:
// The main handler of the EPTF_Var_MgmtIf.
///////////////////////////////////////////////////////////
private altstep as_EPTF_Var_mainHandler_MgmtIf() runs on EPTF_Var_CT {
var EPTF_Var_MgmtMsg vl_EPTF_Var_MgmtIf_msg;
var EPTF_Var_CT vl_EPTF_Var_MgmtIf_msg_sender;
[] EPTF_Var_MgmtIf.receive(?) -> value vl_EPTF_Var_MgmtIf_msg sender vl_EPTF_Var_MgmtIf_msg_sender {
if (f_EPTF_Var_mainHandler_MgmtIf(vl_EPTF_Var_MgmtIf_msg,vl_EPTF_Var_MgmtIf_msg_sender)) {repeat;}
}
[] as_EPTF_Var_refreshSubscribers();
[] as_EPTF_Var_Msg_Buffer_Handler();
}
group Logging {
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_error
//
// Purpose:
// Function to log an error from Variable feature.
//
// Parameters:
// - pl_message - *in* *charstring* - the message to log
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_error(in charstring pl_message)
runs on EPTF_Var_CT
{
f_EPTF_Logging_error(true, tsp_EPTF_Var_loggingComponentMask&": "&pl_message);
f_EPTF_Base_stopAll();
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_warning
//
// Purpose:
// Function to log a warning from Variable feature.
//
// Parameters:
// - pl_message - *in* *charstring* - the message to log
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_warning(in @lazy charstring pl_message)
runs on EPTF_Var_CT
{
f_EPTF_Logging_warningV2(pl_message, v_Var_loggingMaskId, {c_EPTF_Var_loggingClassIdx_Warning});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_debug
//
// Purpose:
// Function to log a debug message from Var feature.
//
// Parameters:
// - pl_message - *in* *charstring* - the message to log
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_debug(in @lazy charstring pl_message)
runs on EPTF_Var_CT
{
f_EPTF_Logging_debugV2(pl_message, v_Var_loggingMaskId, {c_EPTF_Var_loggingClassIdx_Debug});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_debugEnabled
//
// Purpose:
// Function to check if debug is enabled for Variable
//
// Parameters:
// -
//
// Return Value:
// *boolean* - true if debug enalbed
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_debugEnabled()
runs on EPTF_Var_CT
return boolean
{
return f_EPTF_Logging_isEnabled(v_Var_loggingMaskId, c_EPTF_Var_loggingClassIdx_Debug);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_enableDebug
//
// Purpose:
// Function enables debug logging for Variable
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
public function f_EPTF_Var_enableDebug()
runs on EPTF_Var_CT
{
f_EPTF_Logging_enableLocalMask(v_Var_loggingMaskId, c_EPTF_Var_loggingClassIdx_Debug)
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_Var_disableDebug
//
// Purpose:
// Function disables debug logging for Variable
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////
private function f_EPTF_Var_disableDebug()
runs on EPTF_Var_CT
{
f_EPTF_Logging_disableLocalMask(v_Var_loggingMaskId, c_EPTF_Var_loggingClassIdx_Debug)
}
} // group Logging
} // group Private
} // end of module