orbparameters.h

编译工具

//   handle indirections properly.
//  
//   Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::Boolean  acceptMisalignedTcIndirections;
//   If true, try to fix a mis-aligned indirection in a typecode. This
//   could be used to work around some versions of Visibroker's Java ORB.
//  
//   Valid values = 0 or 1


///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//                                                                       //
//                    Client Side Parameters                             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

_CORBA_MODULE_VAR _core_attr CORBA::Boolean verifyObjectExistsAndType;
//  If the value of this variable is 0 then the ORB will not
//  send a GIOP LOCATE_REQUEST message to verify the existence of
//  the object prior to the first invocation. Set this variable
//  if the other end is a buggy ORB that cannot handle GIOP
//  LOCATE_REQUEST. 
//
//  Valid values = 0 or 1


_CORBA_MODULE_VAR _core_attr CORBA::Boolean oneCallPerConnection;
//  1 means only one call can be in progress at any time per connection.
//
//  Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::ULong maxGIOPConnectionPerServer;
//  The ORB could open more than one connection to a server
//  depending on the number of concurrent invocations to the same
//  server. This variable decides the maximum number of connections 
//  to use per server. This variable is read only once at ORB_init.
//  If the number of concurrent invocations exceeds this number, the
//  extra invocations are blocked until the the outstanding ones
//  return.
//
//  Valid values = (n >= 1) 


_CORBA_MODULE_VAR _core_attr GIOP::AddressingDisposition giopTargetAddressMode;
//  On the client side, if it is to use GIOP 1.2 or above to talk to a 
//  server, use this Target Address Mode.
//
//  Valid values = 0 (GIOP::KeyAddr)
//                 1 (GIOP::ProfileAddr)
//                 2 (GIOP::ReferenceAddr)


_CORBA_MODULE_VAR _core_attr CORBA::Boolean offerBiDirectionalGIOP;
//   Applies to the client side. Set to 1 to indicates that the
//   ORB may choose to use a connection to do bidirectional GIOP
//   calls. Set to 0 means the ORB should never do bidirectional.
//
//   Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::Boolean  diiThrowsSysExceptions;
// If the value of this variable is 1 then the Dynamic Invacation Interface
// functions (Request::invoke, send_oneway, send_deferred, get_response,
// poll_response) will throw system exceptions as appropriate. Otherwise 
// the exception will be stored in the Environment pseudo object associated
// with the Request. By default system exceptions are passed through the 
// Environment object.
//
// Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::ULong outConScanPeriod;
//  Idle connections shutdown. The ORB periodically scans all the
//  incoming connections to detect if they are idle.
//  If no operation has passed through a connection for a scan period,
//  the ORB would treat this connection idle and shut it down.
//
//  Valid values = (n >= 0 in seconds) 
//                  0 --> do not close idle connections.

_CORBA_MODULE_VAR _core_attr timeValue clientCallTimeOutPeriod;
//   Call timeout. On the client side, if a remote call takes longer
//   than the timeout value, the ORB will shutdown the connection and
//   raise a COMM_FAILURE.
//
//   Valid values = (n >= 0 in milliseconds) 
//                   0 --> no timeout. Block till a reply comes back

_CORBA_MODULE_VAR _core_attr CORBA::Boolean supportPerThreadTimeOut;
//   If true, each thread may have a timeout associated with it. This
//   gives a performance hit due to accessing per-thread data.
//
//   Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::String_var bootstrapAgentHostname;
// Applies to the client side. Non-zero enables the use of Sun's bootstrap
// agent protocol to resolve initial references. The value is the host name
// where requests for initial references should be sent. Only uses this
// option to interoperate with Sun's javaIDL.

_CORBA_MODULE_VAR _core_attr CORBA::UShort bootstrapAgentPort;
// Applies to the client side. Use this port no. to contact the bootstrap 
// agent.


///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//                                                                       //
//                    Server Side Parameters                             //
//                                                                       //
///////////////////////////////////////////////////////////////////////////


_CORBA_MODULE_VAR _core_attr CORBA::Boolean threadPerConnectionPolicy;
//   1 means the ORB should dedicate one thread per connection on the 
//   server side. 0 means the ORB should dispatch a thread from a pool
//   to a connection only when a request has arrived.
//
//  Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::ULong   threadPerConnectionUpperLimit;
//   If the one thread per connection is in effect, this number is
//   the max. no. of connections the server will allow before it
//   switch off the one thread per connection policy and move to
//   the thread pool policy.
//
//   Valid values = (n >= 1) 

_CORBA_MODULE_VAR _core_attr CORBA::ULong   threadPerConnectionLowerLimit;
//   If the one thread per connection was in effect and was switched
//   off because threadPerConnectionUpperLimit has been exceeded
//   previously, this number tells when the policy should be restored
//   when the number of connections drop.
//
//   Valid values = (n >= 1 && n < threadPerConnectionUpperLimit) 

_CORBA_MODULE_VAR _core_attr CORBA::ULong   maxServerThreadPerConnection;
//   The max. no. of threads the server will dispatch to server the
//   requests coming from one connection.
//
//   Valid values = (n >= 1) 

_CORBA_MODULE_VAR _core_attr CORBA::ULong   maxServerThreadPoolSize;
//   The max. no. of threads the server will allocate to do various
//   ORB tasks. This number does not include the dedicated thread
//   per connection when the threadPerConnectionPolicy is in effect
//
//   Valid values = (n >= 1) 

_CORBA_MODULE_VAR _core_attr CORBA::ULong   threadPoolWatchConnection;
//   After dispatching an upcall in thread pool mode, the thread that
//   has just performed the call can watch the connection for a short
//   time before returning to the pool. This leads to less thread
//   switching for a series of calls from a single client, but is less
//   fair if there are concurrent clients. The connection is watched
//   if the number of threads concurrently handling the connection is
//   <= the value of this parameter. i.e. if the parameter is zero,
//   the connection is never watched; if it is 1, the last thread
//   managing a connection watches it; if 2, the connection is still
//   watched if there is one other thread still in an upcall for the
//   connection, and so on.
//
//  Valid values = (n >= 0)

_CORBA_MODULE_VAR _core_attr CORBA::Boolean acceptBiDirectionalGIOP;
//   Applies to the server side. Set to 1 to indicates that the
//   ORB may choose to accept a clients offer to use bidirectional
//   GIOP calls on a connection. Set to 0 means the ORB should
//   never accept any bidirectional offer and should stick to normal
//   GIOP.
//
//   Valid values = 0 or 1

_CORBA_MODULE_VAR _core_attr CORBA::ULong   maxInterleavedCallsPerConnection;
//  No. of interleaved calls per connection the server is prepared
//  to accept. If this number is exceeded, the connection is closed.
//
//  Valid values = (n >= 1) 

_CORBA_MODULE_VAR _core_attr CORBA::ULong  inConScanPeriod;
//  Idle connections shutdown. The ORB periodically scans all the
//  outgoing connections to detect if they are idle.
//  If no operation has passed through a connection for a scan period,
//  the ORB would treat this connection idle and shut it down.
//
//   Valid values = (n >= 0 in seconds) 
//                   0 --> do not close idle connections.


_CORBA_MODULE_VAR _core_attr timeValue serverCallTimeOutPeriod;
//   Call timeout. On the server side, if the ORB cannot completely 
//   unmarshal a call's arguments in the defined timeout, it shutdown the
//   connection.
//
//   Valid values = (n >= 0 in milliseconds) 
//                   0 --> no timeout.

_CORBA_MODULE_VAR _core_attr CORBA::ULong poaHoldRequestTimeout;
//  This variable can be used to set a time-out for calls being held
//  in a POA which is in the HOLDING state.  It gives the time in
//  seconds after which a TRANSIENT exception will be thrown if the
//  POA is not transitioned to a different state.
//
//  Valid values = (n >= 0 in milliseconds) 
//                  0 --> no time-out.

_CORBA_MODULE_VAR _core_attr CORBA::String_var unixTransportDirectory;
//  Applies to the server side. Determine the directory in which
//  the unix domain socket is to be created.
//
//  Valid values = a valid pathname for a directory


_CORBA_MODULE_VAR _core_attr CORBA::UShort unixTransportPermission;
//  Applies to the server side. Determine the permission mode bits
//  the unix domain socket is set to.
//
//  Valid values = unix permission mode bits in octal radix (e.g. 0755)

_CORBA_MODULE_VAR _core_attr CORBA::Boolean supportBootstrapAgent;
//  Applies to the server side. 1 means enable the support for Sun's
//  bootstrap agent protocol.  This enables interoperability between omniORB
//  servers and Sun's javaIDL clients. When this option is enabled, an
//  omniORB server will response to a bootstrap agent request.

_CORBA_MODULE_VAR _core_attr _CORBA_Unbounded_Sequence_Octet persistentId;
//  Persistent identifier used to detect object references that should
//  be considered to be in this process.

_CORBA_MODULE_VAR _core_attr CORBA::Boolean connectionWatchImmediate;
//  If true, connections are watched immediately while an upcall is
//  handled; otherwise, they are not watched until the
//  SocketCollection next scans the connection list.

_CORBA_MODULE_END

OMNI_NAMESPACE_END(omni)

#undef _core_attr

#endif // __ORBPARAMETERS_H__