| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2019 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v2.0 // |
| // which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_CLL_LoggingServer_Definitions |
| // |
| // Purpose: |
| // This module contains definitions of EPTF_CLL_LoggingUI. |
| // |
| // Module depends on: |
| // <EPTF_CLL_Logging_Definitions> |
| // <EPTF_CLL_Variable_Definitions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_UIHandlerClient_Definitions> |
| // <EPTF_CLL_HashMap_Definitions> |
| // |
| // Current Owner: |
| // ELSZSKU |
| // |
| // Last Review Date: |
| // 20 |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| |
| module EPTF_CLL_LoggingServer_Definitions |
| |
| { |
| import from EPTF_CLL_DataSource_Definitions all; |
| |
| // if you use EPTF_Generic_Logger_CT you have to import these |
| import from EPTF_CLL_Logging_Definitions all |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_HashMap_Definitions all; |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_Logging_resp |
| // |
| // Purpose: |
| // Constant for <Logging_Resp>. |
| // |
| /////////////////////////////////////////////////////////// |
| const EPTF_Logging_Msg c_Logging_resp:={ |
| Logging_Resp:={ |
| Message:=OK |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_Logging_bye |
| // |
| // Purpose: |
| // Constant for <Logging_Bye>. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| const EPTF_Logging_Msg c_Logging_bye:={ |
| Logging_Bye:={ |
| Message:=Bye |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_Logging_byeAck |
| // |
| // Purpose: |
| // Constant for <Logging_ByeAck>. |
| // |
| /////////////////////////////////////////////////////////// |
| const EPTF_Logging_Msg c_Logging_byeAck:={ |
| Logging_ByeAck:={ |
| Message:=ByeAck |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Template: tr_EPTF_Logging_req template |
| // |
| // Purpose: |
| // <EPTF_Logging_Req_Type> type template, for receiving request messages. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| template EPTF_Logging_Msg tr_EPTF_Logging_req:={ |
| Logging_Req:={ |
| Request:=Init, |
| clientIdx:=?, |
| compType:=?, |
| selectionInClient:=?, |
| eventClassNames:={*} |
| } |
| } |
| //TODO comment |
| template EPTF_Logging_Msg tr_EPTF_Logging_newSelection:={ |
| Logging_NewSelection:={ |
| name := ?, |
| selectionInClient := ?, |
| clientIdx := ? |
| } |
| } |
| |
| template EPTF_Logging_Msg tr_EPTF_Logging_hello := { |
| Logging_Hello := {?} |
| } |
| |
| template EPTF_Logging_Msg tr_EPTF_Logging_clientAck := { |
| Logging_ClientAck := {?} |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_Req_Type |
| // |
| // Purpose: |
| // Reqest Type message. |
| // |
| // Elements: |
| // Request - <EPTF_Logging_Msg_types> - The type of request |
| // compName - *charstring* - The name of the component |
| // compType - *charstring* - The type of the component |
| // selection - *integer* - Core=0/User=1 |
| // eventClassNames - <EPTF_Logging_EventClassPrefixList> - The list of the logmask |
| // |
| // Detailed Comments: |
| // Reqest Type message. The client sends this messages to the main Logging component. |
| // The client sends its name,type, and logmask. with the help of this message the main |
| // Logging component makes the component types tab. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| type record EPTF_Logging_Req_Type |
| { |
| EPTF_Logging_Msg_types Request, |
| integer clientIdx, |
| charstring compType, |
| integer selectionInClient, |
| EPTF_Logging_EventClassPrefixList eventClassNames |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_ClientAck_Type |
| // |
| // Purpose: |
| // Server answers to the EPTF_Logging_Hello_Type message and |
| // returns the client idx to the client. |
| // |
| /////////////////////////////////////////////////////////// |
| type record EPTF_Logging_ClientAck_Type |
| { |
| integer clientIdx |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_NewSelection_Type |
| // |
| // Purpose: |
| // Client indicates that a new selection type has been registered. |
| // |
| /////////////////////////////////////////////////////////// |
| type record EPTF_Logging_NewSelection_Type{ |
| charstring name, |
| integer selectionInClient, |
| integer clientIdx |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_Hello_Type |
| // |
| // Purpose: |
| // Client connects to the server, passes its Base name. |
| // |
| /////////////////////////////////////////////////////////// |
| type record EPTF_Logging_Hello_Type{ |
| charstring compName |
| } |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_Resp_Type |
| // |
| // Purpose: |
| // Response Type message. |
| // |
| // Elements: |
| // Response - <EPTF_Logging_Msg_types> - The response message |
| // |
| // Detailed Comments: |
| // The response message. The Logging and Logging client components sends these messages. |
| // There are 3 types OK, Hello, Bye: |
| // OK is a response to a request message. |
| // Hello is a client message for starting the connection. Bye is a client message for stopping connection. |
| // With the help of these messages main Logging maintain the number of connected clients. |
| // |
| ////////////////////////////////////////////////////////// |
| |
| type record EPTF_Logging_Resp_Type |
| { |
| EPTF_Logging_Msg_types Message |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_Msg_types |
| // |
| // Purpose: |
| // Enumerated type for chosing Logging message types. |
| // |
| // Elements: |
| // Hello - Hello type msg |
| // Init - Init type msg |
| // OK - OK type msg |
| // Bye - Bye type msg |
| // |
| // Detailed Comments: |
| // Enumerated type for chosing possible Logging message types. |
| /////////////////////////////////////////////////////////// |
| |
| type enumerated EPTF_Logging_Msg_types {Hello(0), Init(1), OK(2), Bye(3), ByeAck(4), NewSelection(5)} |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_Logging_Msg |
| // |
| // Purpose: |
| // The union of Logging messages. |
| // |
| // Elements: |
| // Logging_Req - <EPTF_Logging_Req_Type> - The request message |
| // Logging_Resp - <EPTF_Logging_Resp_Type> - The response message |
| // Logging_Hello - <EPTF_Logging_Resp_Type> - The Hello message |
| // Logging_Bye - <EPTF_Logging_Resp_Type> - The Bye message |
| // |
| // Detailed Comments: |
| // All Logging messages. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| type union EPTF_Logging_Msg |
| { |
| EPTF_Logging_Req_Type Logging_Req, |
| EPTF_Logging_Resp_Type Logging_Resp, |
| EPTF_Logging_Hello_Type Logging_Hello, |
| EPTF_Logging_ClientAck_Type Logging_ClientAck, |
| EPTF_Logging_Resp_Type Logging_Bye, |
| EPTF_Logging_Resp_Type Logging_ByeAck, |
| EPTF_Logging_NewSelection_Type Logging_NewSelection |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_LoggingPort_PT |
| // |
| // Purpose: |
| // Internal message port type for exchanging configuration messages. |
| // |
| // Elements: |
| // |
| // Detailed Comments: |
| // Can bothway send messages |
| /////////////////////////////////////////////////////////// |
| |
| type port EPTF_LoggingPort_PT message { |
| inout EPTF_Logging_Msg; |
| } with {extension "internal"} |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_Logging_typesLookupTable_HashName |
| // |
| // Purpose: |
| // Constant for the name of the Hashmap used for a lookupTable for types. |
| // |
| /////////////////////////////////////////////////////////// |
| const charstring c_Logging_typesLookupTable_HashName := "typesLookupTable"; |
| |
| /////////////////////////////////////////////////////////// |
| // Component: EPTF_LoggingClient_CT |
| // |
| // Purpose: |
| // Component type for EPTF LoggingUI Client interface. |
| // |
| // Elements: |
| // v_LoggingClient_main - <EPTF_LoggingServer_CT> - the main LoggingServer component |
| // v_LoggingClient_allComponentLocalEnableIdx - *integer* - the EPTF variable ID of v_EPTF_Logging_allComponentLocalEnable |
| // v_LoggingClient_componentLocalEnableIdx - <EPTF_IntegerList> - the EPTF variable ID of v_EPTF_componentLocalEnable, integerlist |
| // v_LoggingClient_componentLocalMaskIdx - <EPTF_IntegerArray2D> - the EPTF variable ID of v_EPTF_componentLocalMask, 2D integermatrix |
| // v_LoggingClient_initialized - *boolean* - true if loggingUI is initalized with its init function |
| // |
| // Detailed Comments: |
| // LoggingUI Client type component. Every component using LoggingUI have to extend this component type. |
| // |
| /////////////////////////////////////////////////////////// |
| |
| type component EPTF_LoggingClient_CT extends EPTF_Logging_CT, EPTF_DataSourceClient_CT { |
| private port EPTF_LoggingPort_PT EPTF_LoggingClientPort_CP; |
| |
| private var EPTF_LoggingServer_CT v_LoggingClient_main; |
| private var integer v_LoggingClient_allComponentLocalEnableIdx; |
| private var EPTF_IntegerList v_LoggingClient_componentLocalEnableIdx; |
| private var EPTF_IntegerArray2D v_LoggingClient_componentLocalMaskIdx; |
| private var boolean v_LoggingClient_initialized := false; |
| private var boolean v_LoggingClient_portConnected := false; |
| private var boolean v_LoggingClient_byeAckReceived := false; |
| private var default v_LoggingClient_handleBy := null; |
| private var integer v_LoggingClient_clientIdx := -1; |
| |
| private var integer v_LoggingClient_dummyInt; |
| private var charstring v_LoggingClient_dummyCharstring; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Component: EPTF_LoggingServer_CT |
| // |
| // Purpose: |
| // Component type for EPTF main LoggingServer interface. |
| // |
| // Elements: |
| // v_EPTF_LoggingServer_def - *default* - default altstep in main LoggingServer component |
| // v_EPTF_LoggingServer_allComponentGlobalEnableIdx - *integer* - the EPTF variable ID of v_EPTF_allComponentGlobalEnable |
| // v_EPTF_LoggingServer_componentGlobalEnableIdx - <EPTF_IntegerArray2D> - the EPTF variable id of <EPTF_Logging_LogMaskList> ComponentGlobalEnable |
| // v_EPTF_LoggingServer_componentGlobalMaskIdx - <LoggingServer_IntegerArray3D> - the EPTF variable ID of <EPTF_Logging_LogMaskList> ComponentGlobalMask |
| // v_EPTF_LoggingServer_typesLookupTableName - *charstring* - name of the component types lookup table HashMap |
| // v_EPTF_LoggingServer_typesLookupTableID - *integer* - the returned ID of the component types lookup table HashMap |
| // v_EPTF_LoggingServer_typesID - *integer* - the generated ID of the component types |
| // v_EPTF_LoggingServer_tabboxName - *charstring* - name of the tabbox where the LoggingServer has to be created on the GUI |
| // v_EPTF_LoggingServer_numberOfClients - *integer* - the number of connected clients |
| // v_EPTF_LoggingServer_allowReq - *boolean* - true if new request message processing allowed |
| // v_EPTF_LoggingServer_initialized - *boolean* - true if LoggingServer is initalized with its init function |
| // LoggingServer_CharstringArray2D v_LoggingServer_clientNames4Types; |
| // LoggingServer_CharstringArray2D v_LoggingServer_clientNames4Types; |
| // |
| // Detailed Comments: |
| // LoggingServer main component. There always have to be one main component. |
| // |
| /////////////////////////////////////////////////////////// |
| type component EPTF_LoggingServer_CT extends EPTF_Logging_CT, EPTF_Var_CT, EPTF_DataSourceClient_CT, EPTF_HashMap_CT { |
| private port EPTF_LoggingPort_PT EPTF_LoggingServerPort_CP; |
| private var default v_EPTF_LoggingServer_def := null; |
| private var integer v_EPTF_LoggingServer_allComponentGlobalEnableIdx; |
| private var EPTF_IntegerArray2D v_EPTF_LoggingServer_componentGlobalEnableIdx; |
| private var LoggingServer_IntegerArray3D v_EPTF_LoggingServer_componentGlobalMaskIdx; |
| private var charstring v_EPTF_LoggingServer_typesLookupTableName; |
| private var integer v_EPTF_LoggingServer_typesLookupTableID; |
| private var integer v_EPTF_LoggingServer_typesID; |
| private var charstring v_EPTF_LoggingServer_tabboxName; |
| private var integer v_EPTF_LoggingServer_numberOfClients; |
| private var boolean v_EPTF_LoggingServer_allowReq := true; |
| private var boolean v_EPTF_LoggingServer_initialized := false; |
| private var EPTF_IntegerList v_LoggingServer_clientNames4Types; |
| private var EPTF_IntegerArray2D v_LoggingServer_typeNames; |
| private var EPTF_LoggingServer_ClientList v_LoggingServer_clients := {}; |
| private var integer v_LoggingServer_iteratorSelectionsVarIdx := -1; |
| private var integer v_LoggingServer_iteratorClientsVarIdx := -1; |
| private var EPTF_IntegerList v_LoggingServer_iteratorComponentTypesVarIdxList := {}; //Masks per selection |
| |
| private var integer v_LoggingServer_dummyInt; |
| private var charstring v_LoggingServer_dummyCharstring; |
| private var EPTF_IntegerArray2D v_LoggingServer_selIdxMap := {}; |
| } |
| type record of EPTF_LoggingClient_CT EPTF_LoggingServer_ClientList; |
| type record of EPTF_IntegerArray2D LoggingServer_IntegerArray3D; |
| //type record of EPTF_CharstringList LoggingServer_CharstringArray2D; |
| |
| const charstring c_LoggingServer_sourceId := "Logging"; |
| const charstring c_LoggingClient_sourceId := "LoggingClient"; |
| const charstring c_LoggingServer_allComponentGlobalEnableVarName := "allComponentGlobalEnable" |
| /////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_typesLookupTable_HashName |
| // |
| // Purpose: |
| // Constant for the name of the Hashmap used for a lookupTable for types. |
| // |
| /////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_typesLookupTable_HashName := "typesLookupTable"; |
| |
| const charstring c_LoggingServer_componentGlobalEnablePrefix := "Logging.componentGlobalEnable." |
| //EPTF_LoggingUI.componentGlobalMask. |
| const charstring c_LoggingServer_componentGlobalMaskPrefix := "Logging.componentGlobalMask." |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_iteratorVarPrefix |
| // |
| // Purpose: |
| // This is the prefix for LoggingServer iterator variables |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_iteratorVarPrefix := "LoggingServer_iterator_"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_paramNameSelection |
| // |
| // Purpose: |
| // Specifies a selection |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_paramNameSelection := "Selection"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_paramNameComponentType |
| // |
| // Purpose: |
| // Specifies the component type name which registered its log classes. |
| // E.g. "StatHandler" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_paramNameComponentType := "ComponentType"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_paramNameClass |
| // |
| // Purpose: |
| // Specifies the name of a registered logging class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_paramNameClass := "Class" |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_paramNameClient |
| // |
| // Purpose: |
| // Specifies the PTC name of a registered client component |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_paramNameClient := "Client" |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_iteratorSelectionTypes |
| // |
| // Purpose: |
| // This iterator enlists the available selection types |
| // |
| // Parameters: |
| // This element has no parameters |
| // |
| // Detailed comments |
| // There are two available selection types: CLL and User. |
| // The core library features register their log classes under the CLL |
| // selection type. Obviously users can register their log classes under the |
| // User selection type. |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_iteratorSelectionTypes := "SelectionTypes"; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_iteratorSelectionTypes := { |
| name := c_LoggingServer_iteratorSelectionTypes, |
| valueType := charstringlistType, |
| typeDescriptor := { |
| isListOf := true, |
| typeName := "SelectionType" |
| }, |
| description := "Iterator enlists the available selection types." |
| }; |
| |
| const charstring c_LoggingServer_iteratorSelectionTypes_varName := c_LoggingServer_iteratorSelectionTypes; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_iteratorClients |
| // |
| // Purpose: |
| // This iterator enlists the PTC names of registered clients |
| // |
| // Parameters: |
| // - <c_LoggingServer_paramNameComponentType> - if the optional parameter is set, the |
| // iterator enlists only the client PTC names which PTCs registered the |
| // given component type. |
| // If there is no parameter, the iterator enlists every connected client. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_iteratorClients := "Clients"; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_iteratorClients := { |
| name := c_LoggingServer_iteratorClients, |
| valueType := charstringlistType, |
| description := "Iterator enlists the PTC names of registered clients." |
| }; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_iteratorClients_componentType := { |
| name := c_LoggingServer_iteratorClients, |
| valueType := charstringlistType, |
| description := "Iterator enlists only the client PTC names which PTCs registered the given component type.", |
| parameters := { |
| { |
| name := c_LoggingServer_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| } |
| } |
| }; |
| |
| const charstring c_LoggingServer_iteratorClients_varName := c_LoggingServer_iteratorClients; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_iteratorComponentTypes |
| // |
| // Purpose: |
| // This iterator enlists the name of the component types which registered their log classes. |
| // |
| // Parameters: |
| // - <c_LoggingServer_paramNameSelection> - the mandatory parameter defines |
| // the selection type to filter the component types which registered |
| // their log classes. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_iteratorComponentTypes := "ComponentTypes"; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_iteratorComponentTypes := { |
| name := c_LoggingServer_iteratorComponentTypes, |
| valueType := charstringlistType, |
| typeDescriptor := { |
| isListOf := true, |
| typeName := "ComponentType" |
| }, |
| description := "Iterator enlists the name of the component types which registered their log classes.", |
| parameters := { |
| { |
| name := c_LoggingServer_paramNameSelection, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorSelectionTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "The selection type to filter the component types which registered their log classes", |
| exampleValue := "EPTF_CLL" |
| } |
| } |
| }; |
| |
| const charstring c_LoggingServer_iteratorComponentTypes_varName := c_LoggingServer_iteratorComponentTypes; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_iteratorClasses |
| // |
| // Purpose: |
| // This iterator enlists the registered log classes |
| // |
| // Parameters: |
| // - <c_LoggingServer_paramNameComponentType> - the mandatory parameter defines |
| // the component type which registered the log classes to be listed |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_iteratorClasses := "Classes"; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_iteratorClasses := { |
| name := c_LoggingServer_iteratorClasses, |
| valueType := charstringlistType, |
| typeDescriptor := { |
| isListOf := true, |
| typeName := "Class" |
| }, |
| description := "Iterator enlists the registered log classes", |
| parameters := { |
| { |
| name := c_LoggingServer_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| } |
| } |
| } |
| |
| const charstring c_LoggingServer_iteratorClasses_varName := c_LoggingServer_iteratorClasses; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingServer_dataElementScGroupOfSc |
| // |
| // Purpose: |
| // This dataElement returns the enabled state of the element described by |
| // the parameters. |
| // - Each parameter is optional. |
| // - If none is set, the state of global logging returned. |
| // - If only the <c_LoggingServer_paramNameComponentType> is set, the component type log enabled state returned. |
| // - If the <c_LoggingServer_paramNameComponentType> and <c_LoggingServer_paramNameClass> are set, |
| // the log enabled state of the given log class of the given component type log returned. |
| // - Any other combination of the parameters is invalid. |
| // |
| // Parameters: |
| // - <c_LoggingServer_paramNameComponentType> |
| // - <c_LoggingServer_paramNameClass> |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingServer_dataElementLogEnabled := "LogEnabled"; |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_dataElementLogEnabled := { |
| name := c_LoggingServer_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of the given log class of the given component type log", |
| parameters := { |
| { |
| name := c_LoggingServer_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| }, |
| { |
| name := c_LoggingServer_paramNameClass, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorClasses.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the name of a registered logging class", |
| exampleValue := "Warning" |
| } |
| } |
| } |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_dataElementLogEnabled_withoutParams := { |
| name := c_LoggingServer_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of global logging" |
| } |
| |
| const EPTF_DataSource_Help_DataElement c_Logging_Help_dataElementLogEnabled_componentType := { |
| name := c_LoggingServer_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of the component type log", |
| parameters := { |
| { |
| name := c_LoggingServer_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_Logging_dataElement_help |
| // |
| // Purpose: |
| // This data element returns the help information about |
| // all dataElements supported. |
| // ValueType: charstring |
| // |
| // Parameters: |
| // - <c_EPTF_DataSource_paramNameHelpFormat> - the format of the output |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_Logging_dataElement_help := c_EPTF_DataSource_dataElement_Help; |
| |
| const EPTF_DataSource_Help_DataElement c_EPTF_Logging_Help_dataElement_help := c_EPTF_DataSource_Help_dataElement_genericHelp; |
| |
| // the datasource help database for Logging |
| const EPTF_DataSource_Help_DataElementChildren c_EPTF_Logging_help := { |
| { |
| dataElement := c_EPTF_Logging_Help_dataElement_help |
| }, |
| { |
| dataElement := c_Logging_Help_iteratorClients |
| }, |
| { |
| dataElement := c_Logging_Help_dataElementLogEnabled_withoutParams |
| }, |
| { |
| dataElement := c_Logging_Help_iteratorSelectionTypes |
| }, |
| { |
| dataElement := c_Logging_Help_iteratorComponentTypes |
| }, |
| { |
| dataElement := c_Logging_Help_iteratorClients_componentType |
| }, |
| { |
| dataElement := c_Logging_Help_dataElementLogEnabled_componentType |
| }, |
| { |
| dataElement := c_Logging_Help_iteratorClasses |
| }, |
| { |
| dataElement := c_Logging_Help_dataElementLogEnabled |
| } |
| } |
| |
| //Client data sources |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingClient_paramNameComponentType |
| // |
| // Purpose: |
| // Specifies the component type name which registered its log classes. |
| // E.g. "StatHandler" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingClient_paramNameComponentType := "ComponentType"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingClient_paramNameClass |
| // |
| // Purpose: |
| // Specifies the name of a registered logging class |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingClient_paramNameClass := "Class" |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_LoggingClient_dataElementScGroupOfSc |
| // |
| // Purpose: |
| // This dataElement returns the enabled state of the element described by |
| // the parameters. |
| // - Each parameter is optional. |
| // - If none is set, the client log enabled state returned. |
| // - If only the <c_LoggingClient_paramNameComponentType> is set, the component type log on the given client enabled state returned. |
| // - If the <c_LoggingClient_paramNameComponentType> and <c_LoggingClient_paramNameClass> are set, |
| // the log enabled state of the given log class of the given component type on the given client log returned. |
| // - Any other combination of the parameters is invalid. |
| // |
| // Parameters: |
| // - <c_LoggingClient_paramNameComponentType> |
| // - <c_LoggingClient_paramNameClass> |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_LoggingClient_dataElementLogEnabled := "LogEnabled"; |
| |
| const EPTF_DataSource_Help_DataElement c_LoggingClient_Help_dataElementLogEnabled := { |
| name := c_LoggingClient_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of the given log class of the given component type on the given client log returned", |
| parameters := { |
| { |
| name := c_LoggingClient_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| }, |
| { |
| name := c_LoggingClient_paramNameClass, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorClasses.typeDescriptor.typeName |
| } |
| }, |
| description := "Name of log class", |
| exampleValue := "Warning" |
| } |
| } |
| } |
| |
| const EPTF_DataSource_Help_DataElement c_LoggingClient_Help_dataElementLogEnabled_withoutParams := { |
| name := c_LoggingClient_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of the client log" |
| } |
| |
| const EPTF_DataSource_Help_DataElement c_LoggingClient_Help_dataElementLogEnabled_paramComponentType := { |
| name := c_LoggingClient_dataElementLogEnabled, |
| valueType := boolType, |
| description := "Enabled state of the component type log on the given client", |
| parameters := { |
| { |
| name := c_LoggingClient_paramNameComponentType, |
| typeDescriptor := { |
| reference := { |
| typeName := c_Logging_Help_iteratorComponentTypes.typeDescriptor.typeName |
| } |
| }, |
| description := "Specifies the component type name which registered its log classes.", |
| exampleValue := "EPTF_Logging" |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_LoggingClient_dataElement_Help |
| // |
| // Purpose: |
| // This data element returns the help information about |
| // all dataElements supported. |
| // ValueType: charstring |
| // |
| // Parameters: |
| // - <c_EPTF_DataSource_paramNameHelpFormat> - the format of the output |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_LoggingClient_dataElement_Help := c_EPTF_DataSource_dataElement_Help; |
| |
| const EPTF_DataSource_Help_DataElement c_EPTF_LoggingClient_Help_dataElement_help := c_EPTF_DataSource_Help_dataElement_genericHelp; |
| |
| // the datasource help database for LoggingClient |
| const EPTF_DataSource_Help_DataElementChildren c_EPTF_LoggingClient_help := { |
| { |
| dataElement := c_EPTF_LoggingClient_Help_dataElement_help |
| }, |
| { |
| dataElement := c_LoggingClient_Help_dataElementLogEnabled |
| }, |
| { |
| dataElement := c_LoggingClient_Help_dataElementLogEnabled_withoutParams |
| }, |
| { |
| dataElement := c_LoggingClient_Help_dataElementLogEnabled_paramComponentType |
| } |
| } |
| |
| |
| //LogEnabled |
| |
| } // end of module |
