/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/
/*
 *
 * CEE configuration records and constants.
 *
 */


module CEECFG {

//
// The following types are used for SKI configuration.
//

//
// !MemoryDebug
//
// If set to true then a number of memory debugging features are enabled.
// Not recommended if high performance is required.
//
// Default is false. (Use CMU -c for current values).
//

   typedef boolean MemoryDebug;



//
// !MaxConfiguredObjects
//
// Maximum number of objects that can be configured with
// CEE_OBJECT_CONFIGURE.
//
// Default is 1024.
//

   typedef unsigned long MaxConfiguredObjects;



//
// !MaxInterfaces
//
// Maximum number of interfaces that can be created with
// CEE_INTERFACE_CREATE.
//
// Default is 256.
//

   typedef unsigned long MaxInterfaces;



//
// !MaxImplementations
//
// Maximum number of implementations that can be created with
// CEE_IMPLEMENTATION_CREATE.
//
// Default is 256.
//

   typedef unsigned long MaxImplementations;



//
// !MaxAsynchIOs
//
// Maximum number of asynchrononous I/O's that can be outstanding
// at any time.
//
// Default is 1024.
//

   typedef unsigned long MaxAsynchIOs;



//
// !MaxObjrefSize
//
// Maximum number of bytes (characters) in an object reference including the
// terminating null.
//
// Default is 128.
//

   typedef unsigned long MaxObjrefSize;



//
// !MaxProxies
//
// Maximum number of proxies that can be created with CEE_PROXY_CREATE.
//
// Default is 10000.
//

   typedef unsigned long MaxProxies;



//
// !MaxObjects
//
// Maximum number of objects. Sum of configured objects and dynamic
// objects created with CEE_OBJECT_CREATE.
//
// Default is 10000.
//

   typedef unsigned long MaxObjects;



//
// !MaxSignalHandlers
//
// Maximum number of signal handlers that can be registered with
// CEE_SIGNAL_HANDLER_REGISTER.
//
// Default is 1024.
//

   typedef unsigned long MaxSignalHandlers;



//
// !MaxCalls
//
// Maximum number of concurrently active object calls.
//
// Default is 10000.
//

   typedef unsigned long MaxCalls;



//
// !MaxServiceContextListLength
//
// Maximum number of elements in a service context list (send or receive).
//
// Default is 2.
//

   typedef unsigned long MaxServiceContextListLength;



//
// !MaxTimers
//
// Maximum number of pending timers.
//
// Default is 10000.
//

   typedef unsigned long MaxTimers;



//
// !MaxTasks
//
// Maximum number of CEE tasks.
//
// Default is 1024.
//

   typedef unsigned long MaxTasks;



//
// !MaxTitaniumSignalTags
//
// Maximum number of Titanium signal tags that can be created with
// CEE_TI_SIGNAL_TAG_CREATE.
//
// Default is 2048.
//

   typedef unsigned long MaxTiSignalTags;



//
// !PoolExtentSizeDivisor
//
// PoolExtentSizeDivisor is used to compute the size of the "chunks"
// the CEE uses to extned its internal memory pools.  Most of the
// "Max*" configuration values define the upper limit on the size of
// the pools.  The initial size of a pool is the "Max*" divided by
// "PoolExtentSizeDivisor". If "PoolExtentSizeDivisor" is 0 or 1, the
// entire pool is allocated at initialization.  If "PoolExtentSizeDivisor"
// is negative, the pool is "grown" in single unit chunks (e.g. one call
// or one proxy).  If "PoolExtentSizeDivisor" is 2, the pool is initially
// half of "Max*" and the other half will be allocated on demand.  If
// "PoolExtentSizeDivisor" is 3, one third is allocated initially and
// the rest on demand.  And so on.
//
// Default is 100.
// 

   typedef unsigned long PoolExtentSizeDivisor;



//
// !Transport
//
// Transport to be used to receive object calls.
//
// Can be:
//
// - CEE_TRANSPORT_NULL (= 1): receive no external object calls
//
// - CEE_TRANSPORT_FSP  (= 2): receive object calls on $RECEIVE
//                             (WRITEREAD or PATHSEND). For Pathway
//                             servers "ServerclassName" must be set.
//                             For associative servers "PathmonName"
//                             must be set.
//
// - CEE_TRANSPORT_TCP  (= 3): receive object calls on socket specified
//                             by "TcpSocketNumber".
//
// - CEE_TRANSPORT_TI   (= 4): receive object calls via Titanium on the
//                             SNOR's derived from "TitaniumServerCapsule".
//
// - CEE_TRANSPORT_SRT  (= 5): pseudo-transport which enables switching
//                             calls between a series of object references
//
// Default is CEE_TRANSPORT_NULL.
//

   typedef unsigned long Transport;



//
// !TcpPortNumber
//
// Port number on which to listen. Used only by servers with the TCP
// transport.
// 
// Default is zero (= use any socket).
//

   typedef unsigned short TcpPortNumber;



//
// !TcpReuseAddress
//
// 
// "TcpReuseAddress" enables or disables the ability to reuse a local
// socket name on more than one socket. If this option is set to true
// (a non-zero value), then it will allow the CEE to listen on a port
// even if this port is already in use. You should avoid using this
// option if possible since its use can have unexpected results. Used
// only by servers with the TCP transport.
// 
// Default is false 
//

   typedef boolean TcpReuseAddress;



//
// !TcpProcessName
//
// TCP process to use for accepting/posting object calls over TCP.
// Used by servers and clients on NSK platforms with the TCP transport.
// 
// Default is $ZTC0 
//

   typedef string TcpProcessName;


//
// !TcpNetwork
//
// Similar to TcpProcessName, on NT and UNIXs "TcpNetwork" contains 
// an Internet address in standard (dot) notation which allows the user
// to configure the network stack on a multihomed system. 
//
// Default is "0.0.0.0" (INADDR_ANY)
//

   typedef string TcpNetwork;

//
// !ServerclassName
//
// Pathway serverclass name. Used only by servers with the FSP transport
// if they are running as Pathway servers.
// 
// Default is empty string (implies server is not a Pathway server).
//
// Example: MY-SERVER
//

   typedef string<15> ServerclassName;



//
// !PathmonName
//
// Pathmon process name under which the server is running. Used only
// by servers with the FSP transport if they are running as Pathway
// servers. If Pathmon process name does not include a node name it is
// assumed to be on the local node.
// 
// Default is process ancestor (implies server is not an associative
// server).
//
// Examples: $MYPM, \MYHOST.$PMON
//

   typedef string<15> PathmonName;




//
// !TitaniumServerCapsule
//
// Used only by servers with the Titanium transport.
//
// Must be specified if "Transport" is set to CEE_TRANSPORT_TI (= 4).
//
// Format is manufacturer-id/object-id. The local site-id, manufacturer-id
// and object-id are used to create a SNOR (site native object reference) 
// for the server capsule's queue.
//
// No default.
//
// Example: 12/4
//

   typedef string TitaniumServerCapsule;




//  
// !TitaniumServerConcurrency
//
// Used only by servers with the Titanium transport. Specifies how many
// outstanding replies a capsule can have. This influences how many
// Titanium server ports are created.
// 
// Default is one.
//
// Example: 100
//

   typedef unsigned long TitaniumServerConcurrency;

   const unsigned long MAX_LIBRARY_NAME_SIZE       =  256;
   const unsigned long MAX_ENTRY_POINT_NAME_SIZE   =   64;
   const unsigned long MAX_PARAM_SIZE              = 1024;
   const unsigned long MIN_OBJREF_SIZE             =   64;



//
// !ObjectConfigTag
//
// Is an entry in the configured object table (see next section). Each
// entry describes one configured object.
//
// <oid>            Object ID.
//
// <vendorID>       Vendor ID (qualifies component ID)
//
// <componentID>    Identifies the implementation library (component)
//                  for alerts etc.
//
// <libraryName>    Name of library containing the objects implementation
//                  and initialization function.
//
// <entrypointName> Name of the object initialization function.
//
// <param>          A parameter that will be passed to the
//                  object initialization function (not used
//                  by the CEE).
//
//

   struct ObjectConfigTag {
      sequence<char>                              oid;
      sequence<char, MAX_LIBRARY_NAME_SIZE>       libraryName;
      sequence<char, MAX_ENTRY_POINT_NAME_SIZE>   entrypointName;
      sequence<char, MAX_PARAM_SIZE>              param;   
   };



//
// !ConfiguredObjectTable
//
// Contains a list of configured objects.
//

   typedef sequence<ObjectConfigTag> ConfiguredObjectTable;



//         
// ! UseBootstrapAlertObject
//
// If set to true (the default) then "ALF_AlertRaise"  will try to
// write a primitive message to "stderr" if the alert object specified
// by "AlertObjref" cannot be called.
//
// If false then "ALF_AlertRaise" has no effect if the alert object is
// unreachable.
//
// Default is "true".
//

   typedef boolean UseBootstrapAlertObject;



//         
// ! AlertObjref
//
// Object reference of the Alert Object to which all alerts are to be sent.
//
// Default is "".
//

   typedef Object AlertObjref;



//
// ! UseTitanium
//
// If set to true the process will attempt to register as a Titanium
// capsule. If this succeeds then it will be possible to make object
// calls using the Titanium transport.
//
// Default is CEE_FALSE.
//

   typedef boolean UseTitanium;



//
// ! ProxyCachingEnabled
//
// If set to true, then on a proxy destroy request an attempt will be
// made to cache the resources associated with the given proxy such
// that they could potentially be reused on a subsequent proxy create
// request.
//
// Default is CEE_TRUE.
//

   typedef boolean ProxyCachingEnabled;



//
// ! MaxProxiesToCache
//
// Defines the maximum number of proxies that the proxy cache may
// hold.
//
// Default is 20.
//

   typedef boolean MaxProxiesToCache;



//         
// ! Trace configuration
//
// The following parameters can be used to override the setting of the
// TRACEINFO, TRACEWARN, TRACEFAIL and TRACEFORMAT environment variables
// so that tracing can also be controlled with SAM.
//

   typedef string TraceInfo;
   typedef string TraceWarn;
   typedef string TraceFail;
   typedef string TraceFormat;
  


//
// !Stub Trace: Client
//
// Enables tracing for client capsules. This parameter is disabled by
// default. If this parameter is set to false then no trace output is
// produced for CEE clients even if TRACEINFO is set to "STUB".
//
// Note that for stubs tracing, TRACEINFO must be set to "STUB".
//
// Default is IDL_FALSE.
//

   typedef boolean TraceClient;



//
// !Stub Trace: Server
//
// Enables tracing for server capsules. This parameter is disabled by
// default. If this parameter is set to false then no trace output is
// produced for CEE servers even if TRACEINFO is set to "STUB".
//
// Note that for stubs tracing, TRACEINFO must be set to "STUB".
//
// Default is IDL_FALSE.
//

   typedef boolean TraceServer;
  

//
// !Stub Trace: ParamDumpLength
//
// This parameter sets the approximate length of operation argument value
// strings which are displayed in trace messages. Parameter Data conversion
// is limited by the "ParamDumpLength" parameter. If this parameter
// equals 0, then no operation arguments are dumped. This parameter is
// set to 200 by default. Note that the maximal trace message is limited
// to 2048 characters.
//

   typedef unsigned long ParamDumpLength;




//
// !Stub Trace: InsertLineBreaks
//
// If true line breaks are inserted in an argument value string for better
// readability. This is advisable when analysing deeply nested data types.
// This parameter is set to false by default.
  
   typedef boolean InsertLineBreaks;



//
// ! StderrFile
//
// The file to which stderr should be redirected.  Trace output is 
// written to stderr and so are bootstrap alerts.
//
// Default is NULL.
//
  typedef string StderrFile;



//         
// ! ServiceResourceEntry
//
// Is an entry in the Service Resource Block (see
// ServiceResourceBlock). Entries have the form:
//
// <type>      defines whether the entry refers to an
//             IMPLEMENTER or a PROVIDER
//
// <objref>    the object reference of the resource
//

  struct ServiceResourceEntry {
    sequence<char>  type;
    sequence<char>  objref;
  };



//         
// ! ServiceResourceBlock
//
// Associates a name with a list of service resource entries.
// The name is then referenced in a statically configured
// SRT (Service Resource Transport) objref. Entries have the
// form:
//
// <name>      service name
//
// <policy>    the name of the policy which governs how
//             object calls are switched between service
//             implementers
//
// <list>      a sequence of service resource entries
//

  struct ServiceResourceBlock {
    sequence<char>                     name;
    sequence<char>                     policy;
    sequence<ServiceResourceEntry>     list;
  };



//
// !ServiceResourceTable
//
// Contains a list of service resource blocks.
//

   typedef sequence<ServiceResourceBlock> ServiceResourceTable;



//
// !Default Asynch Call mode
//
// Default asynch call mode (unsupported)
//
// Default is CEE_CALL_MODE_QUEUE.
//

typedef unsigned long AsynchCallMode;



//
// !Default Asynch Response mode
//
// Default asynch response mode (unsupported)
//
// Default is CEE_RESPONSE_MODE_QUEUE.
//

typedef unsigned long AsynchResponseMode;



//
// !TransactionFactory
//
// The object reference that should be used to create transactions.
//
  typedef Object TransactionFactory;


}; // module CEECFG