///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_LoggingUI_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:
//    Bence Molnar (EBENMOL)
// 
//  Last Review Date:
//    2008-01-29
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////

module EPTF_CLL_LoggingUI_Definitions

{
// if you use EPTF_Generic_Logger_CT you have to import these
import from EPTF_CLL_Logging_Definitions all
// if you use EPTF_Var_CT you have to import these
import from EPTF_CLL_Variable_Definitions all;
// if you use EPTF_IntegerList you have to import these
import from EPTF_CLL_Common_Definitions all;
// if you use UIHandler&XUL you have to import these
import from EPTF_CLL_UIHandlerClient_Definitions all;

import from EPTF_CLL_HashMap_Definitions all;

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_LoggingUI_resp
//
//  Purpose:
//     <EPTF_LoggingUI_Resp_Type> type constant.
//    
///////////////////////////////////////////////////////////

const EPTF_LoggingUI_Msg c_EPTF_LoggingUI_resp:={
  LoggingUI_Resp:={
    Message:=OK
  }
}

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_LoggingUI_hello
//
//  Purpose:
//     <EPTF_LoggingUI_Hello_Type> type constant.
//    
///////////////////////////////////////////////////////////

const EPTF_LoggingUI_Msg c_EPTF_LoggingUI_hello:={
  LoggingUI_Hello:={
    Message:=Hello
  }
}

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_LoggingUI_bye 
//
//  Purpose:
//     <EPTF_LoggingUI_Bye_Type> type constant.
//    
///////////////////////////////////////////////////////////

const EPTF_LoggingUI_Msg c_EPTF_LoggingUI_bye:={
  LoggingUI_Bye:={
    Message:=Bye
  }
}

///////////////////////////////////////////////////////////
//  Template: tr_EPTF_LoggingUI_req template
//
//  Purpose:
//     <EPTF_LoggingUI_Req_Type> type template, for receiving request messages.
//    
///////////////////////////////////////////////////////////

template EPTF_LoggingUI_Msg tr_EPTF_LoggingUI_req:={
  LoggingUI_Req:={
    Request:=Init,
    compName:=?,
    compType:=?,
    selection:=?,
    eventClassNames:={*}
  }
}

///////////////////////////////////////////////////////////
//  Type: EPTF_LoggingUI_Req_Type 
//
//  Purpose:
//     Reqest Type message.
// 
//  Elements:
//     Request - <EPTF_LoggingUI_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 loggingUI component.
//    The client sends its name,type, and logmask. with the help of this message the main 
//    loggingUI component makes the component types tab.
//
///////////////////////////////////////////////////////////

type record EPTF_LoggingUI_Req_Type
{
  EPTF_LoggingUI_Msg_types Request,
  charstring compName,
  charstring compType,
  integer selection,
  EPTF_Logging_EventClassPrefixList eventClassNames
}

///////////////////////////////////////////////////////////
//  Type: EPTF_LoggingUI_Resp_Type
//
//  Purpose:
//     Response Type message.
// 
//  Elements:
//     Response - <EPTF_LoggingUI_Msg_types> - The response message
// 
//  Detailed Comments:
//    The response message. The loggingUI and loggingUI 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 LoggingUI maintain the number of connected clients.
//    
//////////////////////////////////////////////////////////

type record EPTF_LoggingUI_Resp_Type
{
  EPTF_LoggingUI_Msg_types Message
} 

///////////////////////////////////////////////////////////
//  Type: EPTF_LoggingUI_Msg_types
// 
//  Purpose:
//     Enumerated type for chosing LoggingUI 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 LoggingUI message types. 
///////////////////////////////////////////////////////////  

type enumerated EPTF_LoggingUI_Msg_types {Hello(0), Init(1), OK(2), Bye(3)}

///////////////////////////////////////////////////////////
//  Type: EPTF_LoggingUI_Msg 
//
//  Purpose:
//     The union of LoggingUI messages.
// 
//  Elements:
//     LoggingUI_Req - <EPTF_LoggingUI_Req_Type> - The request message
//     LoggingUI_Resp - <EPTF_LoggingUI_Resp_Type> - The response message
//     LoggingUI_Hello - <EPTF_LoggingUI_Resp_Type> - The Hello message
//     LoggingUI_Bye - <EPTF_LoggingUI_Resp_Type> - The Bye message
// 
//  Detailed Comments:
//    All loggingUI messages.
//    
///////////////////////////////////////////////////////////  

type union EPTF_LoggingUI_Msg
{
  EPTF_LoggingUI_Req_Type LoggingUI_Req,
  EPTF_LoggingUI_Resp_Type LoggingUI_Resp,
  EPTF_LoggingUI_Resp_Type LoggingUI_Hello,
  EPTF_LoggingUI_Resp_Type LoggingUI_Bye
}

///////////////////////////////////////////////////////////
//  Type: EPTF_LoggingUIPort_PT
// 
//  Purpose:
//     Internal message port type for exchanging configuration messages.
// 
//  Elements:
// 
//  Detailed Comments:
//    Can bothway send messages
///////////////////////////////////////////////////////////

type port EPTF_LoggingUIPort_PT message {
  inout EPTF_LoggingUI_Msg;
} with {extension "internal"}

///////////////////////////////////////////////////////////
//  Component: EPTF_LoggingUIClient_CT
// 
//  Purpose:
//     Component type for EPTF LoggingUI Client interface.
// 
//  Elements:
//    v_EPTF_LoggingUI_main - <EPTF_LoggingUI_CT> - the main loggingUI component
//    v_EPTF_LoggingUI_allComponentLocalEnableIdx - *integer* - the EPTF variable ID of v_EPTF_Logging_allComponentLocalEnable
//    v_EPTF_LoggingUI_componentLocalEnableIdx - <EPTF_IntegerList> - the EPTF variable ID of v_EPTF_componentLocalEnable, integerlist
//    v_EPTF_LoggingUI_componentLocalMaskIdx - <EPTF_IntegerArray2D> - the EPTF variable ID of v_EPTF_componentLocalMask, 2D integermatrix
//    v_EPTF_LoggingUIClient_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_LoggingUIClient_CT extends EPTF_Logging_CT, EPTF_Var_CT, EPTF_UIHandlerClient_CT {
  private port EPTF_LoggingUIPort_PT EPTF_LoggingUIClientPort_CP;

  private var EPTF_LoggingUI_CT v_EPTF_LoggingUI_main;
  private var integer v_EPTF_LoggingUI_allComponentLocalEnableIdx;
  private var EPTF_IntegerList v_EPTF_LoggingUI_componentLocalEnableIdx;
  private var EPTF_IntegerArray2D v_EPTF_LoggingUI_componentLocalMaskIdx;
  private var boolean v_EPTF_LoggingUIClient_initialized := false;
}

///////////////////////////////////////////////////////////
//  Constant: c_EPTF_LoggingUI_typesLookupTable_HashName 
//
//  Purpose:
//     Constant for the name of the Hashmap used for a lookupTable for types.
//    
///////////////////////////////////////////////////////////
const charstring c_EPTF_LoggingUI_typesLookupTable_HashName := "typesLookupTable";

///////////////////////////////////////////////////////////
//  Component: EPTF_LoggingUI_CT
// 
//  Purpose:
//     Component type for EPTF main LoggingUI interface.
// 
//  Elements:
//    v_EPTF_LoggingUI_def - *default* - default altstep in main LoggingUI component
//    v_EPTF_LoggingUI_allComponentGlobalEnableIdx - *integer* - the EPTF variable ID of v_EPTF_allComponentGlobalEnable
//    v_EPTF_LoggingUI_componentGlobalEnableIdx - <EPTF_IntegerArray2D> - the EPTF variable id of <EPTF_Logging_LogMaskList> ComponentGlobalEnable
//    v_EPTF_LoggingUI_componentGlobalMaskIdx - <LoggingUI_IntegerArray3D> - the EPTF variable ID of <EPTF_Logging_LogMaskList> ComponentGlobalMask
//    v_EPTF_LoggingUI_typesLookupTableName - *charstring* - name of the component types lookup table HashMap
//    v_EPTF_LoggingUI_typesLookupTableID - *integer* - the returned ID of the component types lookup table HashMap
//    v_EPTF_LoggingUI_typesID - *integer* - the generated ID of the component types
//    v_EPTF_LoggingUI_tabboxName - *charstring* - name of the tabbox where the LoggingUI has to be created on the GUI
//    v_EPTF_LoggingUI_numberOfClients - *integer* - the number of connected clients
//    v_EPTF_LoggingUI_allowReq - *boolean* - true if new request message processing allowed
//    v_EPTF_LoggingUI_initialized - *boolean* - true if loggingUI is initalized with its init function
//
//  Detailed Comments:
//    LoggingUI main component. There always have to be one main component.
//     
/////////////////////////////////////////////////////////// 

type component EPTF_LoggingUI_CT extends EPTF_Logging_CT, EPTF_Var_CT, EPTF_UIHandlerClient_CT, EPTF_HashMap_CT {
  private port EPTF_LoggingUIPort_PT EPTF_LoggingUIPort_CP;

  private var default v_EPTF_LoggingUI_def := null;
  private var integer v_EPTF_LoggingUI_allComponentGlobalEnableIdx;
  private var EPTF_IntegerArray2D v_EPTF_LoggingUI_componentGlobalEnableIdx;
  private var LoggingUI_IntegerArray3D v_EPTF_LoggingUI_componentGlobalMaskIdx;
  private var charstring v_EPTF_LoggingUI_typesLookupTableName;
  private var integer v_EPTF_LoggingUI_typesLookupTableID;
  private var integer v_EPTF_LoggingUI_typesID;
  private var charstring v_EPTF_LoggingUI_tabboxName;
  private var integer v_EPTF_LoggingUI_numberOfClients;
  private var boolean v_EPTF_LoggingUI_allowReq := true;
  private var boolean v_EPTF_LoggingUI_initialized := false;

}

type record of EPTF_IntegerArray2D LoggingUI_IntegerArray3D;

}  // end of module