| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_ExecCtrl_PhaseDefinitions |
| // |
| // Purpose: |
| // This module contains type definitions for EPTF_CLL_ExecCtrl phase |
| // handling implementation. |
| // |
| // Module depends on: |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_FBQ_Definitions> |
| // <EPTF_CLL_LGenBase_PhaseDefinitions> |
| // |
| // Module Parameters: |
| // - |
| // |
| // Current Owner: |
| // Antal Wu-Hen-Chang (EANTWUH) |
| // |
| // Last Review Date: |
| // 2008-11-24 |
| // |
| // Detailed Comments: |
| // This module contains type definitions for EPTF_CLL_ExecCtrl phase |
| // handling implementation. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| module EPTF_CLL_ExecCtrl_PhaseDefinitions |
| { |
| |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_FBQ_Definitions all; |
| import from EPTF_CLL_LGenBase_PhaseDefinitions all; |
| |
| group Phase |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_Phase_Type |
| // |
| // Purpose: |
| // Type for storing data that describes a phase. |
| // |
| // Elements: |
| // - name - *charstring* - the name of the phase |
| // - enabled - *boolean* - shows whether the phase is enabled |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_Phase_Type |
| { |
| charstring name, |
| boolean enabled |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_Phase_Instance |
| // |
| // Purpose: |
| // Type for storing data that describes a phase instance. |
| // |
| // Elements: |
| // - name - *charstring* - the name of the phase instance |
| // - enabled - *boolean* - shows whether the phase instance is enabled |
| // - state - <EPTF_ExecCtrl_Phase_States> - state of the phase instance |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_Phase_Instance |
| { |
| charstring name, |
| boolean enabled, |
| EPTF_ExecCtrl_Phase_States state |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_Phase_Instance_List |
| // |
| // Purpose: |
| // Type for storing list of phase instances |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_Phase_Instance> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_Phase_Instance EPTF_ExecCtrl_Phase_Instance_List; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_Phase_States |
| // |
| // Purpose: |
| // Type for modelling the available states for a phase instance |
| // |
| // Elements: |
| // - IDLE |
| // - RUNNING |
| // - SKIPPING |
| // - STOPPING |
| // - FINISHED |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type enumerated EPTF_ExecCtrl_Phase_States |
| { |
| IDLE, |
| RUNNING, |
| SKIPPING, |
| STOPPING, |
| FINISHED |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFn |
| // |
| // Purpose: |
| // Callback function type for scenarioGroupPhaseChange |
| // |
| // Parameters: |
| // - pl_sgName - *in charstring* - name of the scenario group |
| // - pl_actualPhaseIdx - *in integer* - index of the actual phase of the scenarioGroup |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| type function EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFn(in charstring pl_sgName, in integer pl_actualPhaseIdx) runs on self; |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns |
| // |
| // Purpose: |
| // List of <EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFn>-s |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFn EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns; |
| |
| } //end of Phase group |
| |
| group PhaseList |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseList_Type |
| // |
| // Purpose: |
| // Type for storing list of phase declarators |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_Phase_Type> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_Phase_Type EPTF_ExecCtrl_PhaseList_Type; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseList_Instance |
| // |
| // Purpose: |
| // Type for storing data that describes a phase list |
| // instance. |
| // |
| // Elements: |
| // - name - *charstring* - the name of the phase list instance |
| // - phases - <EPTF_ExecCtrl_Phase_Instance_List> - phase instance list |
| // - actualPhaseIndex - *integer* - pointer to the actual phase in phases |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseList_Instance |
| { |
| charstring name, |
| EPTF_ExecCtrl_Phase_Instance_List phases, |
| integer actualPhaseIndex |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_ExecCtrl_PhaseList_Instance_empty |
| // |
| // Purpose: |
| // To init an empty <EPTF_ExecCtrl_PhaseList_Instance> value. |
| // |
| // Elements: |
| // name := "" |
| // phases := {} |
| // actualPhaseIndex := 0 |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_ExecCtrl_PhaseList_Instance c_EPTF_ExecCtrl_PhaseList_Instance_empty := |
| { |
| name := "", |
| phases := {}, |
| actualPhaseIndex := 0 |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseList_Instance_List |
| // |
| // Purpose: |
| // Type for storing a number of phase list instances |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_PhaseList_Instance> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_PhaseList_Instance |
| EPTF_ExecCtrl_PhaseList_Instance_List; |
| |
| } //end of PhaseList group |
| |
| group ScenarioGroups |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroup_ExecMode |
| // |
| // Purpose: |
| // Type for modelling the available execution mode for a scenario group |
| // |
| // Elements: |
| // - MANUAL |
| // - AUTOMATIC |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type enumerated EPTF_ExecCtrl_ScenarioGroup_ExecMode |
| { |
| AUTOMATIC, |
| MANUAL |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroup_Declarator |
| // |
| // Purpose: |
| // Type for declaring a scenario group |
| // |
| // Elements: |
| // - name - *charstring* - the name of the scenario group |
| // - execMode - <EPTF_ExecCtrl_ScenarioGroup_ExecMode> - execution mode |
| // - scenarioNames - <EPTF_CharstringList> - names of the scenarios in the |
| // scenario group |
| // - phaseListName - *charstring* - name of the phase list to be used |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_ScenarioGroup_Declarator |
| { |
| charstring name, |
| EPTF_ExecCtrl_ScenarioGroup_ExecMode execMode, |
| EPTF_CharstringList scenarioNames, |
| charstring phaseListName |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroup_Declarators |
| // |
| // Purpose: |
| // Type for storing a number of scenario group declarators |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_ScenarioGroup_Declarator> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_ScenarioGroup_Declarator |
| EPTF_ExecCtrl_ScenarioGroup_Declarators; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioPhaseInfo |
| // |
| // Purpose: |
| // Type for storing the phase information for a scenario in a scenario group |
| // |
| // Elements: |
| // - name - *charstring* - the name of the scenario |
| // - idx - *integer* - pointer to the scenario in the v_ExecCtrl_scenarios |
| // database |
| // - lgenIndexes - <EPTF_IntegerList> - pointer to the LGens in the |
| // v_ExecCtrl_lgens database, the scenario is running on |
| // - lgenPhaseLists - <EPTF_ExecCtrl_PhaseList_Instance_List> - phase list |
| // for each LGen the scenario is running on |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_ScenarioPhaseInfo |
| { |
| charstring name, |
| integer idx, |
| EPTF_IntegerList lgenIndexes, |
| EPTF_ExecCtrl_PhaseList_Instance_List lgenPhaseLists |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioPhaseInfo_List |
| // |
| // Purpose: |
| // Type for storing phase informationfor a number of scenarios |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_ScenarioPhaseInfo> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_ScenarioPhaseInfo |
| EPTF_ExecCtrl_ScenarioPhaseInfo_List; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroupAction_FT |
| // |
| // Purpose: |
| // Runs-on-self function signature to handle a scenario group finish or a |
| // phase finish event |
| // |
| // Elements: |
| // - p_idx - *in integer* - index if the scenario group in |
| // v_ExecCtrl_ScenarioGroupInstanceDB database |
| // - p_event - *in charstring* - in case of a phase finish, the finished |
| // phase's name is passed in this argument |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_ExecCtrl_ScenarioGroupAction_FT( |
| in integer p_idx, in charstring p_event); |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroup_Instance |
| // |
| // Purpose: |
| // Type for storing a scenario group instance |
| // |
| // Elements: |
| // - name - *charstring* - the name of the scenario group |
| // - execMode - <EPTF_ExecCtrl_ScenarioGroup_ExecMode> - execution mode |
| // - scenarios - <EPTF_ExecCtrl_ScenarioPhaseInfo_List> - phase information |
| // for the members of the scenario group |
| // - scenarioPhaseLists - <EPTF_ExecCtrl_PhaseList_Instance_List> - phase list |
| // instance for each scenario |
| // - groupPhaseList - <EPTF_ExecCtrl_PhaseList_Instance> - phase list instance |
| // for the group itself |
| // - phaseFinishAction - <EPTF_ExecCtrl_ScenarioGroupAction_FT> - this function |
| // will be called, when a phase is finished |
| // - groupFinishAction - <EPTF_ExecCtrl_ScenarioGroupAction_FT> - this function |
| // will be called, when the scenario group is finished executing the phase list |
| // - isRunningVarIdx - *integer* - variable index for the checkbox that control |
| // the starting and stopping of the scenario group |
| // - internalAdjust - *boolean* - this flag indicates whether the state of the |
| // checkbox that controls the starting/stopping was modified from the code |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_ScenarioGroup_Instance |
| { |
| charstring name, |
| EPTF_ExecCtrl_ScenarioGroup_ExecMode execMode, |
| EPTF_ExecCtrl_ScenarioPhaseInfo_List scenarios, |
| EPTF_ExecCtrl_PhaseList_Instance_List scenarioPhaseLists, |
| EPTF_ExecCtrl_PhaseList_Instance groupPhaseList, |
| EPTF_ExecCtrl_ScenarioGroupAction_FT phaseFinishAction, |
| EPTF_ExecCtrl_ScenarioGroupAction_FT groupFinishAction, |
| integer isRunningVarIdx, |
| boolean internalAdjust |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroup_Instances |
| // |
| // Purpose: |
| // Type for storing a number of scenarop group instances |
| // |
| // Elements: |
| // <EPTF_ExecCtrl_ScenarioGroup_Instance> |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_ExecCtrl_ScenarioGroup_Instance EPTF_ExecCtrl_ScenarioGroup_Instances; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_ExecCtrl_ScenarioGroup_Instance_empty |
| // |
| // Purpose: |
| // To init an empty <EPTF_ExecCtrl_ScenarioGroup_Instance> value. |
| // |
| // Elements: |
| // name := "", |
| // execMode := AUTOMATIC, |
| // scenarios := {}, |
| // scenarioPhaseLists := {}, |
| // groupPhaseList := c_EPTF_ExecCtrl_PhaseList_Instance_empty, |
| // phaseFinishAction := null, |
| // groupFinishAction := null, |
| // isRunningVarIdx := -1, |
| // internalAdjust := false |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_ExecCtrl_ScenarioGroup_Instance |
| c_EPTF_ExecCtrl_ScenarioGroup_Instance_empty := |
| { |
| name := "", |
| execMode := AUTOMATIC, |
| scenarios := {}, |
| scenarioPhaseLists := {}, |
| groupPhaseList := c_EPTF_ExecCtrl_PhaseList_Instance_empty, |
| phaseFinishAction := null, |
| groupFinishAction := null, |
| isRunningVarIdx := -1, |
| internalAdjust := false |
| } |
| |
| } //end of ScenarioGroups group |
| |
| group Databases |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseListDeclaratorDB |
| // |
| // Purpose: |
| // Type for storing a the phase list declarators |
| // |
| // Elements: |
| // - queue - <EPTF_FreeBusyQueue> - FBQ for the declarators |
| // - data - <EPTF_ExecCtrl_PhaseList_Declarators> - phase list declarators |
| // - hashRef - *integer* - str2int hash id. the hash key is the name, the |
| // value is the index in the data field. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseListDeclaratorDB |
| { |
| EPTF_FreeBusyQueue queue, |
| EPTF_LGenBase_PhaseList_Declarators data, |
| integer hashRef |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_ExecCtrl_PhaseListDeclaratorDB_HashName |
| // |
| // Purpose: |
| // To assign a name for the str2int hashmap usid in the |
| // v_ExecCtrl_PhaseListDeclaratorDB database. |
| // |
| // Elements: |
| // "EPTF_ExecCtrl_PhaseListDeclaratorDB_Hash" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_ExecCtrl_PhaseListDeclaratorDB_HashName := |
| "EPTF_ExecCtrl_PhaseListDeclaratorDB_Hash"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_ScenarioGroupInstanceDB |
| // |
| // Purpose: |
| // Type for storing the scenario group instances |
| // |
| // Elements: |
| // - queue - <EPTF_FreeBusyQueue> - FBQ for the declarators |
| // - data - <EPTF_ExecCtrl_ScenarioGroup_Declarators> - scenario group instances |
| // - hashRef - *integer* - str2int hash id. the hash key is the name, the |
| // value is the index in the data field. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_ScenarioGroupInstanceDB |
| { |
| EPTF_FreeBusyQueue queue, |
| EPTF_ExecCtrl_ScenarioGroup_Instances data, |
| integer hashRef |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_ExecCtrl_ScenarioGroupInstanceDB_HashName |
| // |
| // Purpose: |
| // To assign a name for the str2int hashmap used in the |
| // v_ExecCtrl_ScenarioGroupDB database. |
| // |
| // Elements: |
| // "EPTF_ExecCtrl_ScenarioGroupInstanceDB_Hash" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_ExecCtrl_ScenarioGroupInstanceDB_HashName := |
| "EPTF_ExecCtrl_ScenarioGroupInstanceDB_Hash"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_ExecCtrl_PhaseListDeclaratorDB_initValue |
| // |
| // Purpose: |
| // Init value for <EPTF_ExecCtrl_PhaseListDeclaratorDB>. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_ExecCtrl_PhaseListDeclaratorDB c_ExecCtrl_PhaseListDeclaratorDB_initValue := { |
| queue := c_EPTF_emptyFreeBusyQueue, |
| data := {}, |
| hashRef := -1 |
| }; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_ExecCtrl_ScenarioGroupInstanceDB_initValue |
| // |
| // Purpose: |
| // Init value for <EPTF_ExecCtrl_ScenarioGroupInstanceDB>. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_ExecCtrl_ScenarioGroupInstanceDB c_ExecCtrl_ScenarioGroupInstanceDB_initValue := { |
| queue := c_EPTF_emptyFreeBusyQueue, |
| data := {}, |
| hashRef := -1 |
| }; |
| |
| } // end of Databases group |
| |
| group ServerClientInterface |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseStartReq |
| // |
| // Purpose: |
| // Type for modeling a phase start request. |
| // Direction: ExecCtrl -> ExecCtrlClient |
| // |
| // Elements: |
| // - phaseName - *charstring* - phase to be started |
| // - entityGroupName - *charstring* - name of the entity group |
| // - scenarioInstanceName - *charstring* - name of the scenario instance |
| // - state - <EPTF_ExecCtrl_Phase_States> - the action that must be performed |
| // can be either RUNNING or SKIPPING |
| // - msgID - <EPTF_IntegerList> - msgID contains the following indices |
| // respectively: scenario group idx, scenario idx, lgen idx, phase idx |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseStartReq |
| { |
| charstring phaseName, |
| charstring entityGroupName, |
| charstring scenarioInstanceName, |
| EPTF_ExecCtrl_Phase_States state, |
| EPTF_IntegerList msgID |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseStopReq |
| // |
| // Purpose: |
| // Type for modeling a phase stop request. |
| // Direction: ExecCtrl -> ExecCtrlClient |
| // |
| // Elements: |
| // - phaseName - *charstring* - phase to be stopped |
| // - entityGroupName - *charstring* - name of the entity group |
| // - scenarioInstanceName - *charstring* - name of the scenario instance |
| // - state - <EPTF_ExecCtrl_Phase_States> - the action that must be performed |
| // can be STOPPING |
| // - msgID - <EPTF_IntegerList> - msgID contains the following indices |
| // respectively: scenario group idx, scenario idx, lgen idx, phase idx |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseStopReq |
| { |
| charstring phaseName, |
| charstring entityGroupName, |
| charstring scenarioInstanceName, |
| EPTF_ExecCtrl_Phase_States state, |
| EPTF_IntegerList msgID |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseStopTestReq |
| // |
| // Purpose: |
| // Type for modeling a phase stop request. |
| // Direction: ExecCtrl -> ExecCtrlClient |
| // |
| // Elements: |
| // - phaseName - *charstring* - phase to be stopped |
| // - entityGroupName - *charstring* - name of the entity group |
| // - scenarioInstanceName - *charstring* - name of the scenario instance |
| // - state - <EPTF_ExecCtrl_Phase_States> - the action that must be performed |
| // can be STOPPING |
| // - msgID - <EPTF_IntegerList> - msgID contains the following indices |
| // respectively: scenario group idx, scenario idx, lgen idx, phase idx |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseStopTestReq |
| { |
| charstring phaseName, |
| charstring entityGroupName, |
| charstring scenarioInstanceName, |
| EPTF_ExecCtrl_Phase_States state, |
| EPTF_IntegerList msgID |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseResetReq |
| // |
| // Purpose: |
| // Type for modeling a phase reset request. |
| // Direction: ExecCtrl -> ExecCtrlClient |
| // |
| // Elements: |
| // - phaseName - *charstring* - phase to be set |
| // - entityGroupName - *charstring* - name of the entity group |
| // - scenarioInstanceName - *charstring* - name of the scenario instance |
| // - state - <EPTF_ExecCtrl_Phase_States> - state of the phase |
| // - msgID - <EPTF_IntegerList> - msgID contains the following indices |
| // respectively: scenario group idx, scenario idx, lgen idx, phase idx |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseResetReq |
| { |
| charstring phaseName, |
| charstring entityGroupName, |
| charstring scenarioInstanceName, |
| EPTF_ExecCtrl_Phase_States state, |
| EPTF_IntegerList msgID |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhaseStatusRsp |
| // |
| // Purpose: |
| // Type for modeling a phase status response. |
| // Direction: ExecCtrlClient -> ExecCtrl |
| // |
| // Elements: |
| // - phaseName - *charstring* - actual phase |
| // - entityGroupName - *charstring* - name of the entity group |
| // - scenarioInstanceName - *charstring* - name of the scenario instance |
| // - state - <EPTF_ExecCtrl_Phase_States> - state of the scenario instance |
| // - msgID - <EPTF_IntegerList> - msgID contains the same indices that were |
| // received in the request (start/stop) |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_ExecCtrl_PhaseStatusRsp |
| { |
| charstring phaseName, |
| charstring entityGroupName, |
| charstring scenarioInstanceName, |
| EPTF_ExecCtrl_Phase_States state, |
| EPTF_IntegerList msgID |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_PhasePDU |
| // |
| // Purpose: |
| // Type for wrapping all the PDUs of the Phase Server/Client Interface |
| // |
| // Elements: |
| // - phaseStartReq - <EPTF_ExecCtrl_PhaseStartReq> - phase start request |
| // - phaseStopReq - <EPTF_ExecCtrl_PhaseStopReq> - phase stop request |
| // - phaseStatusRsp - <EPTF_ExecCtrl_PhaseStatusRsp> - phase status response |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type union EPTF_ExecCtrl_PhasePDU |
| { |
| EPTF_ExecCtrl_PhaseStartReq phaseStartReq, |
| EPTF_ExecCtrl_PhaseStopReq phaseStopReq, |
| EPTF_ExecCtrl_PhaseStopTestReq phaseStopTestReq, |
| EPTF_ExecCtrl_PhaseResetReq phaseResetReq, |
| EPTF_ExecCtrl_PhaseStatusRsp phaseStatusRsp |
| } |
| |
| } // end of ServerClientInterface group |
| |
| } |
