src/LGenBase/EPTF_CLL_LGenBase_TemplateDefinitions.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_LGenBase_TemplateDefinitions
//
//  Purpose:
//    This module provides data types for handling templates on TitanSim load generator
//
//  Module Parameters:
//    -
//
//  Module depends on:
//    <EPTF_CLL_Common_Definitions>
//    <EPTF_CLL_Base_Definitions>
//    <EPTF_CLL_LGenBase_LoggingDefinitions>
//
//  Current Owner:
//    Janos Zoltan Svaner (EJNOSVN)
//
//  Last Review Date:
//    2009-02-12
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
module EPTF_CLL_LGenBase_TemplateDefinitions
{
  import from EPTF_CLL_Common_Definitions all;
  import from EPTF_CLL_HashMap_Definitions all;
  import from EPTF_CLL_LGenBase_LoggingDefinitions all;

  ///////////////////////////////////////////////////////////
  // Module parameter: 
  //   tsp_LGenBase_extTemplLoadList
  //
  // Detailed description:
  //    This parameter defines the initial list of external templates,
  //    which are loded by initialising of component.
  ///////////////////////////////////////////////////////////
  modulepar EPTF_LGenBase_ExtTemplLoadList tsp_LGenBase_extTemplLoadList := {}

  ///////////////////////////////////////////////////////////
  // Module parameter: 
  //   tsp_LGenBase_templParamOpentoken
  //   tsp_LGenBase_templParamClosetoken
  //
  // Detailed description:
  //    This parameter defines the opening and closing strings
  //    of template parameters
  ///////////////////////////////////////////////////////////
  modulepar charstring tsp_LGenBase_templParamOpentoken := "$(";
  modulepar charstring tsp_LGenBase_templParamClosetoken := ")";

  ///////////////////////////////////////////////////////////
  // Module parameter:
  //   tsp_LGenBase_extTemplRemoveLastNewLine
  //
  // Detailed description:
  //    If this paramter is true then the last new line will be removed from the external template
  //
  ///////////////////////////////////////////////////////////
  modulepar boolean tsp_LGenBase_extTemplRemoveLastNewLine       := false;

  //////////////////////////////////////////////////////////////////////////////////////////
  // Module parameter: 
  //   tsp_LGenBase_enableDefaultArithmeticOperationsInExtTemplate
  //
  // Detailed description:
  //    This parameter controls the default arithmetic operation of the 
  //    Template parameter substitution process. If false, the default process
  //    is switched off, only the other registered functions in the 
  //    TemplateMissingParameterCallbackList will be run.
  //////////////////////////////////////////////////////////////////////////////////////////
  modulepar boolean tsp_LGenBase_enableDefaultArithmeticOperationsInExtTemplate := false;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplateList
  //
  // Purpose:
  //   Type for storing loaded external templates. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_ExtTemplate EPTF_LGenBase_ExtTemplateList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplate
  //
  // Purpose:
  //   Type for describing an external template. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ExtTemplate
  {
    charstring name,
    EPTF_LGenBase_ExtTemplateRepr repr,
    EPTF_LGenBase_ExtTemplateFixedPosRepr reprFixedPos
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplateRepr
  //
  // Purpose:
  //   Type for parsed representation of an external template. 
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ExtTemplateRepr
  {
    EPTF_LGenBase_ExtTemplateFragment_List fragmentList,
    charstring lastFragment,
    EPTF_CharstringList paramNames
  }

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplateFixedPosFragment
  //
  // Purpose:
  //   Type for parsed representation of an external template
  //   for fixed position variation
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ExtTemplateFixedPosFragment
  {
    charstring text,
    EPTF_IntegerList paramPositions
  }

  // list of fragments
  type record of EPTF_LGenBase_ExtTemplateFixedPosFragment EPTF_LGenBase_ExtTemplateFixedPosRepr;
  type record of EPTF_LGenBase_ExtTemplateFragment EPTF_LGenBase_ExtTemplateFragment_List;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplateFragment
  //
  // Purpose:
  //   Type for representing one fraggment of an external template. 
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ExtTemplateFragment
  {
    charstring text,       // text fragmment
    integer paramPosition  // true if it will be replaced, false if it won't
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplLoadList
  //
  // Purpose:
  //   Type for defining a list of external templates to load from file system. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_ExtTemplLoadItem  EPTF_LGenBase_ExtTemplLoadList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ExtTemplLoadItem
  //
  // Purpose:
  //   Type for defining an external template to load from file system. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ExtTemplLoadItem
  {
    charstring name,
    charstring path,
    boolean convertLF2CRLF
  }

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateTypeList
  //
  // Purpose:
  //   Type for storing declared template types. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateTypeDeclaration EPTF_LGenBase_TemplateTypeList

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateTypeDeclaration
  //
  // Purpose:
  //   Type for internal representation of a template type declaration. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateTypeDeclaration
  {
    EPTF_LGenBase_TemplateTypeKey templateTypeKey,
    EPTF_LGenBase_TemplateParameterList compulsoryParams,
    EPTF_LGenBase_TemplateParameterList optionalParams,
    EPTF_LGenBase_TemplateCallback startCallback optional,
    EPTF_LGenBase_TemplateCallback finishCallback optional
  }

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateTypeKey
  //
  // Purpose:
  //   Type for defineing a template type key.
  //   A template type is defined by behaviour type and template name.
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateTypeKey
  {
    charstring behaviourType,
    charstring templateName
  }

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateCallback
  //
  // Purpose:
  //   Function type can be used for defining start and finish 
  //   callback by substitution of templates
  ///////////////////////////////////////////////////////////
  type function EPTF_LGenBase_TemplateCallback(inout EPTF_IntegerList pl_contextArgs, inout EPTF_CharstringList pl_params) runs on self;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateParameterCallback
  //
  // Purpose:
  //   Function type can be used for defining callback 
  //   by substitution of a parameter of a template
  ///////////////////////////////////////////////////////////
  type function EPTF_LGenBase_TemplateParameterCallback(inout EPTF_IntegerList pl_contextArgs, inout charstring pl_param) runs on self;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateParameterCallbackList
  //
  // Purpose:
  //   List of <EPTF_LGenBase_TemplateParameterCallback>
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateParameterCallback EPTF_LGenBase_TemplateParameterCallbackList;

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateMissingParameterCallback
  //
  // Purpose:
  //   Function type can be used for defining callback, which is called for a template parameter not known.
  //   This way, application can modify the template if it has more info than LGenBase.
  //
  //   Parameters:
  //
  //    - inout pl_paramValue     - *charstring*                        - the output value that should be changed 
  //                                                                      in the template
  //    - in pl_dictionary        - <EPTF_LGenBase_TemplParamSubstList> - the parameters values according to 
  //                                                                      the output should be changed
  //
  //   Return value:
  //    - boolean : true if value is modified by the function.
  //
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  type function EPTF_LGenBase_TemplateMissingParameterCallback( inout charstring pl_paramValue,
                                                                in EPTF_LGenBase_TemplParamSubstList pl_dictionary)
  runs on self return boolean;

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateMissingParameterCallbackList
  //
  // Purpose:
  //   List of <EPTF_LGenBase_TemplateMissingParameterCallback>
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateMissingParameterCallback EPTF_LGenBase_TemplateMissingParameterCallbackList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateParameter
  //
  // Purpose:
  //   Type for defining a parameter name and a callback for it 
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateParameter
  {
    charstring parameter,
    EPTF_LGenBase_TemplateParameterCallback callback optional 
  }

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateParameterList
  //
  // Purpose:
  //   List of template parameters 
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateParameter EPTF_LGenBase_TemplateParameterList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateSetList
  //
  // Purpose:
  //   Type for storing template sets. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateSet EPTF_LGenBase_TemplateSetList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateSet
  //
  // Purpose:
  //   Type to define a template set. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplateSetItem EPTF_LGenBase_TemplateSet;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateSetItem
  //
  // Purpose:
  //   Type to define an item of template set. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateSetItem
  {
    integer templateTypeIdx,
    integer externalTemplateIdx,
    EPTF_LGenBase_PositionJumpList posJumpTable
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_EPTF_LGenBase_PositionJumpList
  //
  // Purpose:
  //   Jump table for supporting conversion of parameter posisitions. 
  ///////////////////////////////////////////////////////////
  type record of integer EPTF_LGenBase_PositionJumpList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateList
  //
  // Purpose:
  //   Allows configuration of a template set. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_AssignedTemplate EPTF_LGenBase_TemplateList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplParamSubstList
  //
  // Purpose:
  //   Defines a list of parameter substitutions in a template. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_AssignedTemplate
  {
    charstring behaviourType,
    charstring templateName,
    charstring externalTemplateName
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplParamSubstList
  //
  // Purpose:
  //   Defines a list of parameter substitutions in a template. 
  //
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TemplParamSubst EPTF_LGenBase_TemplParamSubstList;

  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplParamSubst
  //
  // Purpose:
  //   Defines a parameter substitution in a template. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplParamSubst
  {
    charstring paramName,
    charstring paramValue
  }

  ///////////////////////////////////////////////////////////
  //  Type: EPTF_LGenBase_getTemplateContent_FT
  //
  //  Purpose:
  //    Funtion type to get the actual template content
  //
  //  Parameters:
  //    - pl_extTemplateIdx - *in* *integer* - index of external template in the dictionary
  //    - pl_dictionary - *in* <EPTF_LGenBase_TemplParamSubstList> - dictionary of fixed order parameter names and values
  //    - pl_content - *inout* *charstring* - the substituted template content
  //
  //  Return value
  //    *boolean* - true, if substitution succeeded, otherwise false
  //
  //  Detailed comments:
  //    -
  //
  ///////////////////////////////////////////////////////////
  type function EPTF_LGenBase_getTemplateContent_FT(
    in integer pl_extTemplateIdx,
    in EPTF_LGenBase_TemplParamSubstList pl_dictionary,
    inout charstring pl_content
  )
  runs on self
  return boolean

  //////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateGetterMode
  //
  // Purpose:
  //   A union for different external template handling parameters 
  //
  // Elements:
  //   - defaultGetter - <EPTF_LGenBase_TemplateGetter_Default> - default external template handling parameters
  //   - fixedPosGetter - <EPTF_LGenBase_TemplateGetter_FixedPos> - fixed position external template handling parameters
  //
  ///////////////////////////////////////////////////////////
  type union EPTF_LGenBase_TemplateGetterMode
  {
    EPTF_LGenBase_TemplateGetter_Default defaultGetter,
    EPTF_LGenBase_TemplateGetter_FixedPos fixedPosGetter
  }
  
  //////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateGetter_Default
  //
  // Purpose:
  //   Empty parameter for default external template handling. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateGetter_Default
  {
  }

  //////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TemplateGetter_FixedPos
  //
  // Purpose:
  //   Defines a parameter for fixed position external template handling. 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TemplateGetter_FixedPos
  {
    EPTF_CharstringList orderedMacroNameList
  }

  ///////////////////////////////////////////////////////////
  //  Type:  EPTF_LGenBase_extTemplate_CT
  //
  //  Extends: -
  // 
  //  Purpose:
  //    Component type for the External Template feature of TitanSim
  // 
  /////////////////////////////////////////////////////////
  type component EPTF_LGenBase_extTemplate_CT extends EPTF_LGenBase_Logging_CT, EPTF_HashMap_CT
  {
    private var boolean v_LGenBase_extTemplate_initialized := false;

    private var EPTF_LGenBase_ExtTemplateList v_LGenBase_extTemplateDB := {};
    private var EPTF_LGenBase_TemplateTypeList v_LGenBase_templateTypeDB := {};
    private var EPTF_LGenBase_TemplateSetList v_LGenBase_templateSetDB := {};

    private var integer v_LGenBase_extTemplHashMapId := -1;  // hashmap to store external template indexes
    private var integer v_LGenBase_templTypeHashMapId := -1;  // hashmap to store template type indexes

    private var integer v_LGenBase_extTemplFixedPos_hashMapId := -1;  // hashmap to store template param fixed position
    private var boolean v_LGenBase_extTemplFixedPos_initialized := false;
    private var boolean v_LGenBase_extTemplRemoveLastNewLine := false;
    private var EPTF_LGenBase_getTemplateContent_FT vf_EPTF_LGenBase_getTemplateContent := null;

    private var EPTF_LGenBase_TemplateMissingParameterCallbackList v_LGenBase_TemplateMissingParameterCallbackList := {};
  }

  ///////////////////////////////////////////////////////////
  //  Constants: 
  //  - c_EPTF_LGenBase_extTemplHashMapName - *charstring* - 
  //            name of hasmap for storing external template names
  //  - c_EPTF_LGenBase_templTypeHashMapName - *charstring* -
  //            name of hasmap for storing template type names
  //  - c_EPTF_LGenBase_extTemplFixedPosHashMapName - *charstring* -
  //            name of hasmap for storing fixed position macro name - position
  //            index pairs
  //  - c_EPTF_LGenBase_hashKeyDelimiter *charstring* - 
  //            delimiter pattern used in template type keys
  ////////////////////////////////////////////////////////////
  const charstring c_EPTF_LGenBase_extTemplHashMapName := "LGenBase_externalTemplateHashMap";
  const charstring c_EPTF_LGenBase_templTypeHashMapName := "LGenBase_templateTypeHashMap";
  const charstring c_EPTF_LGenBase_extTemplFixedPosHashMapName := "LGenBase_extTemplFixedPosHashMapName";
  const charstring c_EPTF_LGenBase_hashKeyDelimiter := "###";

} // end of module