///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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