orbconf.h
Go to the documentation of this file.
00001 // -*- C++ -*- 00002 00003 //============================================================================= 00004 /** 00005 * @file orbconf.h 00006 * 00007 * $Id: orbconf.h 84936 2009-03-23 09:55:43Z johnnyw $ 00008 * 00009 * Build configuration file. 00010 * 00011 * @author Copyright 1995 by Sun Microsystems, Inc. 00012 * @author Chris Cleeland 00013 * @author Douglas C. Schmidt 00014 */ 00015 //============================================================================= 00016 00017 #ifndef TAO_ORBCONF_H 00018 #define TAO_ORBCONF_H 00019 00020 #include /**/ "ace/pre.h" 00021 00022 #include "ace/Basic_Types.h" 00023 #include "ace/Global_Macros.h" 00024 #include "ace/Synch_Traits.h" 00025 00026 #if !defined (ACE_LACKS_PRAGMA_ONCE) 00027 # pragma once 00028 #endif /* ACE_LACKS_PRAGMA_ONCE */ 00029 00030 #include /**/ "tao/Versioned_Namespace.h" 00031 00032 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00033 00034 #define TAO_INVALID_PRIORITY -1 00035 00036 #if !defined (TAO_REACTOR) 00037 #define TAO_REACTOR ACE_Select_Reactor 00038 #endif /* TAO_REACTOR */ 00039 00040 #if !defined (TAO_NULL_LOCK_REACTOR) 00041 #define TAO_NULL_LOCK_REACTOR ACE_Select_Reactor_T< ACE_Reactor_Token_T<ACE_Noop_Token> > 00042 #endif /* TAO_NULL_LOCK_REACTOR */ 00043 00044 //FUZZ: disable check_for_ACE_SYNCH_MUTEX 00045 // Define this to modify the default mutex type used throughout TAO. 00046 #if !defined (TAO_SYNCH_MUTEX) 00047 #define TAO_SYNCH_MUTEX ACE_SYNCH_MUTEX 00048 #endif /* TAO_SYNCH_MUTEX */ 00049 //FUZZ: enable check_for_ACE_SYNCH_MUTEX 00050 00051 #if !defined (TAO_SYNCH_RECURSIVE_MUTEX) 00052 #define TAO_SYNCH_RECURSIVE_MUTEX ACE_SYNCH_RECURSIVE_MUTEX 00053 #endif /* TAO_SYNCH_RECURSIVE_MUTEX */ 00054 00055 #if !defined (TAO_SYNCH_RW_MUTEX) 00056 #define TAO_SYNCH_RW_MUTEX ACE_SYNCH_RW_MUTEX 00057 #endif /* TAO_SYNCH_RW_MUTEX */ 00058 00059 #if !defined (TAO_SYNCH_CONDITION) 00060 #define TAO_SYNCH_CONDITION ACE_SYNCH_CONDITION 00061 #endif /* TAO_SYNCH_CONDITION */ 00062 00063 // Define this if you don't want POA timestamps in the IOR. Remember, 00064 // without timestamps, transient and persistent POA cannot be 00065 // distinguished. 00066 #if !defined (POA_NO_TIMESTAMP) 00067 # define POA_NO_TIMESTAMP 0 00068 #endif /* POA_NO_TIMESTAMP */ 00069 00070 // If set the ORB will use dotted decimal addresses in the IIOP IORs 00071 // it exports. This is useful for platforms or environments that 00072 // cannot depend on a DNS being available. This macro only affects 00073 // the server side of a TAO-based CORBA application. If we are on Win32 00074 // the DNS is perenially broken. Set it to 1 regardless. 00075 #if !defined (TAO_USE_DOTTED_DECIMAL_ADDRESSES) && defined (ACE_WIN32) 00076 # define TAO_USE_DOTTED_DECIMAL_ADDRESSES 1 00077 #endif /*TAO_USE_DOTTED_DECIMAL_ADDRESSES*/ 00078 00079 #if !defined (TAO_USE_DOTTED_DECIMAL_ADDRESSES) 00080 # define TAO_USE_DOTTED_DECIMAL_ADDRESSES 0 00081 #endif /* TAO_USE_DOTTED_DECIMAL_ADDRESSES */ 00082 00083 // If set the ORB will use codeset negotiation. This means adding a 00084 // Codeset component to each profile in an IOR, and a codeset context 00085 // to the first request. The use of codeset negotiation also causes 00086 // libTAO_Codeset to be linked in. 00087 #if !defined (TAO_NEGOTIATE_CODESETS) 00088 # define TAO_NEGOTIATE_CODESETS 1 00089 #endif /*TAO_NEGOTIATE_CODESETS*/ 00090 00091 // The default size of TAO's ORB table, i.e. the one used as the 00092 // underlying implementation for the CORBA::ORB_init() function. 00093 #if !defined (TAO_DEFAULT_ORB_TABLE_SIZE) 00094 const size_t TAO_DEFAULT_ORB_TABLE_SIZE = 16; 00095 #endif /* !TAO_DEFAULT_ORB_TABLE_SIZE */ 00096 00097 // The default size of TAO's adapter registry. 00098 #if !defined (TAO_DEFAULT_ADAPTER_REGISTRY_SIZE) 00099 const size_t TAO_DEFAULT_ADAPTER_REGISTRY_SIZE = 16; 00100 #endif /* !TAO_DEFAULT_ORB_TABLE_SIZE */ 00101 00102 // The default size of the reply dispatcher table, ie. if the reply 00103 // dispatcher strategy needs a table to maintain association between 00104 // request id's and reply dispatchers 00105 #if !defined (TAO_RD_TABLE_SIZE) 00106 const size_t TAO_RD_TABLE_SIZE = 16; 00107 #endif /* !TAO_RD_TABLE_SIZE */ 00108 00109 // The default size of TAO's policy factory registry, i.e. the map 00110 // used as the underlying implementation for the 00111 // PortableInterceptor::ORBInitInfo::register_policy_factory() method. 00112 #if !defined (TAO_DEFAULT_POLICY_FACTORY_REGISTRY_SIZE) 00113 const size_t TAO_DEFAULT_POLICY_FACTORY_REGISTRY_SIZE = 64; 00114 #endif /* !TAO_DEFAULT_ORB_TABLE_SIZE */ 00115 00116 // Should we use parallel connect 00117 #if !defined (TAO_USE_PARALLEL_CONNECT) 00118 const bool TAO_USE_PARALLEL_CONNECT = false; 00119 #endif /* !TAO_USE_PARALLEL_CONNECT */ 00120 00121 #if !defined (TAO_ACCEPT_ERROR_DELAY) 00122 const time_t TAO_ACCEPT_ERROR_DELAY = 5; 00123 #endif /* TAO_ACCEPT_ERROR_DELAY */ 00124 00125 #if !defined (TAO_SO_LINGER) 00126 const int TAO_SO_LINGER = -1; 00127 #endif /* TAO_SO_LINGER */ 00128 00129 // The default size of TAO's initial object reference table, i.e. the 00130 // one used as the underlying implementation for the 00131 // CORBA::ORB::register_initial_reference() and 00132 // PortableInterceptor::ORBInitInfo::register_initial_reference() 00133 // methods. 00134 #if !defined (TAO_DEFAULT_OBJECT_REF_TABLE_SIZE) 00135 const size_t TAO_DEFAULT_OBJECT_REF_TABLE_SIZE = 256; 00136 #endif /* !TAO_DEFAULT_ORB_TABLE_SIZE */ 00137 00138 // The default size of TAO's ValueFactory table, i.e. the 00139 // one used as the underlying implementation for the 00140 // CORBA::ORB::register_value_factory() method. 00141 #if !defined (TAO_DEFAULT_VALUE_FACTORY_TABLE_SIZE) 00142 const size_t TAO_DEFAULT_VALUE_FACTORY_TABLE_SIZE = 128; 00143 #endif /* !TAO_DEFAULT_ORB_TABLE_SIZE */ 00144 00145 00146 // The default size of TAO's server active object map. 00147 #if !defined (TAO_DEFAULT_SERVER_ACTIVE_OBJECT_MAP_SIZE) 00148 # if defined (TAO_DEFAULT_SERVER_OBJECT_TABLE_SIZE) 00149 // 00150 // TAO_DEFAULT_SERVER_OBJECT_TABLE_SIZE is deprecated. Please use 00151 // TAO_DEFAULT_SERVER_ACTIVE_OBJECT_MAP_SIZE. 00152 // 00153 # define TAO_DEFAULT_SERVER_ACTIVE_OBJECT_MAP_SIZE TAO_DEFAULT_SERVER_OBJECT_TABLE_SIZE 00154 # else 00155 # define TAO_DEFAULT_SERVER_ACTIVE_OBJECT_MAP_SIZE 64 00156 # endif /* TAO_DEFAULT_SERVER_OBJECT_TABLE_SIZE */ 00157 #endif /* ! TAO_DEFAULT_SERVER_ACTIVE_OBJECT_MAP_SIZE */ 00158 00159 // The default size of TAO's server poa map. 00160 #if !defined (TAO_DEFAULT_SERVER_POA_MAP_SIZE) 00161 # define TAO_DEFAULT_SERVER_POA_MAP_SIZE 24 00162 #endif /* ! TAO_DEFAULT_SERVER_POA_MAP_SIZE */ 00163 00164 // The default timeout receiving the location request to the TAO 00165 // Naming, Trading and other servicesService. 00166 #if !defined (TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT) 00167 #define TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT 10 00168 #endif /* TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT */ 00169 00170 // The default starting port number for TAO servers. 00171 // @@ This assumes we are using one or more protocols that will all 00172 // @@ 1) know what to do with a port number and 00173 // @@ 2) use the same default port number. 00174 // @@ This should go away! 00175 #if !defined (TAO_DEFAULT_SERVER_PORT) 00176 #define TAO_DEFAULT_SERVER_PORT 0 00177 #endif /* TAO_DEFAULT_SERVER_PORT */ 00178 00179 // TAO's max buffer size 00180 #if !defined (TAO_MAXBUFSIZE) 00181 #define TAO_MAXBUFSIZE 1024 00182 #endif /* TAO_MAXBUFSIZE */ 00183 00184 #if !defined (TAO_CONNECTION_PURGING_STRATEGY) 00185 # define TAO_CONNECTION_PURGING_STRATEGY TAO_Resource_Factory::LRU 00186 #endif /* TAO_CONNECTION_PURGING_STRATEGY */ 00187 00188 #if !defined (TAO_PURGE_PERCENT) 00189 # define TAO_PURGE_PERCENT 20 00190 #endif /* TAO_PURGE_PERCENT */ 00191 00192 #if !defined (TAO_CONNECTION_CACHE_MAXIMUM) 00193 // If for some reason you configure the maximum number of handles in 00194 // your OS to some astronomical value, then you should override this 00195 // macro to be a smaller value, e.g., NOFILES or FD_SETSIZE. 00196 # define TAO_CONNECTION_CACHE_MAXIMUM (ACE::max_handles () / 2) 00197 #endif /* TAO_CONNECTION_CACHE_MAXIMUM */ 00198 00199 // This definition theoretically is not required. Just leaving it here 00200 // for backward compatibility 00201 #define TAO_NAMESPACE_STORAGE_CLASS extern TAO_EXPORT_MACRO 00202 00203 # if defined (_MSC_VER) && defined (__ACE_INLINE__) 00204 # define TAO_NAMESPACE_INLINE_FUNCTION inline 00205 # else 00206 # define TAO_NAMESPACE_INLINE_FUNCTION TAO_NAMESPACE_STORAGE_CLASS 00207 # endif 00208 00209 #if !defined(TAO_NO_COPY_OCTET_SEQUENCES) 00210 # define TAO_NO_COPY_OCTET_SEQUENCES 1 00211 #endif /* TAO_NO_COPY_OCTET_SEQUENCES */ 00212 00213 #define TAO_HAS_EXCEPTIONS 00214 00215 // BC++ seems to have a different convention for detecting Win32 than 00216 // VC++. 00217 00218 #if defined (__WIN32__) 00219 # if !defined(_WIN32) 00220 # define _WIN32 00221 # endif /* !defined(_WIN32) */ 00222 #endif /* __WIN32__ */ 00223 00224 // Define if your processor does not store words with the most significant 00225 // byte first. 00226 00227 // @todo It seems to be that this definition of TAO_ENCAP_BYTE_ORDER 00228 // should be removed. We have an equivalent ACE definition in 00229 // ACE_CDR_BYTE_ORDER. Today both of them are consistent. It would be 00230 // a havoc if oneday this consistency is gone.. 00231 #if defined (ACE_LITTLE_ENDIAN) 00232 # define TAO_ENCAP_BYTE_ORDER 1 /* little endian encapsulation byte order has 00233 the value = 1 */ 00234 #else /* ! ACE_LITTLE_ENDIAN */ 00235 # define TAO_ENCAP_BYTE_ORDER 0 /* big endian encapsulation byte order has 00236 the value = 0 */ 00237 #endif /* ! ACE_LITTLE_ENDIAN */ 00238 00239 // Define as the return type of signal handlers (int or void). 00240 #define RETSIGTYPE void 00241 00242 // Define if you don't have vprintf but do have _doprnt. 00243 /* #undef HAVE_DOPRNT */ 00244 00245 // Define if you have the vprintf function. 00246 #define HAVE_VPRINTF 1 00247 00248 // Comment out to enable only ACE monitors... 00249 #if defined (ACE_HAS_MONITOR_FRAMEWORK) && (ACE_HAS_MONITOR_FRAMEWORK == 1) 00250 # define TAO_HAS_MONITOR_FRAMEWORK 1 00251 #else 00252 # define TAO_HAS_MONITOR_FRAMEWORK 0 00253 #endif /* ACE_HAS_MONITOR_FRAMEWORK*/ 00254 00255 #if !defined (TAO_HAS_MONITOR_POINTS) 00256 # define TAO_HAS_MONITOR_POINTS ACE_HAS_MONITOR_POINTS 00257 #endif 00258 00259 #if !defined (TAO_HAS_ZIOP) 00260 # define TAO_HAS_ZIOP 0 00261 #endif 00262 00263 // Avoid namespace pollution that's common on older UNIXes... 00264 #if defined (minor) 00265 #undef minor 00266 #endif /* minor */ 00267 00268 #if defined (major) 00269 #undef major 00270 #endif /* major*/ 00271 00272 #if !defined (TAO_EXPORT_NESTED_CLASSES) \ 00273 && defined (ACE_EXPORT_NESTED_CLASSES) 00274 #define TAO_EXPORT_NESTED_CLASSES 00275 #endif /* !defined TAO_EXPORT_NESTED_CLASSES */ 00276 00277 #if !defined (TAO_EXPORT_NESTED_MACRO) 00278 #define TAO_EXPORT_NESTED_MACRO 00279 #endif /* !defined (TAO_EXPORT_NESTED_MACRO) */ 00280 00281 // Assume DOS/Windows if "configure" didn't get run. 00282 00283 #if defined (_MSC_VER) 00284 // "C4355: 'this' : used in base member initializer list" 00285 # pragma warning (disable:4355) /* disable C4355 warning */ 00286 #endif /* defined (_MSC_VER) */ 00287 00288 // The Root POA default name. 00289 #if !defined (TAO_DEFAULT_ROOTPOA_NAME) 00290 #define TAO_DEFAULT_ROOTPOA_NAME "RootPOA" 00291 #endif /* TAO_DEFAULT_ROOTPOA_NAME */ 00292 00293 #if !defined (TAO_DEFAULT_ROOTPOAMANAGER_NAME) 00294 #define TAO_DEFAULT_ROOTPOAMANAGER_NAME "RootPOAManager" 00295 #endif /* TAO_DEFAULT_ROOTPOAMANAGER_NAME */ 00296 00297 // The default lane name used when storing endpoints. 00298 #if !defined (TAO_DEFAULT_LANE) 00299 #define TAO_DEFAULT_LANE "default lane" 00300 #endif /* TAO_DEFAULT_LANE */ 00301 00302 // Minimum CORBA 00303 #if !defined (TAO_HAS_MINIMUM_CORBA) 00304 # define TAO_HAS_MINIMUM_CORBA 0 00305 #endif /* TAO_HAS_MINIMUM_CORBA */ 00306 00307 /// Default IIOP settings 00308 #if !defined (TAO_HAS_IIOP) 00309 # define TAO_HAS_IIOP 1 00310 #endif /* !TAO_HAS_IIOP */ 00311 00312 /// Default DIOP settings 00313 #if !defined (TAO_HAS_DIOP) 00314 # define TAO_HAS_DIOP 1 00315 #endif /* !TAO_HAS_DIOP */ 00316 00317 /// Default SCIOP Settings 00318 /// SCIOP is disabled by default (i.e. TAO_HAS_SCIOP is undef) 00319 /// to enable SCIOP, make with sctp=openss7 option on command line. 00320 /// See $ACE_ROOT/performance-tests/SCTP/README for more info. 00321 #if !defined (TAO_HAS_SCIOP) 00322 # if defined (ACE_HAS_SCTP) 00323 # define TAO_HAS_SCIOP 1 00324 # define TAO_DEF_SCIOP_MAJOR 1 00325 # define TAO_DEF_SCIOP_MINOR 0 00326 # else 00327 # define TAO_HAS_SCIOP 0 00328 # endif /* ACE_HAS_SCTP */ 00329 #endif /* !TAO_HAS_SCIOP */ 00330 00331 // UIOP support is enabled by default if the platform supports UNIX 00332 // domain sockets, and TAO is not configured for minimum CORBA. 00333 // If TAO is configured for minimum CORBA, then UIOP will be disabled 00334 // by default. 00335 // To explicitly enable UIOP support uncomment the following 00336 // #define TAO_HAS_UIOP 1 00337 // To explicitly disable UIOP support uncomment the following 00338 // #define TAO_HAS_UIOP 0 00339 00340 // Default UIOP settings 00341 #if !defined (TAO_HAS_UIOP) 00342 # if defined (ACE_LACKS_UNIX_DOMAIN_SOCKETS) 00343 # define TAO_HAS_UIOP 0 00344 # else 00345 # define TAO_HAS_UIOP 1 00346 # endif /* ACE_LACKS_UNIX_DOMAIN_SOCKETS */ 00347 #endif /* !TAO_HAS_UIOP */ 00348 00349 // NSKPW and NSKFS are Pluggable Protocols used on the Tandem 00350 // platform. These are disabled by default. 00351 00352 #if defined (TAO_HAS_NSKPW) 00353 #define TAO_DEF_NSKPW_MAJOR 1 00354 #define TAO_DEF_NSKPW_MINOR 2 00355 #endif 00356 00357 #if defined (TAO_HAS_NSKFS) 00358 #define TAO_DEF_NSKFS_MAJOR 1 00359 #define TAO_DEF_NSKFS_MINOR 2 00360 #endif 00361 00362 #if (ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1) 00363 # if !defined (TAO_HAS_SHMIOP) 00364 # define TAO_HAS_SHMIOP 1 00365 # endif /* TAO_HAS_SHMIOP */ 00366 #else 00367 # if defined (TAO_HAS_SHMIOP) 00368 # undef TAO_HAS_SHMIOP 00369 # endif /* TAO_HAS_SHMIOP */ 00370 # define TAO_HAS_SHMIOP 0 00371 #endif /* ACE_HAS_POSITION_INDEPENDENT_POINTERS == 1 */ 00372 00373 // NAMED_RT_MUTEX support is disabled by default. 00374 // To explicitly enable NAMED_RT_MUTEX support uncomment the following 00375 // #define TAO_HAS_NAMED_RT_MUTEXES 1 00376 // To explicitly disable NAMED_RT_MUTEX support uncomment the following 00377 // #define TAO_HAS_NAMED_RT_MUTEXES 0 00378 00379 // Default NAMED_RT_MUTEX settings 00380 #if !defined (TAO_HAS_NAMED_RT_MUTEXES) 00381 # define TAO_HAS_NAMED_RT_MUTEXES 0 00382 #endif /* !TAO_HAS_NAMED_RT_MUTEXES */ 00383 00384 // MINIMUM_POA support is disabled by default if TAO is not 00385 // configured for minimum CORBA. If TAO is configured for minimum 00386 // CORBA, then MINIMUM_POA will be enabled by default. 00387 // To explicitly enable MINIMUM_POA support uncomment the following 00388 // #define TAO_HAS_MINIMUM_POA 1 00389 // To explicitly disable MINIMUM_POA support uncomment the following 00390 // #define TAO_HAS_MINIMUM_POA 0 00391 00392 // Default MINIMUM_POA settings 00393 #if !defined (TAO_HAS_MINIMUM_POA) 00394 # if (TAO_HAS_MINIMUM_CORBA == 1) 00395 # define TAO_HAS_MINIMUM_POA 1 00396 # else 00397 # define TAO_HAS_MINIMUM_POA 0 00398 # endif /* TAO_HAS_MINIMUM_CORBA */ 00399 #endif /* !TAO_HAS_MINIMUM_POA */ 00400 00401 // MINIMUM_POA_MAPS support is disabled by default if TAO is not 00402 // configured for minimum POA. If TAO is configured for minimum 00403 // POA, then MINIMUM_POA_MAPS will be enabled by default. 00404 // To explicitly enable MINIMUM_POA_MAPS support uncomment the following 00405 // #define TAO_HAS_MINIMUM_POA_MAPS 1 00406 // To explicitly disable MINIMUM_POA_MAPS support uncomment the following 00407 // #define TAO_HAS_MINIMUM_POA_MAPS 0 00408 00409 // Default MINIMUM_POA_MAPS settings 00410 #if !defined (TAO_HAS_MINIMUM_POA_MAPS) 00411 # if (TAO_HAS_MINIMUM_POA == 1) 00412 # define TAO_HAS_MINIMUM_POA_MAPS 1 00413 # else 00414 # define TAO_HAS_MINIMUM_POA_MAPS 0 00415 # endif /* TAO_HAS_MINIMUM_POA */ 00416 #endif /* !TAO_HAS_MINIMUM_POA_MAPS */ 00417 00418 // CORBA_MESSAGING support is enabled by default if TAO is not 00419 // configured for minimum CORBA. If TAO is configured for minimum 00420 // CORBA, then CORBA_MESSAGING will be disabled by default. 00421 // To explicitly enable CORBA_MESSAGING support uncomment the following 00422 // #define TAO_HAS_CORBA_MESSAGING 1 00423 // To explicitly disable CORBA_MESSAGING support uncomment the following 00424 // #define TAO_HAS_CORBA_MESSAGING 0 00425 00426 // Default CORBA_MESSAGING settings 00427 #if !defined (TAO_HAS_CORBA_MESSAGING) 00428 # define TAO_HAS_CORBA_MESSAGING 1 00429 #endif /* !TAO_HAS_CORBA_MESSAGING */ 00430 00431 // For all the policies, support is enabled by default if TAO is 00432 // configured for CORBA Messaging. If TAO is not configured for CORBA 00433 // Messaging, then policies cannot be enabled. Default support can be 00434 // turned off by setting TAO_DISABLE_CORBA_MESSAGING_POLICIES to 1. 00435 00436 #if !defined (TAO_DISABLE_CORBA_MESSAGING_POLICIES) 00437 # define TAO_DISABLE_CORBA_MESSAGING_POLICIES 0 00438 #endif /* !TAO_DISABLE_CORBA_MESSAGING_POLICIES */ 00439 00440 // To explicitly disable REBIND_POLICY support uncomment the following 00441 // #define TAO_HAS_REBIND_POLICY 0 00442 00443 // Default REBIND_POLICY settings 00444 #if !defined (TAO_HAS_REBIND_POLICY) 00445 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00446 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00447 # define TAO_HAS_REBIND_POLICY 1 00448 # else 00449 # define TAO_HAS_REBIND_POLICY 0 00450 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00451 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00452 #endif /* !TAO_HAS_REBIND_POLICY */ 00453 00454 // To explicitly disable SYNC_SCOPE_POLICY support uncomment the following 00455 // #define TAO_HAS_SYNC_SCOPE_POLICY 0 00456 00457 // Default SYNC_SCOPE_POLICY settings 00458 #if !defined (TAO_HAS_SYNC_SCOPE_POLICY) 00459 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00460 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00461 # define TAO_HAS_SYNC_SCOPE_POLICY 1 00462 # else 00463 # define TAO_HAS_SYNC_SCOPE_POLICY 0 00464 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00465 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00466 #endif /* !TAO_HAS_SYNC_SCOPE_POLICY */ 00467 00468 // To explicitly disable PRIORITY_POLICIES support uncomment the following 00469 // #define TAO_HAS_PRIORITY_POLICIES 0 00470 00471 // Default PRIORITY_POLICIES settings 00472 #if !defined (TAO_HAS_PRIORITY_POLICIES) 00473 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00474 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00475 # define TAO_HAS_PRIORITY_POLICIES 1 00476 # else 00477 # define TAO_HAS_PRIORITY_POLICIES 0 00478 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00479 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00480 #endif /* !TAO_HAS_PRIORITY_POLICIES */ 00481 00482 // To explicitly disable REQUEST_START_TIME_POLICY support uncomment the following 00483 // #define TAO_HAS_REQUEST_START_TIME_POLICY 0 00484 00485 // Default REQUEST_START_TIME_POLICY settings 00486 #if !defined (TAO_HAS_REQUEST_START_TIME_POLICY) 00487 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00488 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00489 # define TAO_HAS_REQUEST_START_TIME_POLICY 1 00490 # else 00491 # define TAO_HAS_REQUEST_START_TIME_POLICY 0 00492 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00493 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00494 #endif /* !TAO_HAS_REQUEST_START_TIME_POLICY */ 00495 00496 // To explicitly disable REQUEST_END_TIME_POLICY support uncomment the following 00497 // #define TAO_HAS_REQUEST_END_TIME_POLICY 0 00498 00499 // Default REQUEST_END_TIME_POLICY settings 00500 #if !defined (TAO_HAS_REQUEST_END_TIME_POLICY) 00501 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00502 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00503 # define TAO_HAS_REQUEST_END_TIME_POLICY 1 00504 # else 00505 # define TAO_HAS_REQUEST_END_TIME_POLICY 0 00506 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00507 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00508 #endif /* !TAO_HAS_REQUEST_END_TIME_POLICY */ 00509 00510 // To explicitly disable REPLY_START_TIME_POLICY support uncomment the following 00511 // #define TAO_HAS_REPLY_START_TIME_POLICY 0 00512 00513 // Default REPLY_START_TIME_POLICY settings 00514 #if !defined (TAO_HAS_REPLY_START_TIME_POLICY) 00515 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00516 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00517 # define TAO_HAS_REPLY_START_TIME_POLICY 1 00518 # else 00519 # define TAO_HAS_REPLY_START_TIME_POLICY 0 00520 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00521 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00522 #endif /* !TAO_HAS_REPLY_START_TIME_POLICY */ 00523 00524 // To explicitly disable REPLY_END_TIME_POLICY support uncomment the following 00525 // #define TAO_HAS_REPLY_END_TIME_POLICY 0 00526 00527 // Default REPLY_END_TIME_POLICY settings 00528 #if !defined (TAO_HAS_REPLY_END_TIME_POLICY) 00529 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00530 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00531 # define TAO_HAS_REPLY_END_TIME_POLICY 1 00532 # else 00533 # define TAO_HAS_REPLY_END_TIME_POLICY 0 00534 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00535 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00536 #endif /* !TAO_HAS_REPLY_END_TIME_POLICY */ 00537 00538 // To explicitly disable RELATIVE_REQUEST_TIMEOUT_POLICY support uncomment the following 00539 // #define TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY 0 00540 00541 // Default RELATIVE_REQUEST_TIMEOUT_POLICY settings 00542 #if !defined (TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY) 00543 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00544 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00545 # define TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY 1 00546 # else 00547 # define TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY 0 00548 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00549 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00550 #endif /* !TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY */ 00551 00552 // To explicitly disable RELATIVE_ROUNDTRIP_TIMEOUT_POLICY support uncomment the following 00553 // #define TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY 0 00554 00555 // Default RELATIVE_ROUNDTRIP_TIMEOUT_POLICY settings 00556 #if !defined (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY) 00557 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00558 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00559 # define TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY 1 00560 # else 00561 # define TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY 0 00562 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00563 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00564 #endif /* !TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY */ 00565 00566 // Default CONNECTION_TIMEOUT_POLICY settings. This is a proprietary 00567 // TAO policy. 00568 #if !defined (TAO_HAS_CONNECTION_TIMEOUT_POLICY) 00569 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00570 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00571 # define TAO_HAS_CONNECTION_TIMEOUT_POLICY 1 00572 # else 00573 # define TAO_HAS_CONNECTION_TIMEOUT_POLICY 0 00574 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00575 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00576 #endif /* !TAO_HAS_CONNECTION_TIMEOUT_POLICY */ 00577 00578 00579 // To explicitly disable ROUTING_POLICY support uncomment the following 00580 // #define TAO_HAS_ROUTING_POLICY 0 00581 00582 // Default ROUTING_POLICY settings 00583 #if !defined (TAO_HAS_ROUTING_POLICY) 00584 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00585 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00586 # define TAO_HAS_ROUTING_POLICY 1 00587 # else 00588 # define TAO_HAS_ROUTING_POLICY 0 00589 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00590 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00591 #endif /* !TAO_HAS_ROUTING_POLICY */ 00592 00593 // To explicitly disable MAX_HOPS_POLICY support uncomment the following 00594 // #define TAO_HAS_MAX_HOPS_POLICY 0 00595 00596 // Default MAX_HOPS_POLICY settings 00597 #if !defined (TAO_HAS_MAX_HOPS_POLICY) 00598 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00599 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00600 # define TAO_HAS_MAX_HOPS_POLICY 1 00601 # else 00602 # define TAO_HAS_MAX_HOPS_POLICY 0 00603 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00604 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00605 #endif /* !TAO_HAS_MAX_HOPS_POLICY */ 00606 00607 // To explicitly disable QUEUE_ORDER_POLICY support uncomment the following 00608 // #define TAO_HAS_QUEUE_ORDER_POLICY 0 00609 00610 // Default QUEUE_ORDER_POLICY settings 00611 #if !defined (TAO_HAS_QUEUE_ORDER_POLICY) 00612 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00613 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00614 # define TAO_HAS_QUEUE_ORDER_POLICY 1 00615 # else 00616 # define TAO_HAS_QUEUE_ORDER_POLICY 0 00617 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00618 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00619 #endif /* !TAO_HAS_QUEUE_ORDER_POLICY */ 00620 00621 // To explicitly disable BUFFERING_CONSTRAINT_POLICY support uncomment the following 00622 // #define TAO_HAS_BUFFERING_CONSTRAINT_POLICY 0 00623 00624 // Default BUFFERING_CONSTRAINT_POLICY settings 00625 #if !defined (TAO_HAS_BUFFERING_CONSTRAINT_POLICY) 00626 # if (TAO_HAS_CORBA_MESSAGING == 1) && \ 00627 (TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0) 00628 # define TAO_HAS_BUFFERING_CONSTRAINT_POLICY 1 00629 # else 00630 # define TAO_HAS_BUFFERING_CONSTRAINT_POLICY 0 00631 # endif /* TAO_HAS_CORBA_MESSAGING == 1 && 00632 TAO_DISABLE_CORBA_MESSAGING_POLICIES == 0 */ 00633 #endif /* !TAO_HAS_BUFFERING_CONSTRAINT_POLICY */ 00634 00635 // AMI support is enabled by default, unless TAO is compiled with 00636 // Minimum CORBA. In that case AMI is disabled by default. 00637 // If disabled you can also disable the CORBA MESSAGING support. 00638 // To explicitly enable AMI support uncomment the following 00639 // #define TAO_HAS_AMI 1 00640 // To explicitly disable AMI support uncomment the following 00641 // #define TAO_HAS_AMI 0 00642 00643 // Default AMI settings 00644 #if !defined (TAO_HAS_AMI) 00645 # if (TAO_HAS_MINIMUM_CORBA == 1) 00646 # define TAO_HAS_AMI 0 00647 # else 00648 # define TAO_HAS_AMI 1 00649 # endif /* TAO_HAS_MINIMUM_CORBA */ 00650 #else 00651 # if (TAO_HAS_AMI == 1) && \ 00652 (TAO_HAS_CORBA_MESSAGING == 0) 00653 # error "tao/orbconf.h: You need CORBA_MESSAGING for AMI support" 00654 # endif /* TAO_HAS_AMI == 1 && 00655 TAO_HAS_CORBA_MESSAGING == 0 */ 00656 #endif /* !TAO_HAS_AMI */ 00657 00658 // We dont have AMI_POLLER support in TAO. Just prevent anyone from 00659 // using it. 00660 00661 /***********************************************************/ 00662 // All these are for future use. Commenting it.. 00663 00664 // #if !defined (TAO_HAS_AMI_POLLER) 00665 // # if (TAO_HAS_AMI == 1) 00666 // # define TAO_HAS_AMI_POLLER 1 00667 // # else 00668 // # define TAO_HAS_AMI_POLLER 0 00669 // # endif /* TAO_HAS_AMI == 1 */ 00670 // #else 00671 // # if (TAO_HAS_AMI_POLLER == 1) && (TAO_HAS_CORBA_MESSAGING == 0) 00672 // # error "tao/orbconf.h: You need CORBA_MESSAGING for AMI support" 00673 // # endif /* TAO_HAS_AMI_POLLER == 1 && 00674 // TAO_HAS_CORBA_MESSAGING == 0 */ 00675 // #endif /* !TAO_HAS_AMI_POLLER */ 00676 /***********************************************************/ 00677 00678 // AMI_CALLBACK support is disabled by default if TAO is not 00679 // configured for AMI. If TAO is configured for AMI, then 00680 // AMI_CALLBACK will be enabled by default. If enabled, it requires 00681 // CORBA_MESSAGING support. 00682 // To explicitly enable AMI_CALLBACK support uncomment the following 00683 // #define TAO_HAS_AMI_CALLBACK 1 00684 // To explicitly disable AMI_CALLBACK support uncomment the following 00685 // #define TAO_HAS_AMI_CALLBACK 0 00686 00687 // Default AMI_CALLBACK settings 00688 #if !defined (TAO_HAS_AMI_CALLBACK) 00689 # if (TAO_HAS_AMI == 1) 00690 # define TAO_HAS_AMI_CALLBACK 1 00691 # else 00692 # define TAO_HAS_AMI_CALLBACK 0 00693 # endif /* TAO_HAS_AMI == 1 */ 00694 #else 00695 # if (TAO_HAS_AMI_CALLBACK == 1) && \ 00696 (TAO_HAS_CORBA_MESSAGING == 0) 00697 # error "tao/orbconf.h: You need CORBA_MESSAGING for AMI support" 00698 # endif /* TAO_HAS_AMI_CALLBACK == 1 && 00699 TAO_HAS_CORBA_MESSAGING == 0 */ 00700 #endif /* !TAO_HAS_AMI_CALLBACK */ 00701 00702 // Interceptors is supported by default if we are not building for 00703 // MinimumCORBA. 00704 #if !defined (TAO_HAS_INTERCEPTORS) 00705 # if (TAO_HAS_MINIMUM_CORBA == 1) || defined (CORBA_E_COMPACT) || defined (CORBA_E_MICRO) 00706 # define TAO_HAS_INTERCEPTORS 0 00707 # else 00708 # define TAO_HAS_INTERCEPTORS 1 00709 # endif /* TAO_HAS_MINIMUM_CORBA */ 00710 #endif 00711 00712 // At the moment we have sendfile support in ACE we enabled this also by 00713 // default for TAO, but we can suppress it also explicitly by set 00714 // TAO_HAS_SENDFILE to 0. 00715 #if !defined (TAO_HAS_SENDFILE) 00716 # if defined ACE_HAS_SENDFILE && ACE_HAS_SENDFILE == 1 00717 # define TAO_HAS_SENDFILE 1 00718 # else 00719 # define TAO_HAS_SENDFILE 0 00720 # endif /* ACE_HAS_SENDFILE */ 00721 #endif /* !TAO_HAS_SENDFILE */ 00722 00723 // Proprietary FT interception-point support is disabled by default. 00724 #ifndef TAO_HAS_EXTENDED_FT_INTERCEPTORS 00725 # define TAO_HAS_EXTENDED_FT_INTERCEPTORS 0 00726 #endif /* !TAO_HAS_EXTENEDED_FT_INTERCEPTORS */ 00727 00728 // This is needed for a check in the Policy Set; Should really not be 00729 // here though; We should find a different way to handle the check in 00730 // the Policy Set. 00731 #define TAO_RT_SERVER_PROTOCOL_POLICY_TYPE 42 00732 00733 /// Policies that are accessed on the critical path and need to be 00734 /// incur minimal retrieval overhead. 00735 enum TAO_Cached_Policy_Type 00736 { 00737 TAO_CACHED_POLICY_UNCACHED = -1, 00738 TAO_CACHED_POLICY_PRIORITY_MODEL = 0, 00739 TAO_CACHED_POLICY_THREADPOOL, 00740 TAO_CACHED_POLICY_RT_SERVER_PROTOCOL, 00741 TAO_CACHED_POLICY_RT_CLIENT_PROTOCOL, 00742 TAO_CACHED_POLICY_RT_PRIVATE_CONNECTION, 00743 TAO_CACHED_POLICY_RT_PRIORITY_BANDED_CONNECTION, 00744 00745 TAO_CACHED_POLICY_LIFESPAN, 00746 TAO_CACHED_POLICY_ID_UNIQUENESS, 00747 TAO_CACHED_POLICY_ID_ASSIGNMENT, 00748 00749 #if (TAO_HAS_MINIMUM_POA == 0) 00750 TAO_CACHED_POLICY_THREAD, 00751 TAO_CACHED_POLICY_IMPLICIT_ACTIVATION, 00752 TAO_CACHED_POLICY_SERVANT_RETENTION, 00753 TAO_CACHED_POLICY_REQUEST_PROCESSING, 00754 #endif /* TAO_HAS_MINIMUM_POA == 0 */ 00755 00756 #if (TAO_HAS_SYNC_SCOPE_POLICY == 1) 00757 TAO_CACHED_POLICY_SYNC_SCOPE, 00758 #endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ 00759 00760 #if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1) 00761 TAO_CACHED_POLICY_RELATIVE_ROUNDTRIP_TIMEOUT, 00762 #endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */ 00763 00764 #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) 00765 TAO_CACHED_POLICY_BUFFERING_CONSTRAINT, 00766 #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ 00767 00768 #if (TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1) 00769 TAO_CACHED_POLICY_CONNECTION_TIMEOUT, 00770 #endif /* TAO_HAS_CONNECTION_TIMEOUT_POLICY == 1 */ 00771 00772 TAO_CACHED_POLICY_BIDIRECTIONAL_GIOP, 00773 00774 TAO_CACHED_POLICY_SERVER_NETWORK_PRIORITY, 00775 00776 TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY, 00777 00778 TAO_CACHED_POLICY_NETWORK_PRIORITY, 00779 00780 TAO_CACHED_POLICY_ENDPOINT, 00781 00782 TAO_CACHED_COMPRESSION_ENABLING_POLICY, 00783 00784 TAO_CACHED_COMPRESSION_LOW_VALUE_POLICY, 00785 00786 TAO_CACHED_MIN_COMPRESSION_RATIO_POLICY, 00787 00788 TAO_CACHED_COMPRESSION_ID_LEVEL_LIST_POLICY, 00789 00790 /// NOTE: The "TAO_CACHED_POLICY_MAX_CACHED" should always be the last. 00791 /// This value is used as the cached_policies_ array size in TAO_Policy_Set, 00792 /// Any policy type defined after "TAO_CACHED_POLICY_MAX_CACHED" will cause 00793 /// the policy access beyond bound problem. 00794 TAO_CACHED_POLICY_MAX_CACHED 00795 }; 00796 00797 // This enum provides a mask that represent the scope at which a given 00798 // policy can be applied 00799 enum TAO_Policy_Scope 00800 { 00801 TAO_POLICY_OBJECT_SCOPE = 0x01, 00802 TAO_POLICY_THREAD_SCOPE = 0x02, 00803 TAO_POLICY_ORB_SCOPE = 0x04, 00804 TAO_POLICY_POA_SCOPE = 0x08, 00805 TAO_POLICY_CLIENT_EXPOSED = 0x10 00806 }; 00807 00808 #define TAO_POLICY_DEFAULT_SCOPE \ 00809 (static_cast<TAO_Policy_Scope> ( \ 00810 TAO_POLICY_OBJECT_SCOPE | \ 00811 TAO_POLICY_THREAD_SCOPE | \ 00812 TAO_POLICY_ORB_SCOPE | \ 00813 TAO_POLICY_POA_SCOPE)) 00814 00815 // Control the default version of GIOP used by TAO. 00816 // The ORB is always able to communicate with 1.0, 1.1 and 1.2 00817 // servers, and it creates 1.2 endpoints (and profiles). If you need 00818 // to talk to old clients that only understand 1.0 or 1.1 (and do not 00819 // attempt to use 1.0 or 1.1 with 1.2 servers), then change the values 00820 // below. 00821 #if !defined (TAO_DEF_GIOP_MAJOR) 00822 #define TAO_DEF_GIOP_MAJOR 1 00823 #endif /* TAO_DEF_GIOP_MAJOR */ 00824 #if !defined (TAO_DEF_GIOP_MINOR) 00825 #define TAO_DEF_GIOP_MINOR 2 00826 #endif /* TAO_DEF_GIOP_MINOR */ 00827 00828 // Control the minimum required IIOP version for IPv6 support 00829 #if defined (ACE_HAS_IPV6) 00830 # if !defined (TAO_MIN_IPV6_IIOP_MAJOR) 00831 # define TAO_MIN_IPV6_IIOP_MAJOR 1 00832 # endif /* TAO_MIN_IPV6_IIOP_MAJOR */ 00833 # if !defined (TAO_MIN_IPV6_IIOP_MINOR) 00834 # define TAO_MIN_IPV6_IIOP_MINOR 2 00835 # endif /* TAO_MIN_IPV6_IIOP_MINOR */ 00836 #endif /* ACE_HAS_IPV6 */ 00837 00838 // @todo this needs to be deprecated. Use TAO_MAXBUFSIZE instead. 00839 #if !defined (TAO_CONNECTION_HANDLER_STACK_BUF_SIZE) 00840 # define TAO_CONNECTION_HANDLER_STACK_BUF_SIZE 1024 00841 #endif /*TAO_CONNECTION_HANDLER_STACK_BUF_SIZE */ 00842 00843 // By default TAO generate the OMG standard profile components 00844 // (ORB_TYPE and CODE_SETS) 00845 #define TAO_STD_PROFILE_COMPONENTS 00846 00847 #if !defined (TAO_DEFAULT_IOR_SIZE) 00848 // This is the default size of the buffer used for processing IORs. 00849 #define TAO_DEFAULT_IOR_SIZE 1024 00850 #endif /* TAO_DEFAULT_IOR_SIZE */ 00851 00852 #if !defined (TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT) 00853 // The default timeout value for the thread-per-connection model, in 00854 // milliseconds. The "INFINITE" value is magic and means blocking forever. 00855 #define TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT "5000" 00856 #endif /* TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT */ 00857 00858 /// By default we use Muxed Transports 00859 #if !defined (TAO_USE_MUXED_TRANSPORT_MUX_STRATEGY) 00860 # define TAO_USE_MUXED_TRANSPORT_MUX_STRATEGY 1 00861 #endif /* TAO_USE_MUXED_TRANSPORT_MUX_STRATEGY */ 00862 00863 /// By default we use multicast lookup 00864 #if !defined(TAO_DEFAULT_INIT_REFERENCE_INITIALIZER) 00865 # define TAO_DEFAULT_INIT_REFERENCE_INITIALIZER "mcast://:::" 00866 #endif /* TAO_DEFAULT_INIT_REFERENCE_INITIALIZER */ 00867 00868 /// By default we dont use lazy strategy 00869 #if !defined (TAO_USE_LAZY_RESOURCE_USAGE_STRATEGY) 00870 # define TAO_USE_LAZY_RESOURCE_USAGE_STRATEGY 0 00871 #endif /* TAO_USE_LAZY_RESOURCE_USAGE_STRATEGY*/ 00872 00873 #if !defined (TAO_USE_LOCAL_MEMORY_POOL) 00874 # define TAO_USE_LOCAL_MEMORY_POOL 1 00875 #endif /* TAO_USE_LOCAL_MEMORY_POOL */ 00876 00877 #if !defined (TAO_USE_OUTPUT_CDR_MMAP_MEMORY_POOL) 00878 # define TAO_USE_OUTPUT_CDR_MMAP_MEMORY_POOL 0 00879 #endif /* TAO_USE_LOCAL_MEMORY_POOL */ 00880 00881 // Enable TransportCurrent by default 00882 #if !defined (TAO_HAS_TRANSPORT_CURRENT) 00883 # define TAO_HAS_TRANSPORT_CURRENT 1 00884 #endif /* ! TAO_HAS_TRANSPORT_CURRENT */ 00885 00886 #if !defined (TAO_HAS_DDL_PARSER) 00887 # define TAO_HAS_DDL_PARSER 1 00888 #endif 00889 00890 #if !defined (TAO_HAS_FILE_PARSER) 00891 # define TAO_HAS_FILE_PARSER 1 00892 #endif 00893 00894 #if !defined (TAO_HAS_CORBALOC_PARSER) 00895 # define TAO_HAS_CORBALOC_PARSER 1 00896 #endif 00897 00898 #if !defined (TAO_HAS_CORBANAME_PARSER) 00899 # define TAO_HAS_CORBANAME_PARSER 1 00900 #endif 00901 00902 #if !defined (TAO_HAS_HTTP_PARSER) 00903 # define TAO_HAS_HTTP_PARSER 1 00904 #endif 00905 00906 #if !defined (TAO_HAS_MCAST_PARSER) 00907 # if defined ACE_HAS_IP_MULTICAST 00908 # define TAO_HAS_MCAST_PARSER 1 00909 # else 00910 # define TAO_HAS_MCAST_PARSER 0 00911 # endif 00912 #endif 00913 00914 #if !defined (TAO_HAS_SEQUENCE_ITERATORS) 00915 # define TAO_HAS_SEQUENCE_ITERATORS 0 00916 #endif 00917 00918 TAO_END_VERSIONED_NAMESPACE_DECL 00919 00920 #include /**/ "ace/post.h" 00921 00922 #endif /* TAO_ORBCONF_H */
