From f1df4e94b6c15ad36fe675af0b4de676da1ca4d6 Mon Sep 17 00:00:00 2001 From: bala Date: Thu, 20 Jul 2000 17:38:20 +0000 Subject: *** empty log message *** --- TAO/tao/FT_CORBAC.cpp | 3819 +++++++++++++++++++++++++++++++++++++++++++ TAO/tao/FT_CORBAC.h | 1782 ++++++++++++++++++++ TAO/tao/FT_CORBAC.i | 3070 ++++++++++++++++++++++++++++++++++ TAO/tao/GIOPC.h | 11 +- TAO/tao/Profile.h | 10 +- TAO/tao/Stub.cpp | 18 +- TAO/tao/TAO.dsp | 61 +- TAO/tao/Tagged_Components.h | 23 +- TAO/tao/Tagged_Components.i | 8 +- 9 files changed, 8757 insertions(+), 45 deletions(-) create mode 100644 TAO/tao/FT_CORBAC.cpp create mode 100644 TAO/tao/FT_CORBAC.h create mode 100644 TAO/tao/FT_CORBAC.i diff --git a/TAO/tao/FT_CORBAC.cpp b/TAO/tao/FT_CORBAC.cpp new file mode 100644 index 00000000000..da1af34bcaa --- /dev/null +++ b/TAO/tao/FT_CORBAC.cpp @@ -0,0 +1,3819 @@ +/* -*- C++ -*- $Id$ */ + +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#include "FT_CORBAC.h" + +#if !defined (__ACE_INLINE__) +#include "FT_CORBAC.i" +#endif /* !defined INLINE */ + +static const CORBA::Long _oc_FT_FTDomainId[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x54446f6d), ACE_NTOHL (0x61696e49), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/FTDomainId:1.0 + 11, ACE_NTOHL (0x4654446f), ACE_NTOHL (0x6d61696e), ACE_NTOHL (0x49640000), // name = FTDomainId + CORBA::tk_string, + 0U, // string length +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FTDomainId (CORBA::tk_alias, sizeof (_oc_FT_FTDomainId), (char *) &_oc_FT_FTDomainId, 0, sizeof (FT::FTDomainId)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FTDomainId, &_tc_TAO_tc_FT_FTDomainId) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_ObjectGroupId[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75704964), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ObjectGroupId:1.0 + 14, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757049), ACE_NTOHL (0x64000000), // name = ObjectGroupId + CORBA::tk_ulonglong, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_ObjectGroupId (CORBA::tk_alias, sizeof (_oc_FT_ObjectGroupId), (char *) &_oc_FT_ObjectGroupId, 0, sizeof (FT::ObjectGroupId)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectGroupId, &_tc_TAO_tc_FT_ObjectGroupId) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_ObjectGroupRefVersion[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75705265), ACE_NTOHL (0x66566572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ObjectGroupRefVersion:1.0 + 22, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757052), ACE_NTOHL (0x65665665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e000000), // name = ObjectGroupRefVersion + CORBA::tk_ulong, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_ObjectGroupRefVersion (CORBA::tk_alias, sizeof (_oc_FT_ObjectGroupRefVersion), (char *) &_oc_FT_ObjectGroupRefVersion, 0, sizeof (FT::ObjectGroupRefVersion)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectGroupRefVersion, &_tc_TAO_tc_FT_ObjectGroupRefVersion) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_TagFTGroupTaggedComponent[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 45, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f54), ACE_NTOHL (0x61674654), ACE_NTOHL (0x47726f75), ACE_NTOHL (0x70546167), ACE_NTOHL (0x67656443), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/TagFTGroupTaggedComponent:1.0 + 26, ACE_NTOHL (0x54616746), ACE_NTOHL (0x5447726f), ACE_NTOHL (0x75705461), ACE_NTOHL (0x67676564), ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74000000), // name = TagFTGroupTaggedComponent + 4, // member count + 8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00), // name = version + CORBA::tk_struct, // typecode kind + 88, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x47494f50), ACE_NTOHL (0x2f566572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/GIOP/Version:1.0 + 8, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e00), // name = Version + 2, // member count + 6, ACE_NTOHL (0x6d616a6f), ACE_NTOHL (0x72000000), // name = major + CORBA::tk_octet, + + 6, ACE_NTOHL (0x6d696e6f), ACE_NTOHL (0x72000000), // name = minor + CORBA::tk_octet, + + + 13, ACE_NTOHL (0x66745f64), ACE_NTOHL (0x6f6d6169), ACE_NTOHL (0x6e5f6964), ACE_NTOHL (0x0), // name = ft_domain_id + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x54446f6d), ACE_NTOHL (0x61696e49), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/FTDomainId:1.0 + 11, ACE_NTOHL (0x4654446f), ACE_NTOHL (0x6d61696e), ACE_NTOHL (0x49640000), // name = FTDomainId + CORBA::tk_string, + 0U, // string length + + 16, ACE_NTOHL (0x6f626a65), ACE_NTOHL (0x63745f67), ACE_NTOHL (0x726f7570), ACE_NTOHL (0x5f696400), // name = object_group_id + CORBA::tk_alias, // typecode kind for typedefs + 68, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75704964), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ObjectGroupId:1.0 + 14, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757049), ACE_NTOHL (0x64000000), // name = ObjectGroupId + CORBA::tk_ulonglong, + + + 25, ACE_NTOHL (0x6f626a65), ACE_NTOHL (0x63745f67), ACE_NTOHL (0x726f7570), ACE_NTOHL (0x5f726566), ACE_NTOHL (0x5f766572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x0), // name = object_group_ref_version + CORBA::tk_alias, // typecode kind for typedefs + 84, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75705265), ACE_NTOHL (0x66566572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ObjectGroupRefVersion:1.0 + 22, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757052), ACE_NTOHL (0x65665665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e000000), // name = ObjectGroupRefVersion + CORBA::tk_ulong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_TagFTGroupTaggedComponent (CORBA::tk_struct, sizeof (_oc_FT_TagFTGroupTaggedComponent), (char *) &_oc_FT_TagFTGroupTaggedComponent, 0, sizeof (FT::TagFTGroupTaggedComponent)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TagFTGroupTaggedComponent, &_tc_TAO_tc_FT_TagFTGroupTaggedComponent) +TAO_NAMESPACE_END +void FT::TagFTGroupTaggedComponent::_tao_any_destructor (void *x) +{ + TagFTGroupTaggedComponent *tmp = ACE_static_cast (TagFTGroupTaggedComponent*,x); + delete tmp; +} + +static const CORBA::Long _oc_FT_TagFTPrimaryTaggedComponent[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 47, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f54), ACE_NTOHL (0x61674654), ACE_NTOHL (0x5072696d), ACE_NTOHL (0x61727954), ACE_NTOHL (0x61676765), ACE_NTOHL (0x64436f6d), ACE_NTOHL (0x706f6e65), ACE_NTOHL (0x6e743a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/TagFTPrimaryTaggedComponent:1.0 + 28, ACE_NTOHL (0x54616746), ACE_NTOHL (0x54507269), ACE_NTOHL (0x6d617279), ACE_NTOHL (0x54616767), ACE_NTOHL (0x6564436f), ACE_NTOHL (0x6d706f6e), ACE_NTOHL (0x656e7400), // name = TagFTPrimaryTaggedComponent + 1, // member count + 8, ACE_NTOHL (0x7072696d), ACE_NTOHL (0x61727900), // name = primary + CORBA::tk_boolean, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_TagFTPrimaryTaggedComponent (CORBA::tk_struct, sizeof (_oc_FT_TagFTPrimaryTaggedComponent), (char *) &_oc_FT_TagFTPrimaryTaggedComponent, 0, sizeof (FT::TagFTPrimaryTaggedComponent)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TagFTPrimaryTaggedComponent, &_tc_TAO_tc_FT_TagFTPrimaryTaggedComponent) +TAO_NAMESPACE_END +void FT::TagFTPrimaryTaggedComponent::_tao_any_destructor (void *x) +{ + TagFTPrimaryTaggedComponent *tmp = ACE_static_cast (TagFTPrimaryTaggedComponent*,x); + delete tmp; +} + +static const CORBA::Long _oc_FT_FTGroupVersionServiceContext[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x5447726f), ACE_NTOHL (0x75705665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e536572), ACE_NTOHL (0x76696365), ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x6578743a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/FTGroupVersionServiceContext:1.0 + 29, ACE_NTOHL (0x46544772), ACE_NTOHL (0x6f757056), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x72766963), ACE_NTOHL (0x65436f6e), ACE_NTOHL (0x74657874), ACE_NTOHL (0x0), // name = FTGroupVersionServiceContext + 1, // member count + 25, ACE_NTOHL (0x6f626a65), ACE_NTOHL (0x63745f67), ACE_NTOHL (0x726f7570), ACE_NTOHL (0x5f726566), ACE_NTOHL (0x5f766572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x0), // name = object_group_ref_version + CORBA::tk_alias, // typecode kind for typedefs + 84, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75705265), ACE_NTOHL (0x66566572), ACE_NTOHL (0x73696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ObjectGroupRefVersion:1.0 + 22, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757052), ACE_NTOHL (0x65665665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e000000), // name = ObjectGroupRefVersion + CORBA::tk_ulong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FTGroupVersionServiceContext (CORBA::tk_struct, sizeof (_oc_FT_FTGroupVersionServiceContext), (char *) &_oc_FT_FTGroupVersionServiceContext, 0, sizeof (FT::FTGroupVersionServiceContext)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FTGroupVersionServiceContext, &_tc_TAO_tc_FT_FTGroupVersionServiceContext) +TAO_NAMESPACE_END +void FT::FTGroupVersionServiceContext::_tao_any_destructor (void *x) +{ + FTGroupVersionServiceContext *tmp = ACE_static_cast (FTGroupVersionServiceContext*,x); + delete tmp; +} + +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_DURATION_POLICY, 47U) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_FTRequestServiceContext[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x54526571), ACE_NTOHL (0x75657374), ACE_NTOHL (0x53657276), ACE_NTOHL (0x69636543), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78743a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/FTRequestServiceContext:1.0 + 24, ACE_NTOHL (0x46545265), ACE_NTOHL (0x71756573), ACE_NTOHL (0x74536572), ACE_NTOHL (0x76696365), ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787400), // name = FTRequestServiceContext + 3, // member count + 10, ACE_NTOHL (0x636c6965), ACE_NTOHL (0x6e745f69), ACE_NTOHL (0x64000000), // name = client_id + CORBA::tk_string, + 0U, // string length + 13, ACE_NTOHL (0x72657465), ACE_NTOHL (0x6e74696f), ACE_NTOHL (0x6e5f6964), ACE_NTOHL (0x0), // name = retention_id + CORBA::tk_long, + + 16, ACE_NTOHL (0x65787069), ACE_NTOHL (0x72617469), ACE_NTOHL (0x6f6e5f74), ACE_NTOHL (0x696d6500), // name = expiration_time + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FTRequestServiceContext (CORBA::tk_struct, sizeof (_oc_FT_FTRequestServiceContext), (char *) &_oc_FT_FTRequestServiceContext, 0, sizeof (FT::FTRequestServiceContext)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FTRequestServiceContext, &_tc_TAO_tc_FT_FTRequestServiceContext) +TAO_NAMESPACE_END +void FT::FTRequestServiceContext::_tao_any_destructor (void *x) +{ + FTRequestServiceContext *tmp = ACE_static_cast (FTRequestServiceContext*,x); + delete tmp; +} + + +// default constructor +FT::RequestDurationPolicy::RequestDurationPolicy (void) +{} + +// destructor +FT::RequestDurationPolicy::~RequestDurationPolicy (void) +{} + +void FT::RequestDurationPolicy::_tao_any_destructor (void *x) +{ + RequestDurationPolicy *tmp = ACE_static_cast (RequestDurationPolicy*,x); + CORBA::release (tmp); +} + +FT::RequestDurationPolicy_ptr FT::RequestDurationPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return RequestDurationPolicy::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/FT/RequestDurationPolicy:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (RequestDurationPolicy::_nil ()); + if (is_a == 0) + return RequestDurationPolicy::_nil (); + } + return RequestDurationPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +FT::RequestDurationPolicy_ptr FT::RequestDurationPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return RequestDurationPolicy::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + RequestDurationPolicy_ptr default_proxy = RequestDurationPolicy::_nil (); + + if (obj->_is_collocated () && _TAO_collocation_FT_RequestDurationPolicy_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_FT_RequestDurationPolicy_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, RequestDurationPolicy (stub), RequestDurationPolicy::_nil ()); + #if (TAO_HAS_SMART_PROXIES == 1) + return TAO_FT_RequestDurationPolicy_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + #else + return default_proxy; + #endif /*TAO_HAS_SMART_PROXIES == 1*/ + } + else + return + ACE_reinterpret_cast + ( + RequestDurationPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &RequestDurationPolicy::_narrow + ) + ) + ); +} + +FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy::_duplicate (RequestDurationPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +TimeBase::TimeT FT::RequestDurationPolicy::request_duration_value ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + TimeBase::TimeT _tao_retval = 0; + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "_get_request_duration_value", + 27, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK_RETURN (_tao_retval); + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_request_duration_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_retval) + )) + TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_request_duration_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "_get_request_duration_value", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (_tao_retval); +#endif /* TAO_HAS_INTERCEPTORS */ + return _tao_retval; +} + +CORBA::Boolean FT::RequestDurationPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/RequestDurationPolicy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Policy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *FT::RequestDurationPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, RequestDurationPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* FT::RequestDurationPolicy::_interface_repository_id (void) const +{ + return "IDL:omg.org/FT/RequestDurationPolicy:1.0"; +} + +static const CORBA::Long _oc_FT_RequestDurationPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f52), ACE_NTOHL (0x65717565), ACE_NTOHL (0x73744475), ACE_NTOHL (0x72617469), ACE_NTOHL (0x6f6e506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/RequestDurationPolicy:1.0 + 22, ACE_NTOHL (0x52657175), ACE_NTOHL (0x65737444), ACE_NTOHL (0x75726174), ACE_NTOHL (0x696f6e50), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x79000000), // name = RequestDurationPolicy +}; +static CORBA::TypeCode _tc_TAO_tc_FT_RequestDurationPolicy (CORBA::tk_objref, sizeof (_oc_FT_RequestDurationPolicy), (char *) &_oc_FT_RequestDurationPolicy, 0, sizeof (FT::RequestDurationPolicy)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RequestDurationPolicy, &_tc_TAO_tc_FT_RequestDurationPolicy) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, HEARTBEAT_POLICY, 48U) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::ULong) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::ULong, HEARTBEAT_ENABLED_POLICY, 49U) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_TagFTHeartbeatEnabledTaggedComponent[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 56, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f54), ACE_NTOHL (0x61674654), ACE_NTOHL (0x48656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x74456e61), ACE_NTOHL (0x626c6564), ACE_NTOHL (0x54616767), ACE_NTOHL (0x6564436f), ACE_NTOHL (0x6d706f6e), ACE_NTOHL (0x656e743a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/TagFTHeartbeatEnabledTaggedComponent:1.0 + 37, ACE_NTOHL (0x54616746), ACE_NTOHL (0x54486561), ACE_NTOHL (0x72746265), ACE_NTOHL (0x6174456e), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x64546167), ACE_NTOHL (0x67656443), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0), // name = TagFTHeartbeatEnabledTaggedComponent + 1, // member count + 18, ACE_NTOHL (0x68656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x745f656e), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x64000000), // name = heartbeat_enabled + CORBA::tk_boolean, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_TagFTHeartbeatEnabledTaggedComponent (CORBA::tk_struct, sizeof (_oc_FT_TagFTHeartbeatEnabledTaggedComponent), (char *) &_oc_FT_TagFTHeartbeatEnabledTaggedComponent, 0, sizeof (FT::TagFTHeartbeatEnabledTaggedComponent)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TagFTHeartbeatEnabledTaggedComponent, &_tc_TAO_tc_FT_TagFTHeartbeatEnabledTaggedComponent) +TAO_NAMESPACE_END +void FT::TagFTHeartbeatEnabledTaggedComponent::_tao_any_destructor (void *x) +{ + TagFTHeartbeatEnabledTaggedComponent *tmp = ACE_static_cast (TagFTHeartbeatEnabledTaggedComponent*,x); + delete tmp; +} + +static const CORBA::Long _oc_FT_HeartbeatPolicyValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f48), ACE_NTOHL (0x65617274), ACE_NTOHL (0x62656174), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795661), ACE_NTOHL (0x6c75653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/HeartbeatPolicyValue:1.0 + 21, ACE_NTOHL (0x48656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x74506f6c), ACE_NTOHL (0x69637956), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0), // name = HeartbeatPolicyValue + 3, // member count + 10, ACE_NTOHL (0x68656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x74000000), // name = heartbeat + CORBA::tk_boolean, + + 19, ACE_NTOHL (0x68656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x745f696e), ACE_NTOHL (0x74657276), ACE_NTOHL (0x616c0000), // name = heartbeat_interval + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 18, ACE_NTOHL (0x68656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x745f7469), ACE_NTOHL (0x6d656f75), ACE_NTOHL (0x74000000), // name = heartbeat_timeout + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_HeartbeatPolicyValue (CORBA::tk_struct, sizeof (_oc_FT_HeartbeatPolicyValue), (char *) &_oc_FT_HeartbeatPolicyValue, 0, sizeof (FT::HeartbeatPolicyValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HeartbeatPolicyValue, &_tc_TAO_tc_FT_HeartbeatPolicyValue) +TAO_NAMESPACE_END +void FT::HeartbeatPolicyValue::_tao_any_destructor (void *x) +{ + HeartbeatPolicyValue *tmp = ACE_static_cast (HeartbeatPolicyValue*,x); + delete tmp; +} + + +// default constructor +FT::HeartbeatPolicy::HeartbeatPolicy (void) +{} + +// destructor +FT::HeartbeatPolicy::~HeartbeatPolicy (void) +{} + +void FT::HeartbeatPolicy::_tao_any_destructor (void *x) +{ + HeartbeatPolicy *tmp = ACE_static_cast (HeartbeatPolicy*,x); + CORBA::release (tmp); +} + +FT::HeartbeatPolicy_ptr FT::HeartbeatPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return HeartbeatPolicy::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/FT/HeartbeatPolicy:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (HeartbeatPolicy::_nil ()); + if (is_a == 0) + return HeartbeatPolicy::_nil (); + } + return HeartbeatPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +FT::HeartbeatPolicy_ptr FT::HeartbeatPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return HeartbeatPolicy::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + HeartbeatPolicy_ptr default_proxy = HeartbeatPolicy::_nil (); + + if (obj->_is_collocated () && _TAO_collocation_FT_HeartbeatPolicy_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_FT_HeartbeatPolicy_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, HeartbeatPolicy (stub), HeartbeatPolicy::_nil ()); + #if (TAO_HAS_SMART_PROXIES == 1) + return TAO_FT_HeartbeatPolicy_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + #else + return default_proxy; + #endif /*TAO_HAS_SMART_PROXIES == 1*/ + } + else + return + ACE_reinterpret_cast + ( + HeartbeatPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &HeartbeatPolicy::_narrow + ) + ) + ); +} + +FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy::_duplicate (HeartbeatPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +FT::HeartbeatPolicyValue FT::HeartbeatPolicy::heartbeat_policy_value ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + FT::HeartbeatPolicyValue _tao_retval; + ACE_OS::memset (&_tao_retval, 0, sizeof (FT::HeartbeatPolicyValue)); + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "_get_heartbeat_policy_value", + 27, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK_RETURN (_tao_retval); + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_policy_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_retval) + )) + TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_policy_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_policy_value", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (_tao_retval); +#endif /* TAO_HAS_INTERCEPTORS */ + return _tao_retval; +} + +CORBA::Boolean FT::HeartbeatPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/HeartbeatPolicy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Policy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *FT::HeartbeatPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, HeartbeatPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* FT::HeartbeatPolicy::_interface_repository_id (void) const +{ + return "IDL:omg.org/FT/HeartbeatPolicy:1.0"; +} + +static const CORBA::Long _oc_FT_HeartbeatPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f48), ACE_NTOHL (0x65617274), ACE_NTOHL (0x62656174), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63793a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/HeartbeatPolicy:1.0 + 16, ACE_NTOHL (0x48656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x74506f6c), ACE_NTOHL (0x69637900), // name = HeartbeatPolicy +}; +static CORBA::TypeCode _tc_TAO_tc_FT_HeartbeatPolicy (CORBA::tk_objref, sizeof (_oc_FT_HeartbeatPolicy), (char *) &_oc_FT_HeartbeatPolicy, 0, sizeof (FT::HeartbeatPolicy)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HeartbeatPolicy, &_tc_TAO_tc_FT_HeartbeatPolicy) +TAO_NAMESPACE_END + +// default constructor +FT::HeartbeatEnabledPolicy::HeartbeatEnabledPolicy (void) +{} + +// destructor +FT::HeartbeatEnabledPolicy::~HeartbeatEnabledPolicy (void) +{} + +void FT::HeartbeatEnabledPolicy::_tao_any_destructor (void *x) +{ + HeartbeatEnabledPolicy *tmp = ACE_static_cast (HeartbeatEnabledPolicy*,x); + CORBA::release (tmp); +} + +FT::HeartbeatEnabledPolicy_ptr FT::HeartbeatEnabledPolicy::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return HeartbeatEnabledPolicy::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/FT/HeartbeatEnabledPolicy:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (HeartbeatEnabledPolicy::_nil ()); + if (is_a == 0) + return HeartbeatEnabledPolicy::_nil (); + } + return HeartbeatEnabledPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +FT::HeartbeatEnabledPolicy_ptr FT::HeartbeatEnabledPolicy::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return HeartbeatEnabledPolicy::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + HeartbeatEnabledPolicy_ptr default_proxy = HeartbeatEnabledPolicy::_nil (); + + if (obj->_is_collocated () && _TAO_collocation_FT_HeartbeatEnabledPolicy_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_FT_HeartbeatEnabledPolicy_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, HeartbeatEnabledPolicy (stub), HeartbeatEnabledPolicy::_nil ()); + #if (TAO_HAS_SMART_PROXIES == 1) + return TAO_FT_HeartbeatEnabledPolicy_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + #else + return default_proxy; + #endif /*TAO_HAS_SMART_PROXIES == 1*/ + } + else + return + ACE_reinterpret_cast + ( + HeartbeatEnabledPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &HeartbeatEnabledPolicy::_narrow + ) + ) + ); +} + +FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy::_duplicate (HeartbeatEnabledPolicy_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +CORBA::Boolean FT::HeartbeatEnabledPolicy::heartbeat_enabled_policy_value ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + CORBA::Boolean _tao_retval = 0; + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "_get_heartbeat_enabled_policy_value", + 35, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK_RETURN (_tao_retval); + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_enabled_policy_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) + )) + TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_enabled_policy_value", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval); + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "_get_heartbeat_enabled_policy_value", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (_tao_retval); +#endif /* TAO_HAS_INTERCEPTORS */ + return _tao_retval; +} + +CORBA::Boolean FT::HeartbeatEnabledPolicy::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/HeartbeatEnabledPolicy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Policy:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *FT::HeartbeatEnabledPolicy::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, HeartbeatEnabledPolicy)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &::CORBA::Policy::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* FT::HeartbeatEnabledPolicy::_interface_repository_id (void) const +{ + return "IDL:omg.org/FT/HeartbeatEnabledPolicy:1.0"; +} + +static const CORBA::Long _oc_FT_HeartbeatEnabledPolicy[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 42, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f48), ACE_NTOHL (0x65617274), ACE_NTOHL (0x62656174), ACE_NTOHL (0x456e6162), ACE_NTOHL (0x6c656450), ACE_NTOHL (0x6f6c6963), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/HeartbeatEnabledPolicy:1.0 + 23, ACE_NTOHL (0x48656172), ACE_NTOHL (0x74626561), ACE_NTOHL (0x74456e61), ACE_NTOHL (0x626c6564), ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63790000), // name = HeartbeatEnabledPolicy +}; +static CORBA::TypeCode _tc_TAO_tc_FT_HeartbeatEnabledPolicy (CORBA::tk_objref, sizeof (_oc_FT_HeartbeatEnabledPolicy), (char *) &_oc_FT_HeartbeatEnabledPolicy, 0, sizeof (FT::HeartbeatEnabledPolicy)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HeartbeatEnabledPolicy, &_tc_TAO_tc_FT_HeartbeatEnabledPolicy) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_TypeId[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 26, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f54), ACE_NTOHL (0x79706549), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/TypeId:1.0 + 7, ACE_NTOHL (0x54797065), ACE_NTOHL (0x49640000), // name = TypeId + CORBA::tk_alias, // typecode kind for typedefs + 72, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0 + 13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0), // name = RepositoryId + CORBA::tk_string, + 0U, // string length + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_TypeId (CORBA::tk_alias, sizeof (_oc_FT_TypeId), (char *) &_oc_FT_TypeId, 0, sizeof (FT::TypeId)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeId, &_tc_TAO_tc_FT_TypeId) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_ObjectGroup[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x7447726f), ACE_NTOHL (0x75703a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/ObjectGroup:1.0 + 12, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63744772), ACE_NTOHL (0x6f757000), // name = ObjectGroup + CORBA::tk_objref, + 52, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/Object:1.0 + 7, ACE_NTOHL (0x4f626a65), ACE_NTOHL (0x63740000), // name = Object + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_ObjectGroup (CORBA::tk_alias, sizeof (_oc_FT_ObjectGroup), (char *) &_oc_FT_ObjectGroup, 0, sizeof (FT::ObjectGroup)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ObjectGroup, &_tc_TAO_tc_FT_ObjectGroup) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_ReplicationStyleValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f52), ACE_NTOHL (0x65706c69), ACE_NTOHL (0x63617469), ACE_NTOHL (0x6f6e5374), ACE_NTOHL (0x796c6556), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ReplicationStyleValue:1.0 + 22, ACE_NTOHL (0x5265706c), ACE_NTOHL (0x69636174), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x74796c65), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65000000), // name = ReplicationStyleValue + CORBA::tk_long, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_ReplicationStyleValue (CORBA::tk_alias, sizeof (_oc_FT_ReplicationStyleValue), (char *) &_oc_FT_ReplicationStyleValue, 0, sizeof (FT::ReplicationStyleValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ReplicationStyleValue, &_tc_TAO_tc_FT_ReplicationStyleValue) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, STATELESS, 0) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, COLD_PASSIVE, 1) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, WARM_PASSIVE, 2) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, ACTIVE, 3) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, ACTIVE_WITH_VOTING, 4) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_MembershipStyleValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72736869), ACE_NTOHL (0x70537479), ACE_NTOHL (0x6c655661), ACE_NTOHL (0x6c75653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/MembershipStyleValue:1.0 + 21, ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65727368), ACE_NTOHL (0x69705374), ACE_NTOHL (0x796c6556), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x0), // name = MembershipStyleValue + CORBA::tk_long, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_MembershipStyleValue (CORBA::tk_alias, sizeof (_oc_FT_MembershipStyleValue), (char *) &_oc_FT_MembershipStyleValue, 0, sizeof (FT::MembershipStyleValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_MembershipStyleValue, &_tc_TAO_tc_FT_MembershipStyleValue) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, MEMB_APP_CTRL, 0) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, MEMB_INF_CTRL, 1) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_ConsistencyStyleValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f43), ACE_NTOHL (0x6f6e7369), ACE_NTOHL (0x7374656e), ACE_NTOHL (0x63795374), ACE_NTOHL (0x796c6556), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/ConsistencyStyleValue:1.0 + 22, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x69737465), ACE_NTOHL (0x6e637953), ACE_NTOHL (0x74796c65), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65000000), // name = ConsistencyStyleValue + CORBA::tk_long, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_ConsistencyStyleValue (CORBA::tk_alias, sizeof (_oc_FT_ConsistencyStyleValue), (char *) &_oc_FT_ConsistencyStyleValue, 0, sizeof (FT::ConsistencyStyleValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsistencyStyleValue, &_tc_TAO_tc_FT_ConsistencyStyleValue) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, CONS_APP_CTRL, 0) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, CONS_INF_CTRL, 1) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_FaultMonitoringStyleValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 45, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x61756c74), ACE_NTOHL (0x4d6f6e69), ACE_NTOHL (0x746f7269), ACE_NTOHL (0x6e675374), ACE_NTOHL (0x796c6556), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/FaultMonitoringStyleValue:1.0 + 26, ACE_NTOHL (0x4661756c), ACE_NTOHL (0x744d6f6e), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x696e6753), ACE_NTOHL (0x74796c65), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65000000), // name = FaultMonitoringStyleValue + CORBA::tk_long, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FaultMonitoringStyleValue (CORBA::tk_alias, sizeof (_oc_FT_FaultMonitoringStyleValue), (char *) &_oc_FT_FaultMonitoringStyleValue, 0, sizeof (FT::FaultMonitoringStyleValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FaultMonitoringStyleValue, &_tc_TAO_tc_FT_FaultMonitoringStyleValue) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, PULL, 0) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, PUSH, 1) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, NOT_MONITORED, 2) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_FaultMonitoringGranularityValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x61756c74), ACE_NTOHL (0x4d6f6e69), ACE_NTOHL (0x746f7269), ACE_NTOHL (0x6e674772), ACE_NTOHL (0x616e756c), ACE_NTOHL (0x61726974), ACE_NTOHL (0x7956616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/FaultMonitoringGranularityValue:1.0 + 32, ACE_NTOHL (0x4661756c), ACE_NTOHL (0x744d6f6e), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x696e6747), ACE_NTOHL (0x72616e75), ACE_NTOHL (0x6c617269), ACE_NTOHL (0x74795661), ACE_NTOHL (0x6c756500), // name = FaultMonitoringGranularityValue + CORBA::tk_long, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FaultMonitoringGranularityValue (CORBA::tk_alias, sizeof (_oc_FT_FaultMonitoringGranularityValue), (char *) &_oc_FT_FaultMonitoringGranularityValue, 0, sizeof (FT::FaultMonitoringGranularityValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FaultMonitoringGranularityValue, &_tc_TAO_tc_FT_FaultMonitoringGranularityValue) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, MEMB, 0) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, LOC, 1) +TAO_NAMESPACE_END +TAO_NAMESPACE_TYPE (const CORBA::Long) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (const CORBA::Long, LOC_AND_TYPE, 2) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_InitialNumberReplicasValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c4e75), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x5265706c), ACE_NTOHL (0x69636173), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/InitialNumberReplicasValue:1.0 + 27, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c4e), ACE_NTOHL (0x756d6265), ACE_NTOHL (0x72526570), ACE_NTOHL (0x6c696361), ACE_NTOHL (0x7356616c), ACE_NTOHL (0x75650000), // name = InitialNumberReplicasValue + CORBA::tk_ushort, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_InitialNumberReplicasValue (CORBA::tk_alias, sizeof (_oc_FT_InitialNumberReplicasValue), (char *) &_oc_FT_InitialNumberReplicasValue, 0, sizeof (FT::InitialNumberReplicasValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InitialNumberReplicasValue, &_tc_TAO_tc_FT_InitialNumberReplicasValue) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_MinimumNumberReplicasValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4d), ACE_NTOHL (0x696e696d), ACE_NTOHL (0x756d4e75), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x5265706c), ACE_NTOHL (0x69636173), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/MinimumNumberReplicasValue:1.0 + 27, ACE_NTOHL (0x4d696e69), ACE_NTOHL (0x6d756d4e), ACE_NTOHL (0x756d6265), ACE_NTOHL (0x72526570), ACE_NTOHL (0x6c696361), ACE_NTOHL (0x7356616c), ACE_NTOHL (0x75650000), // name = MinimumNumberReplicasValue + CORBA::tk_ushort, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_MinimumNumberReplicasValue (CORBA::tk_alias, sizeof (_oc_FT_MinimumNumberReplicasValue), (char *) &_oc_FT_MinimumNumberReplicasValue, 0, sizeof (FT::MinimumNumberReplicasValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_MinimumNumberReplicasValue, &_tc_TAO_tc_FT_MinimumNumberReplicasValue) +TAO_NAMESPACE_END +static const CORBA::Long _oc_FT_FaultMonitoringIntervalAndTimeoutValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 58, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f46), ACE_NTOHL (0x61756c74), ACE_NTOHL (0x4d6f6e69), ACE_NTOHL (0x746f7269), ACE_NTOHL (0x6e67496e), ACE_NTOHL (0x74657276), ACE_NTOHL (0x616c416e), ACE_NTOHL (0x6454696d), ACE_NTOHL (0x656f7574), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/FaultMonitoringIntervalAndTimeoutValue:1.0 + 39, ACE_NTOHL (0x4661756c), ACE_NTOHL (0x744d6f6e), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x696e6749), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x76616c41), ACE_NTOHL (0x6e645469), ACE_NTOHL (0x6d656f75), ACE_NTOHL (0x7456616c), ACE_NTOHL (0x75650000), // name = FaultMonitoringIntervalAndTimeoutValue + 2, // member count + 20, ACE_NTOHL (0x6d6f6e69), ACE_NTOHL (0x746f7269), ACE_NTOHL (0x6e675f69), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x76616c00), // name = monitoring_interval + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + + 8, ACE_NTOHL (0x74696d65), ACE_NTOHL (0x6f757400), // name = timeout + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_FaultMonitoringIntervalAndTimeoutValue (CORBA::tk_struct, sizeof (_oc_FT_FaultMonitoringIntervalAndTimeoutValue), (char *) &_oc_FT_FaultMonitoringIntervalAndTimeoutValue, 0, sizeof (FT::FaultMonitoringIntervalAndTimeoutValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FaultMonitoringIntervalAndTimeoutValue, &_tc_TAO_tc_FT_FaultMonitoringIntervalAndTimeoutValue) +TAO_NAMESPACE_END +void FT::FaultMonitoringIntervalAndTimeoutValue::_tao_any_destructor (void *x) +{ + FaultMonitoringIntervalAndTimeoutValue *tmp = ACE_static_cast (FaultMonitoringIntervalAndTimeoutValue*,x); + delete tmp; +} + +static const CORBA::Long _oc_FT_CheckpointIntervalValue[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f43), ACE_NTOHL (0x6865636b), ACE_NTOHL (0x706f696e), ACE_NTOHL (0x74496e74), ACE_NTOHL (0x65727661), ACE_NTOHL (0x6c56616c), ACE_NTOHL (0x75653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/FT/CheckpointIntervalValue:1.0 + 24, ACE_NTOHL (0x43686563), ACE_NTOHL (0x6b706f69), ACE_NTOHL (0x6e74496e), ACE_NTOHL (0x74657276), ACE_NTOHL (0x616c5661), ACE_NTOHL (0x6c756500), // name = CheckpointIntervalValue + CORBA::tk_alias, // typecode kind for typedefs + 56, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x54696d65), ACE_NTOHL (0x42617365), ACE_NTOHL (0x2f54696d), ACE_NTOHL (0x65543a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:omg.org/TimeBase/TimeT:1.0 + 6, ACE_NTOHL (0x54696d65), ACE_NTOHL (0x54000000), // name = TimeT + CORBA::tk_ulonglong, + + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_CheckpointIntervalValue (CORBA::tk_alias, sizeof (_oc_FT_CheckpointIntervalValue), (char *) &_oc_FT_CheckpointIntervalValue, 0, sizeof (FT::CheckpointIntervalValue)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_CheckpointIntervalValue, &_tc_TAO_tc_FT_CheckpointIntervalValue) +TAO_NAMESPACE_END + +#if !defined (_FT_STATE_CS_) +#define _FT_STATE_CS_ + +// ************************************************************* +// FT::State +// ************************************************************* + +FT::State::State (void) +{} +FT::State::State (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +FT::State::State (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +FT::State::State (const State &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +FT::State::~State (void) // dtor +{} +void FT::State::_tao_any_destructor (void *x) +{ + State *tmp = ACE_static_cast (State*,x); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_FT_State[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 25, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f53), ACE_NTOHL (0x74617465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/State:1.0 + 6, ACE_NTOHL (0x53746174), ACE_NTOHL (0x65000000), // name = State + CORBA::tk_sequence, // typecode kind + 12, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_octet, + + 0U, + +}; +static CORBA::TypeCode _tc_TAO_tc_FT_State (CORBA::tk_alias, sizeof (_oc_FT_State), (char *) &_oc_FT_State, 0, sizeof (FT::State)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_State, &_tc_TAO_tc_FT_State) +TAO_NAMESPACE_END +// default constructor +FT::NoStateAvailable::NoStateAvailable (void) + : CORBA_UserException (::FT::_tc_NoStateAvailable) +{ +} + +// destructor - all members are of self managing types +FT::NoStateAvailable::~NoStateAvailable (void) +{ +} + +void FT::NoStateAvailable::_tao_any_destructor (void *x) +{ + NoStateAvailable *tmp = ACE_static_cast (NoStateAvailable*,x); + delete tmp; +} + +// copy constructor +FT::NoStateAvailable::NoStateAvailable (const ::FT::NoStateAvailable &_tao_excp) + : CORBA_UserException (_tao_excp._type ()) +{ + } + +// assignment operator +FT::NoStateAvailable& +FT::NoStateAvailable::operator= (const ::FT::NoStateAvailable &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +FT::NoStateAvailable * +FT::NoStateAvailable::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:omg.org/FT/NoStateAvailable:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (NoStateAvailable *, exc); + else + return 0; +} + + +void FT::NoStateAvailable::_raise () +{ + TAO_RAISE(*this); +} + + +void FT::NoStateAvailable::_tao_encode ( + TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + + +void FT::NoStateAvailable::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *FT::NoStateAvailable::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::FT::NoStateAvailable, 0); + return retval; +} + +static const CORBA::Long _oc_FT_NoStateAvailable[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4e), ACE_NTOHL (0x6f537461), ACE_NTOHL (0x74654176), ACE_NTOHL (0x61696c61), ACE_NTOHL (0x626c653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/NoStateAvailable:1.0 + 17, ACE_NTOHL (0x4e6f5374), ACE_NTOHL (0x61746541), ACE_NTOHL (0x7661696c), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x0), // name = NoStateAvailable + 0, // member count +}; +static CORBA::TypeCode _tc_TAO_tc_FT_NoStateAvailable (CORBA::tk_except, sizeof (_oc_FT_NoStateAvailable), (char *) &_oc_FT_NoStateAvailable, 0, sizeof (FT::NoStateAvailable)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NoStateAvailable, &_tc_TAO_tc_FT_NoStateAvailable) +TAO_NAMESPACE_END +// default constructor +FT::InvalidState::InvalidState (void) + : CORBA_UserException (::FT::_tc_InvalidState) +{ +} + +// destructor - all members are of self managing types +FT::InvalidState::~InvalidState (void) +{ +} + +void FT::InvalidState::_tao_any_destructor (void *x) +{ + InvalidState *tmp = ACE_static_cast (InvalidState*,x); + delete tmp; +} + +// copy constructor +FT::InvalidState::InvalidState (const ::FT::InvalidState &_tao_excp) + : CORBA_UserException (_tao_excp._type ()) +{ + } + +// assignment operator +FT::InvalidState& +FT::InvalidState::operator= (const ::FT::InvalidState &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +FT::InvalidState * +FT::InvalidState::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:omg.org/FT/InvalidState:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (InvalidState *, exc); + else + return 0; +} + + +void FT::InvalidState::_raise () +{ + TAO_RAISE(*this); +} + + +void FT::InvalidState::_tao_encode ( + TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + + +void FT::InvalidState::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *FT::InvalidState::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::FT::InvalidState, 0); + return retval; +} + +static const CORBA::Long _oc_FT_InvalidState[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f49), ACE_NTOHL (0x6e76616c), ACE_NTOHL (0x69645374), ACE_NTOHL (0x6174653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/FT/InvalidState:1.0 + 13, ACE_NTOHL (0x496e7661), ACE_NTOHL (0x6c696453), ACE_NTOHL (0x74617465), ACE_NTOHL (0x0), // name = InvalidState + 0, // member count +}; +static CORBA::TypeCode _tc_TAO_tc_FT_InvalidState (CORBA::tk_except, sizeof (_oc_FT_InvalidState), (char *) &_oc_FT_InvalidState, 0, sizeof (FT::InvalidState)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InvalidState, &_tc_TAO_tc_FT_InvalidState) +TAO_NAMESPACE_END +// default constructor +FT::NoUpdateAvailable::NoUpdateAvailable (void) + : CORBA_UserException (::FT::_tc_NoUpdateAvailable) +{ +} + +// destructor - all members are of self managing types +FT::NoUpdateAvailable::~NoUpdateAvailable (void) +{ +} + +void FT::NoUpdateAvailable::_tao_any_destructor (void *x) +{ + NoUpdateAvailable *tmp = ACE_static_cast (NoUpdateAvailable*,x); + delete tmp; +} + +// copy constructor +FT::NoUpdateAvailable::NoUpdateAvailable (const ::FT::NoUpdateAvailable &_tao_excp) + : CORBA_UserException (_tao_excp._type ()) +{ + } + +// assignment operator +FT::NoUpdateAvailable& +FT::NoUpdateAvailable::operator= (const ::FT::NoUpdateAvailable &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +FT::NoUpdateAvailable * +FT::NoUpdateAvailable::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:omg.org/FT/NoUpdateAvailable:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (NoUpdateAvailable *, exc); + else + return 0; +} + + +void FT::NoUpdateAvailable::_raise () +{ + TAO_RAISE(*this); +} + + +void FT::NoUpdateAvailable::_tao_encode ( + TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + + +void FT::NoUpdateAvailable::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *FT::NoUpdateAvailable::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::FT::NoUpdateAvailable, 0); + return retval; +} + +static const CORBA::Long _oc_FT_NoUpdateAvailable[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f4e), ACE_NTOHL (0x6f557064), ACE_NTOHL (0x61746541), ACE_NTOHL (0x7661696c), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/NoUpdateAvailable:1.0 + 18, ACE_NTOHL (0x4e6f5570), ACE_NTOHL (0x64617465), ACE_NTOHL (0x41766169), ACE_NTOHL (0x6c61626c), ACE_NTOHL (0x65000000), // name = NoUpdateAvailable + 0, // member count +}; +static CORBA::TypeCode _tc_TAO_tc_FT_NoUpdateAvailable (CORBA::tk_except, sizeof (_oc_FT_NoUpdateAvailable), (char *) &_oc_FT_NoUpdateAvailable, 0, sizeof (FT::NoUpdateAvailable)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NoUpdateAvailable, &_tc_TAO_tc_FT_NoUpdateAvailable) +TAO_NAMESPACE_END +// default constructor +FT::InvalidUpdate::InvalidUpdate (void) + : CORBA_UserException (::FT::_tc_InvalidUpdate) +{ +} + +// destructor - all members are of self managing types +FT::InvalidUpdate::~InvalidUpdate (void) +{ +} + +void FT::InvalidUpdate::_tao_any_destructor (void *x) +{ + InvalidUpdate *tmp = ACE_static_cast (InvalidUpdate*,x); + delete tmp; +} + +// copy constructor +FT::InvalidUpdate::InvalidUpdate (const ::FT::InvalidUpdate &_tao_excp) + : CORBA_UserException (_tao_excp._type ()) +{ + } + +// assignment operator +FT::InvalidUpdate& +FT::InvalidUpdate::operator= (const ::FT::InvalidUpdate &_tao_excp) +{ + + this->CORBA_UserException::operator= (_tao_excp); + return *this; +} + +// narrow +FT::InvalidUpdate * +FT::InvalidUpdate::_downcast (CORBA::Exception *exc) +{ + if (!ACE_OS::strcmp ("IDL:omg.org/FT/InvalidUpdate:1.0", exc->_id ())) // same type + return ACE_dynamic_cast (InvalidUpdate *, exc); + else + return 0; +} + + +void FT::InvalidUpdate::_raise () +{ + TAO_RAISE(*this); +} + + +void FT::InvalidUpdate::_tao_encode ( + TAO_OutputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) const +{ + if (cdr << *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + + +void FT::InvalidUpdate::_tao_decode ( + TAO_InputCDR &cdr, + CORBA::Environment &ACE_TRY_ENV) +{ + if (cdr >> *this) + return; + ACE_THROW (CORBA::MARSHAL ()); +} + +// TAO extension - the _alloc method +CORBA::Exception *FT::InvalidUpdate::_alloc (void) +{ + CORBA::Exception *retval = 0; + ACE_NEW_RETURN (retval, ::FT::InvalidUpdate, 0); + return retval; +} + +static const CORBA::Long _oc_FT_InvalidUpdate[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f49), ACE_NTOHL (0x6e76616c), ACE_NTOHL (0x69645570), ACE_NTOHL (0x64617465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/FT/InvalidUpdate:1.0 + 14, ACE_NTOHL (0x496e7661), ACE_NTOHL (0x6c696455), ACE_NTOHL (0x70646174), ACE_NTOHL (0x65000000), // name = InvalidUpdate + 0, // member count +}; +static CORBA::TypeCode _tc_TAO_tc_FT_InvalidUpdate (CORBA::tk_except, sizeof (_oc_FT_InvalidUpdate), (char *) &_oc_FT_InvalidUpdate, 0, sizeof (FT::InvalidUpdate)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InvalidUpdate, &_tc_TAO_tc_FT_InvalidUpdate) +TAO_NAMESPACE_END + +// default constructor +FT::Checkpointable::Checkpointable (void) +{} + +// destructor +FT::Checkpointable::~Checkpointable (void) +{} + +void FT::Checkpointable::_tao_any_destructor (void *x) +{ + Checkpointable *tmp = ACE_static_cast (Checkpointable*,x); + CORBA::release (tmp); +} + +FT::Checkpointable_ptr FT::Checkpointable::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return Checkpointable::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/FT/Checkpointable:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (Checkpointable::_nil ()); + if (is_a == 0) + return Checkpointable::_nil (); + } + return Checkpointable::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +FT::Checkpointable_ptr FT::Checkpointable::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return Checkpointable::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + Checkpointable_ptr default_proxy = Checkpointable::_nil (); + + if (obj->_is_collocated () && _TAO_collocation_FT_Checkpointable_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_FT_Checkpointable_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, Checkpointable (stub), Checkpointable::_nil ()); + #if (TAO_HAS_SMART_PROXIES == 1) + return TAO_FT_Checkpointable_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + #else + return default_proxy; + #endif /*TAO_HAS_SMART_PROXIES == 1*/ + } + else + return + ACE_reinterpret_cast + ( + Checkpointable_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &Checkpointable::_narrow + ) + ) + ); +} + +FT::Checkpointable_ptr +FT::Checkpointable::_duplicate (Checkpointable_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +FT::State * FT::Checkpointable::get_state ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::NoStateAvailable + )) +{ + + static TAO_Exception_Data _tao_FT_Checkpointable_get_state_exceptiondata [] = + { + {FT::_tc_NoStateAvailable, FT::NoStateAvailable::_alloc} + }; + + FT::State *_tao_retval = 0; + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), 0); + + + ACE_NEW_RETURN (_tao_retval, FT::State, _tao_retval); + FT::State_var _tao_safe_retval (_tao_retval); + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "get_state", + 9, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK_RETURN (0); + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "get_state", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + int _invoke_status = + _tao_call.invoke (_tao_FT_Checkpointable_get_state_exceptiondata, 1, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "get_state", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "get_state", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (0); +#endif /* TAO_HAS_INTERCEPTORS */ + return _tao_safe_retval._retn (); +} + +void FT::Checkpointable::set_state ( + const FT::State & s, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::InvalidState + )) +{ + + static TAO_Exception_Data _tao_FT_Checkpointable_set_state_exceptiondata [] = + { + {FT::_tc_InvalidState, FT::InvalidState::_alloc} + }; + + + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW (CORBA::INTERNAL ()); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "set_state", + 9, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK; + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK; + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "set_state", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << s) + )) + TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_FT_Checkpointable_set_state_exceptiondata, 1, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "set_state", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "set_state", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + +} + +CORBA::Boolean FT::Checkpointable::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/Checkpointable:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *FT::Checkpointable::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, Checkpointable)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* FT::Checkpointable::_interface_repository_id (void) const +{ + return "IDL:omg.org/FT/Checkpointable:1.0"; +} + +static const CORBA::Long _oc_FT_Checkpointable[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f43), ACE_NTOHL (0x6865636b), ACE_NTOHL (0x706f696e), ACE_NTOHL (0x7461626c), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/Checkpointable:1.0 + 15, ACE_NTOHL (0x43686563), ACE_NTOHL (0x6b706f69), ACE_NTOHL (0x6e746162), ACE_NTOHL (0x6c650000), // name = Checkpointable +}; +static CORBA::TypeCode _tc_TAO_tc_FT_Checkpointable (CORBA::tk_objref, sizeof (_oc_FT_Checkpointable), (char *) &_oc_FT_Checkpointable, 0, sizeof (FT::Checkpointable)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Checkpointable, &_tc_TAO_tc_FT_Checkpointable) +TAO_NAMESPACE_END + +// default constructor +FT::Updateable::Updateable (void) +{} + +// destructor +FT::Updateable::~Updateable (void) +{} + +void FT::Updateable::_tao_any_destructor (void *x) +{ + Updateable *tmp = ACE_static_cast (Updateable*,x); + CORBA::release (tmp); +} + +FT::Updateable_ptr FT::Updateable::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return Updateable::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/FT/Updateable:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (Updateable::_nil ()); + if (is_a == 0) + return Updateable::_nil (); + } + return Updateable::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +FT::Updateable_ptr FT::Updateable::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return Updateable::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + Updateable_ptr default_proxy = Updateable::_nil (); + + if (obj->_is_collocated () && _TAO_collocation_FT_Updateable_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_FT_Updateable_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, Updateable (stub), Updateable::_nil ()); + #if (TAO_HAS_SMART_PROXIES == 1) + return TAO_FT_Updateable_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + #else + return default_proxy; + #endif /*TAO_HAS_SMART_PROXIES == 1*/ + } + else + return + ACE_reinterpret_cast + ( + Updateable_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &Updateable::_narrow + ) + ) + ); +} + +FT::Updateable_ptr +FT::Updateable::_duplicate (Updateable_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +FT::State * FT::Updateable::get_update ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::NoUpdateAvailable + )) +{ + + static TAO_Exception_Data _tao_FT_Updateable_get_update_exceptiondata [] = + { + {FT::_tc_NoUpdateAvailable, FT::NoUpdateAvailable::_alloc} + }; + + FT::State *_tao_retval = 0; + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), 0); + + + ACE_NEW_RETURN (_tao_retval, FT::State, _tao_retval); + FT::State_var _tao_safe_retval (_tao_retval); + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "get_update", + 10, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK_RETURN (0); + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "get_update", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + int _invoke_status = + _tao_call.invoke (_tao_FT_Updateable_get_update_exceptiondata, 1, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "get_update", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "get_update", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (0); +#endif /* TAO_HAS_INTERCEPTORS */ + return _tao_safe_retval._retn (); +} + +void FT::Updateable::set_update ( + const FT::State & s, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::InvalidUpdate + )) +{ + + static TAO_Exception_Data _tao_FT_Updateable_set_update_exceptiondata [] = + { + {FT::_tc_InvalidUpdate, FT::InvalidUpdate::_alloc} + }; + + + + + TAO_Stub *istub = this->_stubobj (); + if (istub == 0) + ACE_THROW (CORBA::INTERNAL ()); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "set_update", + 10, + istub->orb_core () + ); + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter + _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV)); + ACE_CHECK; + PortableInterceptor::Cookies _tao_cookies; + CORBA::NVList_var _tao_interceptor_args; + if (_tao_vfr.valid ()) + { + istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV); + ACE_CHECK; + } + + ACE_TRY + { +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + TAO_INTERCEPTOR ( + _tao_vfr.preinvoke ( + _tao_call.request_id (), + 1, + this, + "set_update", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << s) + )) + TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_FT_Updateable_set_update_exceptiondata, 1, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + + TAO_INTERCEPTOR ( + _tao_vfr.postinvoke ( + _tao_call.request_id (), + 1, + this, + "set_update", + _tao_call.service_info (), + _tao_interceptor_args.inout (), + _tao_cookies, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + break; + + } +#if (TAO_HAS_INTERCEPTORS == 1) + + } + ACE_CATCHANY + { + _tao_vfr.exception_occurred ( + _tao_call.request_id (), + 1, + this, + "set_update", + _tao_cookies, + ACE_TRY_ENV + ); + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK; +#endif /* TAO_HAS_INTERCEPTORS */ + +} + +CORBA::Boolean FT::Updateable::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/Updateable:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/FT/Checkpointable:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *FT::Updateable::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, Updateable)::_narrow)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast + (ptr_arith_t, + &ACE_NESTED_CLASS (::FT, Checkpointable)::_narrow)) + retv = ACE_reinterpret_cast + ( + void *, + ACE_static_cast + ( + FT::Checkpointable_ptr, + this + ) + ); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* FT::Updateable::_interface_repository_id (void) const +{ + return "IDL:omg.org/FT/Updateable:1.0"; +} + +static const CORBA::Long _oc_FT_Updateable[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x46542f55), ACE_NTOHL (0x70646174), ACE_NTOHL (0x6561626c), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/FT/Updateable:1.0 + 11, ACE_NTOHL (0x55706461), ACE_NTOHL (0x74656162), ACE_NTOHL (0x6c650000), // name = Updateable +}; +static CORBA::TypeCode _tc_TAO_tc_FT_Updateable (CORBA::tk_objref, sizeof (_oc_FT_Updateable), (char *) &_oc_FT_Updateable, 0, sizeof (FT::Updateable)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (FT) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Updateable, &_tc_TAO_tc_FT_Updateable) +TAO_NAMESPACE_END +void operator<<= (CORBA::Any &_tao_any, const FT::TagFTGroupTaggedComponent &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTGroupTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::TagFTGroupTaggedComponent *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTGroupTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::TagFTGroupTaggedComponent::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::TagFTGroupTaggedComponent *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::TagFTGroupTaggedComponent*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::TagFTGroupTaggedComponent *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_TagFTGroupTaggedComponent, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::TagFTGroupTaggedComponent*, + _tao_any.value () + ); + return 1; + } + else + { + FT::TagFTGroupTaggedComponent *tmp; + ACE_NEW_RETURN (tmp, FT::TagFTGroupTaggedComponent, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_TagFTGroupTaggedComponent, + 1, + ACE_static_cast (void *, tmp), + FT::TagFTGroupTaggedComponent::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::TagFTPrimaryTaggedComponent &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTPrimaryTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::TagFTPrimaryTaggedComponent *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTPrimaryTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::TagFTPrimaryTaggedComponent::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::TagFTPrimaryTaggedComponent *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::TagFTPrimaryTaggedComponent*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::TagFTPrimaryTaggedComponent *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_TagFTPrimaryTaggedComponent, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::TagFTPrimaryTaggedComponent*, + _tao_any.value () + ); + return 1; + } + else + { + FT::TagFTPrimaryTaggedComponent *tmp; + ACE_NEW_RETURN (tmp, FT::TagFTPrimaryTaggedComponent, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_TagFTPrimaryTaggedComponent, + 1, + ACE_static_cast (void *, tmp), + FT::TagFTPrimaryTaggedComponent::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::FTGroupVersionServiceContext &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_FTGroupVersionServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::FTGroupVersionServiceContext *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_FTGroupVersionServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::FTGroupVersionServiceContext::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::FTGroupVersionServiceContext *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::FTGroupVersionServiceContext*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::FTGroupVersionServiceContext *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_FTGroupVersionServiceContext, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::FTGroupVersionServiceContext*, + _tao_any.value () + ); + return 1; + } + else + { + FT::FTGroupVersionServiceContext *tmp; + ACE_NEW_RETURN (tmp, FT::FTGroupVersionServiceContext, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_FTGroupVersionServiceContext, + 1, + ACE_static_cast (void *, tmp), + FT::FTGroupVersionServiceContext::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::FTRequestServiceContext &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_FTRequestServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::FTRequestServiceContext *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_FTRequestServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::FTRequestServiceContext::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::FTRequestServiceContext *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::FTRequestServiceContext*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::FTRequestServiceContext *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_FTRequestServiceContext, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::FTRequestServiceContext*, + _tao_any.value () + ); + return 1; + } + else + { + FT::FTRequestServiceContext *tmp; + ACE_NEW_RETURN (tmp, FT::FTRequestServiceContext, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_FTRequestServiceContext, + 1, + ACE_static_cast (void *, tmp), + FT::FTRequestServiceContext::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +FT::RequestDurationPolicy_ptr (*_TAO_collocation_FT_RequestDurationPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, FT::RequestDurationPolicy_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_RequestDurationPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + FT::RequestDurationPolicy::_duplicate (_tao_elem), + FT::RequestDurationPolicy::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::RequestDurationPolicy_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = FT::RequestDurationPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_RequestDurationPolicy, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_RequestDurationPolicy, + 1, + _tao_elem, + FT::RequestDurationPolicy::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = FT::RequestDurationPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = FT::RequestDurationPolicy::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, const FT::TagFTHeartbeatEnabledTaggedComponent &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTHeartbeatEnabledTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::TagFTHeartbeatEnabledTaggedComponent *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_TagFTHeartbeatEnabledTaggedComponent, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::TagFTHeartbeatEnabledTaggedComponent::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::TagFTHeartbeatEnabledTaggedComponent *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::TagFTHeartbeatEnabledTaggedComponent*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::TagFTHeartbeatEnabledTaggedComponent *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_TagFTHeartbeatEnabledTaggedComponent, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::TagFTHeartbeatEnabledTaggedComponent*, + _tao_any.value () + ); + return 1; + } + else + { + FT::TagFTHeartbeatEnabledTaggedComponent *tmp; + ACE_NEW_RETURN (tmp, FT::TagFTHeartbeatEnabledTaggedComponent, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_TagFTHeartbeatEnabledTaggedComponent, + 1, + ACE_static_cast (void *, tmp), + FT::TagFTHeartbeatEnabledTaggedComponent::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::HeartbeatPolicyValue &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_HeartbeatPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::HeartbeatPolicyValue *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_HeartbeatPolicyValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::HeartbeatPolicyValue::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::HeartbeatPolicyValue *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::HeartbeatPolicyValue*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::HeartbeatPolicyValue *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_HeartbeatPolicyValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::HeartbeatPolicyValue*, + _tao_any.value () + ); + return 1; + } + else + { + FT::HeartbeatPolicyValue *tmp; + ACE_NEW_RETURN (tmp, FT::HeartbeatPolicyValue, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_HeartbeatPolicyValue, + 1, + ACE_static_cast (void *, tmp), + FT::HeartbeatPolicyValue::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +FT::HeartbeatPolicy_ptr (*_TAO_collocation_FT_HeartbeatPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, FT::HeartbeatPolicy_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_HeartbeatPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + FT::HeartbeatPolicy::_duplicate (_tao_elem), + FT::HeartbeatPolicy::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::HeartbeatPolicy_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = FT::HeartbeatPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_HeartbeatPolicy, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_HeartbeatPolicy, + 1, + _tao_elem, + FT::HeartbeatPolicy::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = FT::HeartbeatPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = FT::HeartbeatPolicy::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +FT::HeartbeatEnabledPolicy_ptr (*_TAO_collocation_FT_HeartbeatEnabledPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, FT::HeartbeatEnabledPolicy_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_HeartbeatEnabledPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + FT::HeartbeatEnabledPolicy::_duplicate (_tao_elem), + FT::HeartbeatEnabledPolicy::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::HeartbeatEnabledPolicy_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = FT::HeartbeatEnabledPolicy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_HeartbeatEnabledPolicy, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_HeartbeatEnabledPolicy, + 1, + _tao_elem, + FT::HeartbeatEnabledPolicy::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = FT::HeartbeatEnabledPolicy::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = FT::HeartbeatEnabledPolicy::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +void operator<<= (CORBA::Any &_tao_any, const FT::FaultMonitoringIntervalAndTimeoutValue &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_FaultMonitoringIntervalAndTimeoutValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::FaultMonitoringIntervalAndTimeoutValue *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_FaultMonitoringIntervalAndTimeoutValue, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::FaultMonitoringIntervalAndTimeoutValue::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::FaultMonitoringIntervalAndTimeoutValue *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const FT::FaultMonitoringIntervalAndTimeoutValue*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::FaultMonitoringIntervalAndTimeoutValue *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_FaultMonitoringIntervalAndTimeoutValue, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::FaultMonitoringIntervalAndTimeoutValue*, + _tao_any.value () + ); + return 1; + } + else + { + FT::FaultMonitoringIntervalAndTimeoutValue *tmp; + ACE_NEW_RETURN (tmp, FT::FaultMonitoringIntervalAndTimeoutValue, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_FaultMonitoringIntervalAndTimeoutValue, + 1, + ACE_static_cast (void *, tmp), + FT::FaultMonitoringIntervalAndTimeoutValue::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= ( + CORBA::Any &_tao_any, + const FT::State &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_State, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, FT::State *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_State, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::State::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::State *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const FT::State*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::State *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_State, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const FT::State*, + _tao_any.value () + ); + return 1; + } + else + { + FT::State *tmp; + ACE_NEW_RETURN (tmp, FT::State, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_State, + 1, + ACE_static_cast (void *, tmp), + FT::State::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::NoStateAvailable &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_NoStateAvailable, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::NoStateAvailable *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_NoStateAvailable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::NoStateAvailable::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::NoStateAvailable *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const FT::NoStateAvailable*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::NoStateAvailable *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_NoStateAvailable, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (FT::NoStateAvailable *)_tao_any.value (); + return 1; + } + else + { + FT::NoStateAvailable *tmp; + ACE_NEW_RETURN (tmp, FT::NoStateAvailable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; + if (!(stream >> interface_repository_id.out ())) + return 0; + if (ACE_OS::strcmp ( + interface_repository_id.in (), + "IDL:omg.org/FT/NoStateAvailable:1.0")) + return 0; + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_NoStateAvailable, + 1, + tmp, + FT::NoStateAvailable::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::InvalidState &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_InvalidState, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::InvalidState *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_InvalidState, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::InvalidState::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::InvalidState *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const FT::InvalidState*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::InvalidState *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_InvalidState, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (FT::InvalidState *)_tao_any.value (); + return 1; + } + else + { + FT::InvalidState *tmp; + ACE_NEW_RETURN (tmp, FT::InvalidState, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; + if (!(stream >> interface_repository_id.out ())) + return 0; + if (ACE_OS::strcmp ( + interface_repository_id.in (), + "IDL:omg.org/FT/InvalidState:1.0")) + return 0; + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_InvalidState, + 1, + tmp, + FT::InvalidState::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::NoUpdateAvailable &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_NoUpdateAvailable, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::NoUpdateAvailable *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_NoUpdateAvailable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::NoUpdateAvailable::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::NoUpdateAvailable *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const FT::NoUpdateAvailable*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::NoUpdateAvailable *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_NoUpdateAvailable, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (FT::NoUpdateAvailable *)_tao_any.value (); + return 1; + } + else + { + FT::NoUpdateAvailable *tmp; + ACE_NEW_RETURN (tmp, FT::NoUpdateAvailable, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; + if (!(stream >> interface_repository_id.out ())) + return 0; + if (ACE_OS::strcmp ( + interface_repository_id.in (), + "IDL:omg.org/FT/NoUpdateAvailable:1.0")) + return 0; + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_NoUpdateAvailable, + 1, + tmp, + FT::NoUpdateAvailable::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const FT::InvalidUpdate &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + FT::_tc_InvalidUpdate, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, FT::InvalidUpdate *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + FT::_tc_InvalidUpdate, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + FT::InvalidUpdate::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::InvalidUpdate *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const FT::InvalidUpdate*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const FT::InvalidUpdate *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_InvalidUpdate, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = (FT::InvalidUpdate *)_tao_any.value (); + return 1; + } + else + { + FT::InvalidUpdate *tmp; + ACE_NEW_RETURN (tmp, FT::InvalidUpdate, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; + if (!(stream >> interface_repository_id.out ())) + return 0; + if (ACE_OS::strcmp ( + interface_repository_id.in (), + "IDL:omg.org/FT/InvalidUpdate:1.0")) + return 0; + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_InvalidUpdate, + 1, + tmp, + FT::InvalidUpdate::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +FT::Checkpointable_ptr (*_TAO_collocation_FT_Checkpointable_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, FT::Checkpointable_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_Checkpointable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + FT::Checkpointable::_duplicate (_tao_elem), + FT::Checkpointable::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::Checkpointable_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = FT::Checkpointable::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_Checkpointable, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_Checkpointable, + 1, + _tao_elem, + FT::Checkpointable::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = FT::Checkpointable::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = FT::Checkpointable::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +FT::Updateable_ptr (*_TAO_collocation_FT_Updateable_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; +void operator<<= (CORBA::Any &_tao_any, FT::Updateable_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + FT::_tc_Updateable, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + FT::Updateable::_duplicate (_tao_elem), + FT::Updateable::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, FT::Updateable_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = FT::Updateable::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (FT::_tc_Updateable, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + FT::_tc_Updateable, + 1, + _tao_elem, + FT::Updateable::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = FT::Updateable::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = FT::Updateable::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const FT::State &_tao_sequence + ) +{ + if (strm << _tao_sequence.length ()) + { + // encode all elements + +#if defined (TAO_NO_COPY_OCTET_SEQUENCES) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast (TAO_Unbounded_Sequence*, (FT::State *)&_tao_sequence); + if (oseq->mb ()) + return strm.write_octet_array_mb (oseq->mb ()); + else + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + +#else /* TAO_NO_COPY_OCTET_SEQUENCES */ + return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES */ + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + FT::State &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + if (strm >> _tao_seq_len) + { + // set the length of the sequence + _tao_sequence.length (_tao_seq_len); + // If length is 0 we return true. + if (0 >= _tao_seq_len) + return 1; + // retrieve all the elements + +#if defined (TAO_NO_COPY_OCTET_SEQUENCES) + if (ACE_BIT_DISABLED (strm.start ()->flags (),ACE_Message_Block::DONT_DELETE)) + { + TAO_Unbounded_Sequence *oseq = + ACE_static_cast(TAO_Unbounded_Sequence*, &_tao_sequence); + oseq->replace (_tao_seq_len, strm.start ()); + oseq->mb ()->wr_ptr (oseq->mb()->rd_ptr () + _tao_seq_len); + strm.skip_bytes (_tao_seq_len); + return 1; + } + else + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_seq_len); + +#else /* TAO_NO_COPY_OCTET_SEQUENCES */ + return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + +#endif /* TAO_NO_COPY_OCTET_SEQUENCES */ + } + return 0; // error +} + diff --git a/TAO/tao/FT_CORBAC.h b/TAO/tao/FT_CORBAC.h new file mode 100644 index 00000000000..9c6c19955a1 --- /dev/null +++ b/TAO/tao/FT_CORBAC.h @@ -0,0 +1,1782 @@ +/* -*- C++ -*- $Id$ */ + +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#ifndef _TAO_IDL_FT_CORBAC_H_ +#define _TAO_IDL_FT_CORBAC_H_ + +#include "tao/TimeBaseC.h" + +#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) +#include "ace/streams.h" +#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +//#include "tao/IOPC.h" +#include "tao/PolicyC.h" +#include "tao/GIOPC.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_Export + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO TAO_Export +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_NAMESPACE FT +{ + typedef char * FTDomainId; + typedef CORBA::String_var FTDomainId_var; + typedef CORBA::String_out FTDomainId_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FTDomainId; + + typedef CORBA::ULongLong ObjectGroupId; + typedef CORBA::ULongLong_out ObjectGroupId_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectGroupId; + + typedef CORBA::ULong ObjectGroupRefVersion; + typedef CORBA::ULong_out ObjectGroupRefVersion_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectGroupRefVersion; + + struct TagFTGroupTaggedComponent; + class TagFTGroupTaggedComponent_var; + + struct TAO_Export TagFTGroupTaggedComponent + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef TagFTGroupTaggedComponent_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + GIOP::Version version; + TAO_String_Manager ft_domain_id; + ACE_NESTED_CLASS (FT, ObjectGroupId) object_group_id; + ACE_NESTED_CLASS (FT, ObjectGroupRefVersion) object_group_ref_version; + }; + + class TAO_Export TagFTGroupTaggedComponent_var + { + public: + TagFTGroupTaggedComponent_var (void); // default constructor + TagFTGroupTaggedComponent_var (TagFTGroupTaggedComponent *); + TagFTGroupTaggedComponent_var (const TagFTGroupTaggedComponent_var &); // copy constructor + ~TagFTGroupTaggedComponent_var (void); // destructor + + TagFTGroupTaggedComponent_var &operator= (TagFTGroupTaggedComponent *); + TagFTGroupTaggedComponent_var &operator= (const TagFTGroupTaggedComponent_var &); + TagFTGroupTaggedComponent *operator-> (void); + const TagFTGroupTaggedComponent *operator-> (void) const; + + operator const TagFTGroupTaggedComponent &() const; + operator TagFTGroupTaggedComponent &(); + operator TagFTGroupTaggedComponent &() const; + operator TagFTGroupTaggedComponent *&(); // variable-size types only + + // in, inout, out, _retn + const TagFTGroupTaggedComponent &in (void) const; + TagFTGroupTaggedComponent &inout (void); + TagFTGroupTaggedComponent *&out (void); + TagFTGroupTaggedComponent *_retn (void); + TagFTGroupTaggedComponent *ptr (void) const; + + private: + TagFTGroupTaggedComponent *ptr_; + }; + + class TAO_Export TagFTGroupTaggedComponent_out + { + public: + TagFTGroupTaggedComponent_out (TagFTGroupTaggedComponent *&); + TagFTGroupTaggedComponent_out (TagFTGroupTaggedComponent_var &); + TagFTGroupTaggedComponent_out (const TagFTGroupTaggedComponent_out &); + TagFTGroupTaggedComponent_out &operator= (const TagFTGroupTaggedComponent_out &); + TagFTGroupTaggedComponent_out &operator= (TagFTGroupTaggedComponent *); + operator TagFTGroupTaggedComponent *&(); + TagFTGroupTaggedComponent *&ptr (void); + TagFTGroupTaggedComponent *operator-> (void); + + private: + TagFTGroupTaggedComponent *&ptr_; + // assignment from T_var not allowed + void operator= (const TagFTGroupTaggedComponent_var &); + }; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TagFTGroupTaggedComponent; + + struct TagFTPrimaryTaggedComponent; + class TagFTPrimaryTaggedComponent_var; + + struct TAO_Export TagFTPrimaryTaggedComponent + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef TagFTPrimaryTaggedComponent_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + CORBA::Boolean primary; + }; + + class TAO_Export TagFTPrimaryTaggedComponent_var + { + public: + TagFTPrimaryTaggedComponent_var (void); // default constructor + TagFTPrimaryTaggedComponent_var (TagFTPrimaryTaggedComponent *); + TagFTPrimaryTaggedComponent_var (const TagFTPrimaryTaggedComponent_var &); // copy constructor + TagFTPrimaryTaggedComponent_var (const TagFTPrimaryTaggedComponent &); // fixed-size types only + ~TagFTPrimaryTaggedComponent_var (void); // destructor + + TagFTPrimaryTaggedComponent_var &operator= (TagFTPrimaryTaggedComponent *); + TagFTPrimaryTaggedComponent_var &operator= (const TagFTPrimaryTaggedComponent_var &); + TagFTPrimaryTaggedComponent_var &operator= (const TagFTPrimaryTaggedComponent &); // fixed-size types only + TagFTPrimaryTaggedComponent *operator-> (void); + const TagFTPrimaryTaggedComponent *operator-> (void) const; + + operator const TagFTPrimaryTaggedComponent &() const; + operator TagFTPrimaryTaggedComponent &(); + operator TagFTPrimaryTaggedComponent &() const; + + // in, inout, out, _retn + const TagFTPrimaryTaggedComponent &in (void) const; + TagFTPrimaryTaggedComponent &inout (void); + TagFTPrimaryTaggedComponent &out (void); + TagFTPrimaryTaggedComponent _retn (void); + TagFTPrimaryTaggedComponent *ptr (void) const; + + private: + TagFTPrimaryTaggedComponent *ptr_; + }; + + typedef TagFTPrimaryTaggedComponent &TagFTPrimaryTaggedComponent_out; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TagFTPrimaryTaggedComponent; + + struct FTGroupVersionServiceContext; + class FTGroupVersionServiceContext_var; + + struct TAO_Export FTGroupVersionServiceContext + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef FTGroupVersionServiceContext_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + ACE_NESTED_CLASS (FT, ObjectGroupRefVersion) object_group_ref_version; + }; + + class TAO_Export FTGroupVersionServiceContext_var + { + public: + FTGroupVersionServiceContext_var (void); // default constructor + FTGroupVersionServiceContext_var (FTGroupVersionServiceContext *); + FTGroupVersionServiceContext_var (const FTGroupVersionServiceContext_var &); // copy constructor + FTGroupVersionServiceContext_var (const FTGroupVersionServiceContext &); // fixed-size types only + ~FTGroupVersionServiceContext_var (void); // destructor + + FTGroupVersionServiceContext_var &operator= (FTGroupVersionServiceContext *); + FTGroupVersionServiceContext_var &operator= (const FTGroupVersionServiceContext_var &); + FTGroupVersionServiceContext_var &operator= (const FTGroupVersionServiceContext &); // fixed-size types only + FTGroupVersionServiceContext *operator-> (void); + const FTGroupVersionServiceContext *operator-> (void) const; + + operator const FTGroupVersionServiceContext &() const; + operator FTGroupVersionServiceContext &(); + operator FTGroupVersionServiceContext &() const; + + // in, inout, out, _retn + const FTGroupVersionServiceContext &in (void) const; + FTGroupVersionServiceContext &inout (void); + FTGroupVersionServiceContext &out (void); + FTGroupVersionServiceContext _retn (void); + FTGroupVersionServiceContext *ptr (void) const; + + private: + FTGroupVersionServiceContext *ptr_; + }; + + typedef FTGroupVersionServiceContext &FTGroupVersionServiceContext_out; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FTGroupVersionServiceContext; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_DURATION_POLICY; + + struct FTRequestServiceContext; + class FTRequestServiceContext_var; + + struct TAO_Export FTRequestServiceContext + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef FTRequestServiceContext_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager client_id; + CORBA::Long retention_id; + TimeBase::TimeT expiration_time; + }; + + class TAO_Export FTRequestServiceContext_var + { + public: + FTRequestServiceContext_var (void); // default constructor + FTRequestServiceContext_var (FTRequestServiceContext *); + FTRequestServiceContext_var (const FTRequestServiceContext_var &); // copy constructor + ~FTRequestServiceContext_var (void); // destructor + + FTRequestServiceContext_var &operator= (FTRequestServiceContext *); + FTRequestServiceContext_var &operator= (const FTRequestServiceContext_var &); + FTRequestServiceContext *operator-> (void); + const FTRequestServiceContext *operator-> (void) const; + + operator const FTRequestServiceContext &() const; + operator FTRequestServiceContext &(); + operator FTRequestServiceContext &() const; + operator FTRequestServiceContext *&(); // variable-size types only + + // in, inout, out, _retn + const FTRequestServiceContext &in (void) const; + FTRequestServiceContext &inout (void); + FTRequestServiceContext *&out (void); + FTRequestServiceContext *_retn (void); + FTRequestServiceContext *ptr (void) const; + + private: + FTRequestServiceContext *ptr_; + }; + + class TAO_Export FTRequestServiceContext_out + { + public: + FTRequestServiceContext_out (FTRequestServiceContext *&); + FTRequestServiceContext_out (FTRequestServiceContext_var &); + FTRequestServiceContext_out (const FTRequestServiceContext_out &); + FTRequestServiceContext_out &operator= (const FTRequestServiceContext_out &); + FTRequestServiceContext_out &operator= (FTRequestServiceContext *); + operator FTRequestServiceContext *&(); + FTRequestServiceContext *&ptr (void); + FTRequestServiceContext *operator-> (void); + + private: + FTRequestServiceContext *&ptr_; + // assignment from T_var not allowed + void operator= (const FTRequestServiceContext_var &); + }; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FTRequestServiceContext; + + +#if !defined (_FT_REQUESTDURATIONPOLICY___PTR_CH_) +#define _FT_REQUESTDURATIONPOLICY___PTR_CH_ + + class RequestDurationPolicy; + typedef RequestDurationPolicy *RequestDurationPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_REQUESTDURATIONPOLICY___VAR_CH_) +#define _FT_REQUESTDURATIONPOLICY___VAR_CH_ + + class TAO_Export RequestDurationPolicy_var : public TAO_Base_var + { + public: + RequestDurationPolicy_var (void); // default constructor + RequestDurationPolicy_var (RequestDurationPolicy_ptr); + RequestDurationPolicy_var (const RequestDurationPolicy_var &); // copy constructor + ~RequestDurationPolicy_var (void); // destructor + + RequestDurationPolicy_var &operator= (RequestDurationPolicy_ptr); + RequestDurationPolicy_var &operator= (const RequestDurationPolicy_var &); + RequestDurationPolicy_ptr operator-> (void) const; + + operator const RequestDurationPolicy_ptr &() const; + operator RequestDurationPolicy_ptr &(); + // in, inout, out, _retn + RequestDurationPolicy_ptr in (void) const; + RequestDurationPolicy_ptr &inout (void); + RequestDurationPolicy_ptr &out (void); + RequestDurationPolicy_ptr _retn (void); + RequestDurationPolicy_ptr ptr (void) const; + + private: + RequestDurationPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + RequestDurationPolicy_var (const TAO_Base_var &rhs); + RequestDurationPolicy_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_REQUESTDURATIONPOLICY___OUT_CH_) +#define _FT_REQUESTDURATIONPOLICY___OUT_CH_ + + class TAO_Export RequestDurationPolicy_out + { + public: + RequestDurationPolicy_out (RequestDurationPolicy_ptr &); + RequestDurationPolicy_out (RequestDurationPolicy_var &); + RequestDurationPolicy_out (const RequestDurationPolicy_out &); + RequestDurationPolicy_out &operator= (const RequestDurationPolicy_out &); + RequestDurationPolicy_out &operator= (const RequestDurationPolicy_var &); + RequestDurationPolicy_out &operator= (RequestDurationPolicy_ptr); + operator RequestDurationPolicy_ptr &(); + RequestDurationPolicy_ptr &ptr (void); + RequestDurationPolicy_ptr operator-> (void); + + private: + RequestDurationPolicy_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_REQUESTDURATIONPOLICY_CH_) +#define _FT_REQUESTDURATIONPOLICY_CH_ + +class TAO_Export RequestDurationPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef RequestDurationPolicy_ptr _ptr_type; + typedef RequestDurationPolicy_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static RequestDurationPolicy_ptr _duplicate (RequestDurationPolicy_ptr obj); + static RequestDurationPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestDurationPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestDurationPolicy_ptr _nil (void) + { + return (RequestDurationPolicy_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual TimeBase::TimeT request_duration_value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + + protected: + RequestDurationPolicy (void); + RequestDurationPolicy (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~RequestDurationPolicy (void); + private: + RequestDurationPolicy (const RequestDurationPolicy &); + void operator= (const RequestDurationPolicy &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RequestDurationPolicy; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong HEARTBEAT_POLICY; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong HEARTBEAT_ENABLED_POLICY; + + struct TagFTHeartbeatEnabledTaggedComponent; + class TagFTHeartbeatEnabledTaggedComponent_var; + + struct TAO_Export TagFTHeartbeatEnabledTaggedComponent + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef TagFTHeartbeatEnabledTaggedComponent_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + CORBA::Boolean heartbeat_enabled; + }; + + class TAO_Export TagFTHeartbeatEnabledTaggedComponent_var + { + public: + TagFTHeartbeatEnabledTaggedComponent_var (void); // default constructor + TagFTHeartbeatEnabledTaggedComponent_var (TagFTHeartbeatEnabledTaggedComponent *); + TagFTHeartbeatEnabledTaggedComponent_var (const TagFTHeartbeatEnabledTaggedComponent_var &); // copy constructor + TagFTHeartbeatEnabledTaggedComponent_var (const TagFTHeartbeatEnabledTaggedComponent &); // fixed-size types only + ~TagFTHeartbeatEnabledTaggedComponent_var (void); // destructor + + TagFTHeartbeatEnabledTaggedComponent_var &operator= (TagFTHeartbeatEnabledTaggedComponent *); + TagFTHeartbeatEnabledTaggedComponent_var &operator= (const TagFTHeartbeatEnabledTaggedComponent_var &); + TagFTHeartbeatEnabledTaggedComponent_var &operator= (const TagFTHeartbeatEnabledTaggedComponent &); // fixed-size types only + TagFTHeartbeatEnabledTaggedComponent *operator-> (void); + const TagFTHeartbeatEnabledTaggedComponent *operator-> (void) const; + + operator const TagFTHeartbeatEnabledTaggedComponent &() const; + operator TagFTHeartbeatEnabledTaggedComponent &(); + operator TagFTHeartbeatEnabledTaggedComponent &() const; + + // in, inout, out, _retn + const TagFTHeartbeatEnabledTaggedComponent &in (void) const; + TagFTHeartbeatEnabledTaggedComponent &inout (void); + TagFTHeartbeatEnabledTaggedComponent &out (void); + TagFTHeartbeatEnabledTaggedComponent _retn (void); + TagFTHeartbeatEnabledTaggedComponent *ptr (void) const; + + private: + TagFTHeartbeatEnabledTaggedComponent *ptr_; + }; + + typedef TagFTHeartbeatEnabledTaggedComponent &TagFTHeartbeatEnabledTaggedComponent_out; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TagFTHeartbeatEnabledTaggedComponent; + + struct HeartbeatPolicyValue; + class HeartbeatPolicyValue_var; + + struct TAO_Export HeartbeatPolicyValue + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef HeartbeatPolicyValue_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + CORBA::Boolean heartbeat; + TimeBase::TimeT heartbeat_interval; + TimeBase::TimeT heartbeat_timeout; + }; + + class TAO_Export HeartbeatPolicyValue_var + { + public: + HeartbeatPolicyValue_var (void); // default constructor + HeartbeatPolicyValue_var (HeartbeatPolicyValue *); + HeartbeatPolicyValue_var (const HeartbeatPolicyValue_var &); // copy constructor + HeartbeatPolicyValue_var (const HeartbeatPolicyValue &); // fixed-size types only + ~HeartbeatPolicyValue_var (void); // destructor + + HeartbeatPolicyValue_var &operator= (HeartbeatPolicyValue *); + HeartbeatPolicyValue_var &operator= (const HeartbeatPolicyValue_var &); + HeartbeatPolicyValue_var &operator= (const HeartbeatPolicyValue &); // fixed-size types only + HeartbeatPolicyValue *operator-> (void); + const HeartbeatPolicyValue *operator-> (void) const; + + operator const HeartbeatPolicyValue &() const; + operator HeartbeatPolicyValue &(); + operator HeartbeatPolicyValue &() const; + + // in, inout, out, _retn + const HeartbeatPolicyValue &in (void) const; + HeartbeatPolicyValue &inout (void); + HeartbeatPolicyValue &out (void); + HeartbeatPolicyValue _retn (void); + HeartbeatPolicyValue *ptr (void) const; + + private: + HeartbeatPolicyValue *ptr_; + }; + + typedef HeartbeatPolicyValue &HeartbeatPolicyValue_out; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HeartbeatPolicyValue; + + +#if !defined (_FT_HEARTBEATPOLICY___PTR_CH_) +#define _FT_HEARTBEATPOLICY___PTR_CH_ + + class HeartbeatPolicy; + typedef HeartbeatPolicy *HeartbeatPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATPOLICY___VAR_CH_) +#define _FT_HEARTBEATPOLICY___VAR_CH_ + + class TAO_Export HeartbeatPolicy_var : public TAO_Base_var + { + public: + HeartbeatPolicy_var (void); // default constructor + HeartbeatPolicy_var (HeartbeatPolicy_ptr); + HeartbeatPolicy_var (const HeartbeatPolicy_var &); // copy constructor + ~HeartbeatPolicy_var (void); // destructor + + HeartbeatPolicy_var &operator= (HeartbeatPolicy_ptr); + HeartbeatPolicy_var &operator= (const HeartbeatPolicy_var &); + HeartbeatPolicy_ptr operator-> (void) const; + + operator const HeartbeatPolicy_ptr &() const; + operator HeartbeatPolicy_ptr &(); + // in, inout, out, _retn + HeartbeatPolicy_ptr in (void) const; + HeartbeatPolicy_ptr &inout (void); + HeartbeatPolicy_ptr &out (void); + HeartbeatPolicy_ptr _retn (void); + HeartbeatPolicy_ptr ptr (void) const; + + private: + HeartbeatPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + HeartbeatPolicy_var (const TAO_Base_var &rhs); + HeartbeatPolicy_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATPOLICY___OUT_CH_) +#define _FT_HEARTBEATPOLICY___OUT_CH_ + + class TAO_Export HeartbeatPolicy_out + { + public: + HeartbeatPolicy_out (HeartbeatPolicy_ptr &); + HeartbeatPolicy_out (HeartbeatPolicy_var &); + HeartbeatPolicy_out (const HeartbeatPolicy_out &); + HeartbeatPolicy_out &operator= (const HeartbeatPolicy_out &); + HeartbeatPolicy_out &operator= (const HeartbeatPolicy_var &); + HeartbeatPolicy_out &operator= (HeartbeatPolicy_ptr); + operator HeartbeatPolicy_ptr &(); + HeartbeatPolicy_ptr &ptr (void); + HeartbeatPolicy_ptr operator-> (void); + + private: + HeartbeatPolicy_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATPOLICY_CH_) +#define _FT_HEARTBEATPOLICY_CH_ + +class TAO_Export HeartbeatPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef HeartbeatPolicy_ptr _ptr_type; + typedef HeartbeatPolicy_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static HeartbeatPolicy_ptr _duplicate (HeartbeatPolicy_ptr obj); + static HeartbeatPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static HeartbeatPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static HeartbeatPolicy_ptr _nil (void) + { + return (HeartbeatPolicy_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual FT::HeartbeatPolicyValue heartbeat_policy_value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + + protected: + HeartbeatPolicy (void); + HeartbeatPolicy (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~HeartbeatPolicy (void); + private: + HeartbeatPolicy (const HeartbeatPolicy &); + void operator= (const HeartbeatPolicy &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HeartbeatPolicy; + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY___PTR_CH_) +#define _FT_HEARTBEATENABLEDPOLICY___PTR_CH_ + + class HeartbeatEnabledPolicy; + typedef HeartbeatEnabledPolicy *HeartbeatEnabledPolicy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY___VAR_CH_) +#define _FT_HEARTBEATENABLEDPOLICY___VAR_CH_ + + class TAO_Export HeartbeatEnabledPolicy_var : public TAO_Base_var + { + public: + HeartbeatEnabledPolicy_var (void); // default constructor + HeartbeatEnabledPolicy_var (HeartbeatEnabledPolicy_ptr); + HeartbeatEnabledPolicy_var (const HeartbeatEnabledPolicy_var &); // copy constructor + ~HeartbeatEnabledPolicy_var (void); // destructor + + HeartbeatEnabledPolicy_var &operator= (HeartbeatEnabledPolicy_ptr); + HeartbeatEnabledPolicy_var &operator= (const HeartbeatEnabledPolicy_var &); + HeartbeatEnabledPolicy_ptr operator-> (void) const; + + operator const HeartbeatEnabledPolicy_ptr &() const; + operator HeartbeatEnabledPolicy_ptr &(); + // in, inout, out, _retn + HeartbeatEnabledPolicy_ptr in (void) const; + HeartbeatEnabledPolicy_ptr &inout (void); + HeartbeatEnabledPolicy_ptr &out (void); + HeartbeatEnabledPolicy_ptr _retn (void); + HeartbeatEnabledPolicy_ptr ptr (void) const; + + private: + HeartbeatEnabledPolicy_ptr ptr_; + // Unimplemented - prevents widening assignment. + HeartbeatEnabledPolicy_var (const TAO_Base_var &rhs); + HeartbeatEnabledPolicy_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY___OUT_CH_) +#define _FT_HEARTBEATENABLEDPOLICY___OUT_CH_ + + class TAO_Export HeartbeatEnabledPolicy_out + { + public: + HeartbeatEnabledPolicy_out (HeartbeatEnabledPolicy_ptr &); + HeartbeatEnabledPolicy_out (HeartbeatEnabledPolicy_var &); + HeartbeatEnabledPolicy_out (const HeartbeatEnabledPolicy_out &); + HeartbeatEnabledPolicy_out &operator= (const HeartbeatEnabledPolicy_out &); + HeartbeatEnabledPolicy_out &operator= (const HeartbeatEnabledPolicy_var &); + HeartbeatEnabledPolicy_out &operator= (HeartbeatEnabledPolicy_ptr); + operator HeartbeatEnabledPolicy_ptr &(); + HeartbeatEnabledPolicy_ptr &ptr (void); + HeartbeatEnabledPolicy_ptr operator-> (void); + + private: + HeartbeatEnabledPolicy_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY_CH_) +#define _FT_HEARTBEATENABLEDPOLICY_CH_ + +class TAO_Export HeartbeatEnabledPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef HeartbeatEnabledPolicy_ptr _ptr_type; + typedef HeartbeatEnabledPolicy_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static HeartbeatEnabledPolicy_ptr _duplicate (HeartbeatEnabledPolicy_ptr obj); + static HeartbeatEnabledPolicy_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static HeartbeatEnabledPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static HeartbeatEnabledPolicy_ptr _nil (void) + { + return (HeartbeatEnabledPolicy_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual CORBA::Boolean heartbeat_enabled_policy_value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + + protected: + HeartbeatEnabledPolicy (void); + HeartbeatEnabledPolicy (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~HeartbeatEnabledPolicy (void); + private: + HeartbeatEnabledPolicy (const HeartbeatEnabledPolicy &); + void operator= (const HeartbeatEnabledPolicy &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HeartbeatEnabledPolicy; + + class GenericFactory; + +#if !defined (_FT_GENERICFACTORY___PTR_CH_) +#define _FT_GENERICFACTORY___PTR_CH_ + +typedef GenericFactory *GenericFactory_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_GENERICFACTORY___VAR_CH_) +#define _FT_GENERICFACTORY___VAR_CH_ + + class TAO_Export GenericFactory_var : public TAO_Base_var + { + public: + GenericFactory_var (void); // default constructor + GenericFactory_var (GenericFactory_ptr); + GenericFactory_var (const GenericFactory_var &); // copy constructor + ~GenericFactory_var (void); // destructor + + GenericFactory_var &operator= (GenericFactory_ptr); + GenericFactory_var &operator= (const GenericFactory_var &); + GenericFactory_ptr operator-> (void) const; + + operator const GenericFactory_ptr &() const; + operator GenericFactory_ptr &(); + // in, inout, out, _retn + GenericFactory_ptr in (void) const; + GenericFactory_ptr &inout (void); + GenericFactory_ptr &out (void); + GenericFactory_ptr _retn (void); + GenericFactory_ptr ptr (void) const; + + private: + GenericFactory_ptr ptr_; + // Unimplemented - prevents widening assignment. + GenericFactory_var (const TAO_Base_var &rhs); + GenericFactory_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_GENERICFACTORY___OUT_CH_) +#define _FT_GENERICFACTORY___OUT_CH_ + + class TAO_Export GenericFactory_out + { + public: + GenericFactory_out (GenericFactory_ptr &); + GenericFactory_out (GenericFactory_var &); + GenericFactory_out (const GenericFactory_out &); + GenericFactory_out &operator= (const GenericFactory_out &); + GenericFactory_out &operator= (const GenericFactory_var &); + GenericFactory_out &operator= (GenericFactory_ptr); + operator GenericFactory_ptr &(); + GenericFactory_ptr &ptr (void); + GenericFactory_ptr operator-> (void); + + private: + GenericFactory_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + class FaultNotifier; + +#if !defined (_FT_FAULTNOTIFIER___PTR_CH_) +#define _FT_FAULTNOTIFIER___PTR_CH_ + +typedef FaultNotifier *FaultNotifier_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_FAULTNOTIFIER___VAR_CH_) +#define _FT_FAULTNOTIFIER___VAR_CH_ + + class TAO_Export FaultNotifier_var : public TAO_Base_var + { + public: + FaultNotifier_var (void); // default constructor + FaultNotifier_var (FaultNotifier_ptr); + FaultNotifier_var (const FaultNotifier_var &); // copy constructor + ~FaultNotifier_var (void); // destructor + + FaultNotifier_var &operator= (FaultNotifier_ptr); + FaultNotifier_var &operator= (const FaultNotifier_var &); + FaultNotifier_ptr operator-> (void) const; + + operator const FaultNotifier_ptr &() const; + operator FaultNotifier_ptr &(); + // in, inout, out, _retn + FaultNotifier_ptr in (void) const; + FaultNotifier_ptr &inout (void); + FaultNotifier_ptr &out (void); + FaultNotifier_ptr _retn (void); + FaultNotifier_ptr ptr (void) const; + + private: + FaultNotifier_ptr ptr_; + // Unimplemented - prevents widening assignment. + FaultNotifier_var (const TAO_Base_var &rhs); + FaultNotifier_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_FAULTNOTIFIER___OUT_CH_) +#define _FT_FAULTNOTIFIER___OUT_CH_ + + class TAO_Export FaultNotifier_out + { + public: + FaultNotifier_out (FaultNotifier_ptr &); + FaultNotifier_out (FaultNotifier_var &); + FaultNotifier_out (const FaultNotifier_out &); + FaultNotifier_out &operator= (const FaultNotifier_out &); + FaultNotifier_out &operator= (const FaultNotifier_var &); + FaultNotifier_out &operator= (FaultNotifier_ptr); + operator FaultNotifier_ptr &(); + FaultNotifier_ptr &ptr (void); + FaultNotifier_ptr operator-> (void); + + private: + FaultNotifier_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + typedef char * TypeId; + typedef CORBA::String_var TypeId_var; + typedef CORBA::String_out TypeId_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeId; + + typedef CORBA::Object ObjectGroup; + typedef CORBA::Object_ptr ObjectGroup_ptr; + typedef CORBA::Object_var ObjectGroup_var; + typedef CORBA::Object_out ObjectGroup_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectGroup; + + typedef CORBA::Long ReplicationStyleValue; + typedef CORBA::Long_out ReplicationStyleValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ReplicationStyleValue; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long STATELESS; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long COLD_PASSIVE; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long WARM_PASSIVE; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long ACTIVE; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long ACTIVE_WITH_VOTING; + + typedef CORBA::Long MembershipStyleValue; + typedef CORBA::Long_out MembershipStyleValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_MembershipStyleValue; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long MEMB_APP_CTRL; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long MEMB_INF_CTRL; + + typedef CORBA::Long ConsistencyStyleValue; + typedef CORBA::Long_out ConsistencyStyleValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsistencyStyleValue; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long CONS_APP_CTRL; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long CONS_INF_CTRL; + + typedef CORBA::Long FaultMonitoringStyleValue; + typedef CORBA::Long_out FaultMonitoringStyleValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FaultMonitoringStyleValue; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long PULL; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long PUSH; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long NOT_MONITORED; + + typedef CORBA::Long FaultMonitoringGranularityValue; + typedef CORBA::Long_out FaultMonitoringGranularityValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FaultMonitoringGranularityValue; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long MEMB; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long LOC; + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::Long LOC_AND_TYPE; + + typedef CORBA::UShort InitialNumberReplicasValue; + typedef CORBA::UShort_out InitialNumberReplicasValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitialNumberReplicasValue; + + typedef CORBA::UShort MinimumNumberReplicasValue; + typedef CORBA::UShort_out MinimumNumberReplicasValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_MinimumNumberReplicasValue; + + struct FaultMonitoringIntervalAndTimeoutValue; + class FaultMonitoringIntervalAndTimeoutValue_var; + + struct TAO_Export FaultMonitoringIntervalAndTimeoutValue + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef FaultMonitoringIntervalAndTimeoutValue_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TimeBase::TimeT monitoring_interval; + TimeBase::TimeT timeout; + }; + + class TAO_Export FaultMonitoringIntervalAndTimeoutValue_var + { + public: + FaultMonitoringIntervalAndTimeoutValue_var (void); // default constructor + FaultMonitoringIntervalAndTimeoutValue_var (FaultMonitoringIntervalAndTimeoutValue *); + FaultMonitoringIntervalAndTimeoutValue_var (const FaultMonitoringIntervalAndTimeoutValue_var &); // copy constructor + FaultMonitoringIntervalAndTimeoutValue_var (const FaultMonitoringIntervalAndTimeoutValue &); // fixed-size types only + ~FaultMonitoringIntervalAndTimeoutValue_var (void); // destructor + + FaultMonitoringIntervalAndTimeoutValue_var &operator= (FaultMonitoringIntervalAndTimeoutValue *); + FaultMonitoringIntervalAndTimeoutValue_var &operator= (const FaultMonitoringIntervalAndTimeoutValue_var &); + FaultMonitoringIntervalAndTimeoutValue_var &operator= (const FaultMonitoringIntervalAndTimeoutValue &); // fixed-size types only + FaultMonitoringIntervalAndTimeoutValue *operator-> (void); + const FaultMonitoringIntervalAndTimeoutValue *operator-> (void) const; + + operator const FaultMonitoringIntervalAndTimeoutValue &() const; + operator FaultMonitoringIntervalAndTimeoutValue &(); + operator FaultMonitoringIntervalAndTimeoutValue &() const; + + // in, inout, out, _retn + const FaultMonitoringIntervalAndTimeoutValue &in (void) const; + FaultMonitoringIntervalAndTimeoutValue &inout (void); + FaultMonitoringIntervalAndTimeoutValue &out (void); + FaultMonitoringIntervalAndTimeoutValue _retn (void); + FaultMonitoringIntervalAndTimeoutValue *ptr (void) const; + + private: + FaultMonitoringIntervalAndTimeoutValue *ptr_; + }; + + typedef FaultMonitoringIntervalAndTimeoutValue &FaultMonitoringIntervalAndTimeoutValue_out; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FaultMonitoringIntervalAndTimeoutValue; + + typedef TimeBase::TimeT CheckpointIntervalValue; + typedef TimeBase::TimeT_out CheckpointIntervalValue_out; + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_CheckpointIntervalValue; + + +#if !defined (_FT_STATE_CH_) +#define _FT_STATE_CH_ + + class State; + class State_var; + + // ************************************************************* + // State + // ************************************************************* + + class TAO_Export State : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + State (void); // default ctor + State (CORBA::ULong max); // uses max size + State ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::Octet *buffer, + CORBA::Boolean release=0 + ); + State (const State &); // copy ctor + ~State (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef State_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + +#if defined(TAO_NO_COPY_OCTET_SEQUENCES) + State ( + CORBA::ULong length, + const ACE_Message_Block* mb + ) + : TAO_Unbounded_Sequence (length, mb) {} +#endif /* TAO_NO_COPY_OCTET_SEQUENCE */ + + }; + +#endif /* end #if !defined */ + + +#if !defined (_FT_STATE___VAR_CH_) +#define _FT_STATE___VAR_CH_ + + // ************************************************************* + // class FT::State_var + // ************************************************************* + + class TAO_Export State_var + { + public: + State_var (void); // default constructor + State_var (State *); + State_var (const State_var &); // copy constructor + State_var (const State &); // fixed-size base types only + ~State_var (void); // destructor + + State_var &operator= (State *); + State_var &operator= (const State_var &); + State_var &operator= (const State &); // fixed-size base types only + State *operator-> (void); + const State *operator-> (void) const; + + operator const State &() const; + operator State &(); + operator State &() const; + + CORBA::Octet &operator[] (CORBA::ULong index); + // in, inout, out, _retn + const State &in (void) const; + State &inout (void); + State *&out (void); + State *_retn (void); + State *ptr (void) const; + + private: + State *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_STATE___OUT_CH_) +#define _FT_STATE___OUT_CH_ + + class TAO_Export State_out + { + public: + State_out (State *&); + State_out (State_var &); + State_out (const State_out &); + State_out &operator= (const State_out &); + State_out &operator= (State *); + operator State *&(); + State *&ptr (void); + State *operator-> (void); + CORBA::Octet &operator[] (CORBA::ULong index); + + private: + State *&ptr_; + // assignment from T_var not allowed + void operator= (const State_var &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_State; + + +#if !defined (_FT_NOSTATEAVAILABLE_CH_) +#define _FT_NOSTATEAVAILABLE_CH_ + + class TAO_Export NoStateAvailable : public CORBA::UserException + { + public: + + + NoStateAvailable (void); // default ctor + NoStateAvailable (const NoStateAvailable &); // copy ctor + ~NoStateAvailable (void); + static void _tao_any_destructor (void*); + NoStateAvailable &operator= (const NoStateAvailable &); + + + virtual void _raise (void); + + virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; + virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + + static NoStateAvailable *_downcast (CORBA::Exception *); + + + // = TAO extension + static CORBA::Exception *_alloc (void); + +}; // exception FT::NoStateAvailable + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NoStateAvailable; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_INVALIDSTATE_CH_) +#define _FT_INVALIDSTATE_CH_ + +class TAO_Export InvalidState : public CORBA::UserException +{ +public: + + +InvalidState (void); // default ctor +InvalidState (const InvalidState &); // copy ctor +~InvalidState (void); +static void _tao_any_destructor (void*); +InvalidState &operator= (const InvalidState &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static InvalidState *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception FT::InvalidState + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InvalidState; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_NOUPDATEAVAILABLE_CH_) +#define _FT_NOUPDATEAVAILABLE_CH_ + +class TAO_Export NoUpdateAvailable : public CORBA::UserException +{ +public: + + +NoUpdateAvailable (void); // default ctor +NoUpdateAvailable (const NoUpdateAvailable &); // copy ctor +~NoUpdateAvailable (void); +static void _tao_any_destructor (void*); +NoUpdateAvailable &operator= (const NoUpdateAvailable &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static NoUpdateAvailable *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception FT::NoUpdateAvailable + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NoUpdateAvailable; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_INVALIDUPDATE_CH_) +#define _FT_INVALIDUPDATE_CH_ + +class TAO_Export InvalidUpdate : public CORBA::UserException +{ +public: + + +InvalidUpdate (void); // default ctor +InvalidUpdate (const InvalidUpdate &); // copy ctor +~InvalidUpdate (void); +static void _tao_any_destructor (void*); +InvalidUpdate &operator= (const InvalidUpdate &); + + +virtual void _raise (void); + +virtual void _tao_encode ( + TAO_OutputCDR &, + CORBA::Environment &) const; +virtual void _tao_decode ( + TAO_InputCDR &, + CORBA::Environment &); + +static InvalidUpdate *_downcast (CORBA::Exception *); + + +// = TAO extension +static CORBA::Exception *_alloc (void); + +}; // exception FT::InvalidUpdate + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InvalidUpdate; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_CHECKPOINTABLE___PTR_CH_) +#define _FT_CHECKPOINTABLE___PTR_CH_ + +class Checkpointable; +typedef Checkpointable *Checkpointable_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_CHECKPOINTABLE___VAR_CH_) +#define _FT_CHECKPOINTABLE___VAR_CH_ + +class TAO_Export Checkpointable_var : public TAO_Base_var +{ +public: + Checkpointable_var (void); // default constructor + Checkpointable_var (Checkpointable_ptr); + Checkpointable_var (const Checkpointable_var &); // copy constructor + ~Checkpointable_var (void); // destructor + + Checkpointable_var &operator= (Checkpointable_ptr); + Checkpointable_var &operator= (const Checkpointable_var &); + Checkpointable_ptr operator-> (void) const; + + operator const Checkpointable_ptr &() const; + operator Checkpointable_ptr &(); + // in, inout, out, _retn + Checkpointable_ptr in (void) const; + Checkpointable_ptr &inout (void); + Checkpointable_ptr &out (void); + Checkpointable_ptr _retn (void); + Checkpointable_ptr ptr (void) const; + +private: + Checkpointable_ptr ptr_; + // Unimplemented - prevents widening assignment. + Checkpointable_var (const TAO_Base_var &rhs); + Checkpointable_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_CHECKPOINTABLE___OUT_CH_) +#define _FT_CHECKPOINTABLE___OUT_CH_ + +class TAO_Export Checkpointable_out +{ +public: + Checkpointable_out (Checkpointable_ptr &); + Checkpointable_out (Checkpointable_var &); + Checkpointable_out (const Checkpointable_out &); + Checkpointable_out &operator= (const Checkpointable_out &); + Checkpointable_out &operator= (const Checkpointable_var &); + Checkpointable_out &operator= (Checkpointable_ptr); + operator Checkpointable_ptr &(); + Checkpointable_ptr &ptr (void); + Checkpointable_ptr operator-> (void); + +private: + Checkpointable_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_CHECKPOINTABLE_CH_) +#define _FT_CHECKPOINTABLE_CH_ + +class TAO_Export Checkpointable : public virtual CORBA_Object +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef Checkpointable_ptr _ptr_type; + typedef Checkpointable_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static Checkpointable_ptr _duplicate (Checkpointable_ptr obj); + static Checkpointable_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Checkpointable_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Checkpointable_ptr _nil (void) + { + return (Checkpointable_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual FT::State * get_state ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::NoStateAvailable + )); + + virtual void set_state ( + const FT::State & s, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::InvalidState + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + Checkpointable (void); + Checkpointable (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~Checkpointable (void); +private: + Checkpointable (const Checkpointable &); + void operator= (const Checkpointable &); +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Checkpointable; + + +#if !defined (_FT_UPDATEABLE___PTR_CH_) +#define _FT_UPDATEABLE___PTR_CH_ + +class Updateable; +typedef Updateable *Updateable_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_FT_UPDATEABLE___VAR_CH_) +#define _FT_UPDATEABLE___VAR_CH_ + +class TAO_Export Updateable_var : public TAO_Base_var +{ +public: + Updateable_var (void); // default constructor + Updateable_var (Updateable_ptr); + Updateable_var (const Updateable_var &); // copy constructor + ~Updateable_var (void); // destructor + + Updateable_var &operator= (Updateable_ptr); + Updateable_var &operator= (const Updateable_var &); + Updateable_ptr operator-> (void) const; + + operator const Updateable_ptr &() const; + operator Updateable_ptr &(); + // in, inout, out, _retn + Updateable_ptr in (void) const; + Updateable_ptr &inout (void); + Updateable_ptr &out (void); + Updateable_ptr _retn (void); + Updateable_ptr ptr (void) const; + +private: + Updateable_ptr ptr_; + // Unimplemented - prevents widening assignment. + Updateable_var (const TAO_Base_var &rhs); + Updateable_var &operator= (const TAO_Base_var &rhs); +}; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_UPDATEABLE___OUT_CH_) +#define _FT_UPDATEABLE___OUT_CH_ + +class TAO_Export Updateable_out +{ +public: + Updateable_out (Updateable_ptr &); + Updateable_out (Updateable_var &); + Updateable_out (const Updateable_out &); + Updateable_out &operator= (const Updateable_out &); + Updateable_out &operator= (const Updateable_var &); + Updateable_out &operator= (Updateable_ptr); + operator Updateable_ptr &(); + Updateable_ptr &ptr (void); + Updateable_ptr operator-> (void); + +private: + Updateable_ptr &ptr_; +}; + + +#endif /* end #if !defined */ + + +#if !defined (_FT_UPDATEABLE_CH_) +#define _FT_UPDATEABLE_CH_ + +class TAO_Export Updateable: public virtual Checkpointable +{ +public: +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef Updateable_ptr _ptr_type; + typedef Updateable_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations + static Updateable_ptr _duplicate (Updateable_ptr obj); + static Updateable_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Updateable_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static Updateable_ptr _nil (void) + { + return (Updateable_ptr)0; + } + + static void _tao_any_destructor (void*); + + virtual FT::State * get_update ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::NoUpdateAvailable + )); + + virtual void set_update ( + const FT::State & s, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException, + FT::InvalidUpdate + )); + + virtual CORBA::Boolean _is_a ( + const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + virtual void *_tao_QueryInterface (ptr_arith_t type); + + virtual const char* _interface_repository_id (void) const; + +protected: + Updateable (void); + Updateable (TAO_Stub *objref, + TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~Updateable (void); +private: + Updateable (const Updateable &); + void operator= (const Updateable &); +}; + + +#endif /* end #if !defined */ + +TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Updateable; + + +} +TAO_NAMESPACE_CLOSE // module FT + +TAO_Export void operator<<= (CORBA::Any &, const FT::TagFTGroupTaggedComponent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::TagFTGroupTaggedComponent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::TagFTGroupTaggedComponent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::TagFTGroupTaggedComponent *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::TagFTPrimaryTaggedComponent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::TagFTPrimaryTaggedComponent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::TagFTPrimaryTaggedComponent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::TagFTPrimaryTaggedComponent *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::FTGroupVersionServiceContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::FTGroupVersionServiceContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::FTGroupVersionServiceContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::FTGroupVersionServiceContext *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::FTRequestServiceContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::FTRequestServiceContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::FTRequestServiceContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::FTRequestServiceContext *&); +extern TAO_Export FT::RequestDurationPolicy_ptr (*_TAO_collocation_FT_RequestDurationPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface FT::RequestDurationPolicy +TAO_Export void operator<<= (CORBA::Any &, FT::RequestDurationPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::RequestDurationPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::TagFTHeartbeatEnabledTaggedComponent &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::TagFTHeartbeatEnabledTaggedComponent*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::TagFTHeartbeatEnabledTaggedComponent *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::TagFTHeartbeatEnabledTaggedComponent *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::HeartbeatPolicyValue &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::HeartbeatPolicyValue*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::HeartbeatPolicyValue *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::HeartbeatPolicyValue *&); +extern TAO_Export FT::HeartbeatPolicy_ptr (*_TAO_collocation_FT_HeartbeatPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface FT::HeartbeatPolicy +TAO_Export void operator<<= (CORBA::Any &, FT::HeartbeatPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::HeartbeatPolicy *&); +extern TAO_Export FT::HeartbeatEnabledPolicy_ptr (*_TAO_collocation_FT_HeartbeatEnabledPolicy_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface FT::HeartbeatEnabledPolicy +TAO_Export void operator<<= (CORBA::Any &, FT::HeartbeatEnabledPolicy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::HeartbeatEnabledPolicy *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::FaultMonitoringIntervalAndTimeoutValue &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::FaultMonitoringIntervalAndTimeoutValue*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::FaultMonitoringIntervalAndTimeoutValue *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::FaultMonitoringIntervalAndTimeoutValue *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::State &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::State*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::State *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::State *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::NoStateAvailable &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::NoStateAvailable*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::NoStateAvailable *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::NoStateAvailable *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::InvalidState &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::InvalidState*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::InvalidState *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::InvalidState *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::NoUpdateAvailable &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::NoUpdateAvailable*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::NoUpdateAvailable *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::NoUpdateAvailable *&); +TAO_Export void operator<<= (CORBA::Any &, const FT::InvalidUpdate &); // copying version +TAO_Export void operator<<= (CORBA::Any &, FT::InvalidUpdate*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::InvalidUpdate *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const FT::InvalidUpdate *&); +extern TAO_Export FT::Checkpointable_ptr (*_TAO_collocation_FT_Checkpointable_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface FT::Checkpointable +TAO_Export void operator<<= (CORBA::Any &, FT::Checkpointable_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::Checkpointable *&); +extern TAO_Export FT::Updateable_ptr (*_TAO_collocation_FT_Updateable_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +// Any operators for interface FT::Updateable +TAO_Export void operator<<= (CORBA::Any &, FT::Updateable_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, FT::Updateable *&); + +#ifndef __ACE_INLINE__ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::TagFTGroupTaggedComponent &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::TagFTGroupTaggedComponent &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::TagFTPrimaryTaggedComponent &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::TagFTPrimaryTaggedComponent &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::FTGroupVersionServiceContext &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::FTGroupVersionServiceContext &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::FTRequestServiceContext &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::FTRequestServiceContext &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::RequestDurationPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::RequestDurationPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::TagFTHeartbeatEnabledTaggedComponent &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::TagFTHeartbeatEnabledTaggedComponent &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::HeartbeatPolicyValue &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::HeartbeatPolicyValue &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::HeartbeatPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::HeartbeatPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::HeartbeatEnabledPolicy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::HeartbeatEnabledPolicy_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::FaultMonitoringIntervalAndTimeoutValue &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::FaultMonitoringIntervalAndTimeoutValue &); + +#if !defined _TAO_CDR_OP_FT_State_H_ +#define _TAO_CDR_OP_FT_State_H_ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const FT::State & + ); +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + FT::State & + ); + +#endif /* _TAO_CDR_OP_FT_State_H_ */ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::NoStateAvailable &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::NoStateAvailable &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_Export ostream& operator<< (ostream &, const FT::NoStateAvailable &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::InvalidState &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::InvalidState &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_Export ostream& operator<< (ostream &, const FT::InvalidState &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::NoUpdateAvailable &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::NoUpdateAvailable &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_Export ostream& operator<< (ostream &, const FT::NoUpdateAvailable &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::InvalidUpdate &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::InvalidUpdate &); + +# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +TAO_Export ostream& operator<< (ostream &, const FT::InvalidUpdate &); + +# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::Checkpointable_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::Checkpointable_ptr &); +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const FT::Updateable_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, FT::Updateable_ptr &); + +#endif /* __ACE_INLINE__ */ + + +#if defined (__ACE_INLINE__) +#include "FT_CORBAC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#endif /* ifndef */ diff --git a/TAO/tao/FT_CORBAC.i b/TAO/tao/FT_CORBAC.i new file mode 100644 index 00000000000..bf963e85437 --- /dev/null +++ b/TAO/tao/FT_CORBAC.i @@ -0,0 +1,3070 @@ +/* -*- C++ -*- $Id$ */ + +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// ************************************************************* +// Inline operations for class FT::TagFTGroupTaggedComponent_var +// ************************************************************* + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::TagFTGroupTaggedComponent_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::TagFTGroupTaggedComponent_var (TagFTGroupTaggedComponent *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::TagFTGroupTaggedComponent_var (const ::FT::TagFTGroupTaggedComponent_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::TagFTGroupTaggedComponent (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::~TagFTGroupTaggedComponent_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::TagFTGroupTaggedComponent_var & +FT::TagFTGroupTaggedComponent_var::operator= (TagFTGroupTaggedComponent *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent_var & +FT::TagFTGroupTaggedComponent_var::operator= (const ::FT::TagFTGroupTaggedComponent_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::TagFTGroupTaggedComponent (*p.ptr_), *this); + } + return *this; +} + +ACE_INLINE const ::FT::TagFTGroupTaggedComponent * +FT::TagFTGroupTaggedComponent_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent * +FT::TagFTGroupTaggedComponent_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::operator const ::FT::TagFTGroupTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::operator ::FT::TagFTGroupTaggedComponent &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::operator ::FT::TagFTGroupTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +FT::TagFTGroupTaggedComponent_var::operator ::FT::TagFTGroupTaggedComponent *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::FT::TagFTGroupTaggedComponent & +FT::TagFTGroupTaggedComponent_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent & +FT::TagFTGroupTaggedComponent_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::FT::TagFTGroupTaggedComponent *& +FT::TagFTGroupTaggedComponent_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent * +FT::TagFTGroupTaggedComponent_var::_retn (void) +{ + ::FT::TagFTGroupTaggedComponent *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent * +FT::TagFTGroupTaggedComponent_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::TagFTGroupTaggedComponent_out +// ************************************************************* + +ACE_INLINE +FT::TagFTGroupTaggedComponent_out::TagFTGroupTaggedComponent_out (::FT::TagFTGroupTaggedComponent *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_out::TagFTGroupTaggedComponent_out (TagFTGroupTaggedComponent_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_out::TagFTGroupTaggedComponent_out (const ::FT::TagFTGroupTaggedComponent_out &p) // copy constructor + : ptr_ (ACE_const_cast (TagFTGroupTaggedComponent_out&, p).ptr_) +{} + +ACE_INLINE FT::TagFTGroupTaggedComponent_out & +FT::TagFTGroupTaggedComponent_out::operator= (const ::FT::TagFTGroupTaggedComponent_out &p) +{ + this->ptr_ = ACE_const_cast (TagFTGroupTaggedComponent_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::TagFTGroupTaggedComponent_out & +FT::TagFTGroupTaggedComponent_out::operator= (TagFTGroupTaggedComponent *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::TagFTGroupTaggedComponent_out::operator ::FT::TagFTGroupTaggedComponent *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent *& +FT::TagFTGroupTaggedComponent_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTGroupTaggedComponent * +FT::TagFTGroupTaggedComponent_out::operator-> (void) +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::TagFTPrimaryTaggedComponent_var +// ************************************************************* + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::TagFTPrimaryTaggedComponent_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::TagFTPrimaryTaggedComponent_var (TagFTPrimaryTaggedComponent *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::TagFTPrimaryTaggedComponent_var (const ::FT::TagFTPrimaryTaggedComponent_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::TagFTPrimaryTaggedComponent (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::TagFTPrimaryTaggedComponent_var (const ::FT::TagFTPrimaryTaggedComponent &p) +{ + ACE_NEW (this->ptr_, ::FT::TagFTPrimaryTaggedComponent (p)); +} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::~TagFTPrimaryTaggedComponent_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::TagFTPrimaryTaggedComponent_var & +FT::TagFTPrimaryTaggedComponent_var::operator= (TagFTPrimaryTaggedComponent *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent_var & +FT::TagFTPrimaryTaggedComponent_var::operator= (const ::FT::TagFTPrimaryTaggedComponent_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::TagFTPrimaryTaggedComponent (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE FT::TagFTPrimaryTaggedComponent_var & +FT::TagFTPrimaryTaggedComponent_var::operator= (const ::FT::TagFTPrimaryTaggedComponent &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::TagFTPrimaryTaggedComponent (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::TagFTPrimaryTaggedComponent * +FT::TagFTPrimaryTaggedComponent_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent * +FT::TagFTPrimaryTaggedComponent_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::operator const ::FT::TagFTPrimaryTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::operator ::FT::TagFTPrimaryTaggedComponent &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTPrimaryTaggedComponent_var::operator ::FT::TagFTPrimaryTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::FT::TagFTPrimaryTaggedComponent & +FT::TagFTPrimaryTaggedComponent_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent & +FT::TagFTPrimaryTaggedComponent_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent & +FT::TagFTPrimaryTaggedComponent_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent +FT::TagFTPrimaryTaggedComponent_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTPrimaryTaggedComponent * +FT::TagFTPrimaryTaggedComponent_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::FTGroupVersionServiceContext_var +// ************************************************************* + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::FTGroupVersionServiceContext_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::FTGroupVersionServiceContext_var (FTGroupVersionServiceContext *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::FTGroupVersionServiceContext_var (const ::FT::FTGroupVersionServiceContext_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::FTGroupVersionServiceContext (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +FT::FTGroupVersionServiceContext_var::FTGroupVersionServiceContext_var (const ::FT::FTGroupVersionServiceContext &p) +{ + ACE_NEW (this->ptr_, ::FT::FTGroupVersionServiceContext (p)); +} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::~FTGroupVersionServiceContext_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::FTGroupVersionServiceContext_var & +FT::FTGroupVersionServiceContext_var::operator= (FTGroupVersionServiceContext *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::FTGroupVersionServiceContext_var & +FT::FTGroupVersionServiceContext_var::operator= (const ::FT::FTGroupVersionServiceContext_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::FTGroupVersionServiceContext (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE FT::FTGroupVersionServiceContext_var & +FT::FTGroupVersionServiceContext_var::operator= (const ::FT::FTGroupVersionServiceContext &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::FTGroupVersionServiceContext (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::FTGroupVersionServiceContext * +FT::FTGroupVersionServiceContext_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::FTGroupVersionServiceContext * +FT::FTGroupVersionServiceContext_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::operator const ::FT::FTGroupVersionServiceContext &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::operator ::FT::FTGroupVersionServiceContext &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FTGroupVersionServiceContext_var::operator ::FT::FTGroupVersionServiceContext &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::FT::FTGroupVersionServiceContext & +FT::FTGroupVersionServiceContext_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FTGroupVersionServiceContext & +FT::FTGroupVersionServiceContext_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::FT::FTGroupVersionServiceContext & +FT::FTGroupVersionServiceContext_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FTGroupVersionServiceContext +FT::FTGroupVersionServiceContext_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FTGroupVersionServiceContext * +FT::FTGroupVersionServiceContext_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::FTRequestServiceContext_var +// ************************************************************* + +ACE_INLINE +FT::FTRequestServiceContext_var::FTRequestServiceContext_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::FTRequestServiceContext_var::FTRequestServiceContext_var (FTRequestServiceContext *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::FTRequestServiceContext_var::FTRequestServiceContext_var (const ::FT::FTRequestServiceContext_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::FTRequestServiceContext (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +FT::FTRequestServiceContext_var::~FTRequestServiceContext_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::FTRequestServiceContext_var & +FT::FTRequestServiceContext_var::operator= (FTRequestServiceContext *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::FTRequestServiceContext_var & +FT::FTRequestServiceContext_var::operator= (const ::FT::FTRequestServiceContext_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::FTRequestServiceContext (*p.ptr_), *this); + } + return *this; +} + +ACE_INLINE const ::FT::FTRequestServiceContext * +FT::FTRequestServiceContext_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::FTRequestServiceContext * +FT::FTRequestServiceContext_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::FTRequestServiceContext_var::operator const ::FT::FTRequestServiceContext &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FTRequestServiceContext_var::operator ::FT::FTRequestServiceContext &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FTRequestServiceContext_var::operator ::FT::FTRequestServiceContext &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +FT::FTRequestServiceContext_var::operator ::FT::FTRequestServiceContext *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::FT::FTRequestServiceContext & +FT::FTRequestServiceContext_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FTRequestServiceContext & +FT::FTRequestServiceContext_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::FT::FTRequestServiceContext *& +FT::FTRequestServiceContext_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::FT::FTRequestServiceContext * +FT::FTRequestServiceContext_var::_retn (void) +{ + ::FT::FTRequestServiceContext *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::FT::FTRequestServiceContext * +FT::FTRequestServiceContext_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::FTRequestServiceContext_out +// ************************************************************* + +ACE_INLINE +FT::FTRequestServiceContext_out::FTRequestServiceContext_out (::FT::FTRequestServiceContext *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +FT::FTRequestServiceContext_out::FTRequestServiceContext_out (FTRequestServiceContext_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +FT::FTRequestServiceContext_out::FTRequestServiceContext_out (const ::FT::FTRequestServiceContext_out &p) // copy constructor + : ptr_ (ACE_const_cast (FTRequestServiceContext_out&, p).ptr_) +{} + +ACE_INLINE FT::FTRequestServiceContext_out & +FT::FTRequestServiceContext_out::operator= (const ::FT::FTRequestServiceContext_out &p) +{ + this->ptr_ = ACE_const_cast (FTRequestServiceContext_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::FTRequestServiceContext_out & +FT::FTRequestServiceContext_out::operator= (FTRequestServiceContext *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::FTRequestServiceContext_out::operator ::FT::FTRequestServiceContext *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::FTRequestServiceContext *& +FT::FTRequestServiceContext_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::FTRequestServiceContext * +FT::FTRequestServiceContext_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::RequestDurationPolicy::RequestDurationPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_REQUESTDURATIONPOLICY___VAR_CI_) +#define _FT_REQUESTDURATIONPOLICY___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::RequestDurationPolicy_var +// ************************************************************* + +ACE_INLINE +FT::RequestDurationPolicy_var::RequestDurationPolicy_var (void) // default constructor + : ptr_ (RequestDurationPolicy::_nil ()) +{} + +ACE_INLINE +FT::RequestDurationPolicy_var::RequestDurationPolicy_var (RequestDurationPolicy_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::RequestDurationPolicy_var::RequestDurationPolicy_var (const ::FT::RequestDurationPolicy_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (RequestDurationPolicy::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::RequestDurationPolicy_var::~RequestDurationPolicy_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::RequestDurationPolicy_var & +FT::RequestDurationPolicy_var::operator= (RequestDurationPolicy_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::RequestDurationPolicy_var & +FT::RequestDurationPolicy_var::operator= (const ::FT::RequestDurationPolicy_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::FT::RequestDurationPolicy::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::RequestDurationPolicy_var::operator const ::FT::RequestDurationPolicy_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::RequestDurationPolicy_var::operator ::FT::RequestDurationPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr & +FT::RequestDurationPolicy_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr & +FT::RequestDurationPolicy_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::RequestDurationPolicy::_nil (); + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy_var::_retn (void) +{ + // yield ownership of managed obj reference + ::FT::RequestDurationPolicy_ptr val = this->ptr_; + this->ptr_ = ::FT::RequestDurationPolicy::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_REQUESTDURATIONPOLICY___OUT_CI_) +#define _FT_REQUESTDURATIONPOLICY___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::RequestDurationPolicy_out +// ************************************************************* + +ACE_INLINE +FT::RequestDurationPolicy_out::RequestDurationPolicy_out (RequestDurationPolicy_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::FT::RequestDurationPolicy::_nil (); +} + +ACE_INLINE +FT::RequestDurationPolicy_out::RequestDurationPolicy_out (RequestDurationPolicy_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::RequestDurationPolicy::_nil (); +} + +ACE_INLINE +FT::RequestDurationPolicy_out::RequestDurationPolicy_out (const ::FT::RequestDurationPolicy_out &p) // copy constructor + : ptr_ (ACE_const_cast (RequestDurationPolicy_out &, p).ptr_) +{} + +ACE_INLINE ::FT::RequestDurationPolicy_out & +FT::RequestDurationPolicy_out::operator= (const ::FT::RequestDurationPolicy_out &p) +{ + this->ptr_ = ACE_const_cast (RequestDurationPolicy_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::RequestDurationPolicy_out & +FT::RequestDurationPolicy_out::operator= (const ::FT::RequestDurationPolicy_var &p) +{ + this->ptr_ = ::FT::RequestDurationPolicy::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::RequestDurationPolicy_out & +FT::RequestDurationPolicy_out::operator= (RequestDurationPolicy_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::RequestDurationPolicy_out::operator ::FT::RequestDurationPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr & +FT::RequestDurationPolicy_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::RequestDurationPolicy_ptr +FT::RequestDurationPolicy_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +// ************************************************************* +// Inline operations for class FT::TagFTHeartbeatEnabledTaggedComponent_var +// ************************************************************* + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::TagFTHeartbeatEnabledTaggedComponent_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::TagFTHeartbeatEnabledTaggedComponent_var (TagFTHeartbeatEnabledTaggedComponent *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::TagFTHeartbeatEnabledTaggedComponent_var (const ::FT::TagFTHeartbeatEnabledTaggedComponent_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::TagFTHeartbeatEnabledTaggedComponent (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::TagFTHeartbeatEnabledTaggedComponent_var (const ::FT::TagFTHeartbeatEnabledTaggedComponent &p) +{ + ACE_NEW (this->ptr_, ::FT::TagFTHeartbeatEnabledTaggedComponent (p)); +} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::~TagFTHeartbeatEnabledTaggedComponent_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::TagFTHeartbeatEnabledTaggedComponent_var & +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator= (TagFTHeartbeatEnabledTaggedComponent *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent_var & +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator= (const ::FT::TagFTHeartbeatEnabledTaggedComponent_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::TagFTHeartbeatEnabledTaggedComponent (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE FT::TagFTHeartbeatEnabledTaggedComponent_var & +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator= (const ::FT::TagFTHeartbeatEnabledTaggedComponent &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::TagFTHeartbeatEnabledTaggedComponent (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::TagFTHeartbeatEnabledTaggedComponent * +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent * +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator const ::FT::TagFTHeartbeatEnabledTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator ::FT::TagFTHeartbeatEnabledTaggedComponent &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::TagFTHeartbeatEnabledTaggedComponent_var::operator ::FT::TagFTHeartbeatEnabledTaggedComponent &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::FT::TagFTHeartbeatEnabledTaggedComponent & +FT::TagFTHeartbeatEnabledTaggedComponent_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent & +FT::TagFTHeartbeatEnabledTaggedComponent_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent & +FT::TagFTHeartbeatEnabledTaggedComponent_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent +FT::TagFTHeartbeatEnabledTaggedComponent_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::TagFTHeartbeatEnabledTaggedComponent * +FT::TagFTHeartbeatEnabledTaggedComponent_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::HeartbeatPolicyValue_var +// ************************************************************* + +ACE_INLINE +FT::HeartbeatPolicyValue_var::HeartbeatPolicyValue_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::HeartbeatPolicyValue_var (HeartbeatPolicyValue *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::HeartbeatPolicyValue_var (const ::FT::HeartbeatPolicyValue_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::HeartbeatPolicyValue (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +FT::HeartbeatPolicyValue_var::HeartbeatPolicyValue_var (const ::FT::HeartbeatPolicyValue &p) +{ + ACE_NEW (this->ptr_, ::FT::HeartbeatPolicyValue (p)); +} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::~HeartbeatPolicyValue_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::HeartbeatPolicyValue_var & +FT::HeartbeatPolicyValue_var::operator= (HeartbeatPolicyValue *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::HeartbeatPolicyValue_var & +FT::HeartbeatPolicyValue_var::operator= (const ::FT::HeartbeatPolicyValue_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::HeartbeatPolicyValue (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE FT::HeartbeatPolicyValue_var & +FT::HeartbeatPolicyValue_var::operator= (const ::FT::HeartbeatPolicyValue &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::HeartbeatPolicyValue (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::HeartbeatPolicyValue * +FT::HeartbeatPolicyValue_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicyValue * +FT::HeartbeatPolicyValue_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::operator const ::FT::HeartbeatPolicyValue &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::operator ::FT::HeartbeatPolicyValue &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicyValue_var::operator ::FT::HeartbeatPolicyValue &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::FT::HeartbeatPolicyValue & +FT::HeartbeatPolicyValue_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicyValue & +FT::HeartbeatPolicyValue_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::FT::HeartbeatPolicyValue & +FT::HeartbeatPolicyValue_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicyValue +FT::HeartbeatPolicyValue_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicyValue * +FT::HeartbeatPolicyValue_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicy::HeartbeatPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_HEARTBEATPOLICY___VAR_CI_) +#define _FT_HEARTBEATPOLICY___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::HeartbeatPolicy_var +// ************************************************************* + +ACE_INLINE +FT::HeartbeatPolicy_var::HeartbeatPolicy_var (void) // default constructor + : ptr_ (HeartbeatPolicy::_nil ()) +{} + +ACE_INLINE +FT::HeartbeatPolicy_var::HeartbeatPolicy_var (HeartbeatPolicy_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicy_var::HeartbeatPolicy_var (const ::FT::HeartbeatPolicy_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (HeartbeatPolicy::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::HeartbeatPolicy_var::~HeartbeatPolicy_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::HeartbeatPolicy_var & +FT::HeartbeatPolicy_var::operator= (HeartbeatPolicy_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::HeartbeatPolicy_var & +FT::HeartbeatPolicy_var::operator= (const ::FT::HeartbeatPolicy_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatPolicy::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::HeartbeatPolicy_var::operator const ::FT::HeartbeatPolicy_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatPolicy_var::operator ::FT::HeartbeatPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr & +FT::HeartbeatPolicy_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr & +FT::HeartbeatPolicy_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatPolicy::_nil (); + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy_var::_retn (void) +{ + // yield ownership of managed obj reference + ::FT::HeartbeatPolicy_ptr val = this->ptr_; + this->ptr_ = ::FT::HeartbeatPolicy::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATPOLICY___OUT_CI_) +#define _FT_HEARTBEATPOLICY___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::HeartbeatPolicy_out +// ************************************************************* + +ACE_INLINE +FT::HeartbeatPolicy_out::HeartbeatPolicy_out (HeartbeatPolicy_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::FT::HeartbeatPolicy::_nil (); +} + +ACE_INLINE +FT::HeartbeatPolicy_out::HeartbeatPolicy_out (HeartbeatPolicy_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatPolicy::_nil (); +} + +ACE_INLINE +FT::HeartbeatPolicy_out::HeartbeatPolicy_out (const ::FT::HeartbeatPolicy_out &p) // copy constructor + : ptr_ (ACE_const_cast (HeartbeatPolicy_out &, p).ptr_) +{} + +ACE_INLINE ::FT::HeartbeatPolicy_out & +FT::HeartbeatPolicy_out::operator= (const ::FT::HeartbeatPolicy_out &p) +{ + this->ptr_ = ACE_const_cast (HeartbeatPolicy_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::HeartbeatPolicy_out & +FT::HeartbeatPolicy_out::operator= (const ::FT::HeartbeatPolicy_var &p) +{ + this->ptr_ = ::FT::HeartbeatPolicy::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::HeartbeatPolicy_out & +FT::HeartbeatPolicy_out::operator= (HeartbeatPolicy_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::HeartbeatPolicy_out::operator ::FT::HeartbeatPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr & +FT::HeartbeatPolicy_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatPolicy_ptr +FT::HeartbeatPolicy_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +ACE_INLINE +FT::HeartbeatEnabledPolicy::HeartbeatEnabledPolicy (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY___VAR_CI_) +#define _FT_HEARTBEATENABLEDPOLICY___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::HeartbeatEnabledPolicy_var +// ************************************************************* + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::HeartbeatEnabledPolicy_var (void) // default constructor + : ptr_ (HeartbeatEnabledPolicy::_nil ()) +{} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::HeartbeatEnabledPolicy_var (HeartbeatEnabledPolicy_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::HeartbeatEnabledPolicy_var (const ::FT::HeartbeatEnabledPolicy_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (HeartbeatEnabledPolicy::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::~HeartbeatEnabledPolicy_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::HeartbeatEnabledPolicy_var & +FT::HeartbeatEnabledPolicy_var::operator= (HeartbeatEnabledPolicy_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::HeartbeatEnabledPolicy_var & +FT::HeartbeatEnabledPolicy_var::operator= (const ::FT::HeartbeatEnabledPolicy_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::operator const ::FT::HeartbeatEnabledPolicy_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_var::operator ::FT::HeartbeatEnabledPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr & +FT::HeartbeatEnabledPolicy_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr & +FT::HeartbeatEnabledPolicy_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_nil (); + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy_var::_retn (void) +{ + // yield ownership of managed obj reference + ::FT::HeartbeatEnabledPolicy_ptr val = this->ptr_; + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_HEARTBEATENABLEDPOLICY___OUT_CI_) +#define _FT_HEARTBEATENABLEDPOLICY___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::HeartbeatEnabledPolicy_out +// ************************************************************* + +ACE_INLINE +FT::HeartbeatEnabledPolicy_out::HeartbeatEnabledPolicy_out (HeartbeatEnabledPolicy_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_nil (); +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_out::HeartbeatEnabledPolicy_out (HeartbeatEnabledPolicy_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_nil (); +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_out::HeartbeatEnabledPolicy_out (const ::FT::HeartbeatEnabledPolicy_out &p) // copy constructor + : ptr_ (ACE_const_cast (HeartbeatEnabledPolicy_out &, p).ptr_) +{} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_out & +FT::HeartbeatEnabledPolicy_out::operator= (const ::FT::HeartbeatEnabledPolicy_out &p) +{ + this->ptr_ = ACE_const_cast (HeartbeatEnabledPolicy_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::HeartbeatEnabledPolicy_out & +FT::HeartbeatEnabledPolicy_out::operator= (const ::FT::HeartbeatEnabledPolicy_var &p) +{ + this->ptr_ = ::FT::HeartbeatEnabledPolicy::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::HeartbeatEnabledPolicy_out & +FT::HeartbeatEnabledPolicy_out::operator= (HeartbeatEnabledPolicy_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::HeartbeatEnabledPolicy_out::operator ::FT::HeartbeatEnabledPolicy_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr & +FT::HeartbeatEnabledPolicy_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::HeartbeatEnabledPolicy_ptr +FT::HeartbeatEnabledPolicy_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +ACE_INLINE +FT::GenericFactory::GenericFactory (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_GENERICFACTORY___VAR_CI_) +#define _FT_GENERICFACTORY___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::GenericFactory_var +// ************************************************************* + +ACE_INLINE +FT::GenericFactory_var::GenericFactory_var (void) // default constructor + : ptr_ (FT::GenericFactory::_nil ()) +{} + +ACE_INLINE +FT::GenericFactory_var::GenericFactory_var (FT::GenericFactory_ptr p) + : ptr_ (p) +{} + +ACE_INLINE FT::GenericFactory_ptr +FT::GenericFactory_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::GenericFactory_var::GenericFactory_var (const FT::GenericFactory_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (GenericFactory::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::GenericFactory_var::~GenericFactory_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::GenericFactory_var & +FT::GenericFactory_var::operator= (FT::GenericFactory_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::GenericFactory_var & +FT::GenericFactory_var::operator= (const FT::GenericFactory_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = FT::GenericFactory::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::GenericFactory_var::operator const FT::GenericFactory_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::GenericFactory_var::operator FT::GenericFactory_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr +FT::GenericFactory_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr +FT::GenericFactory_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr & +FT::GenericFactory_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr & +FT::GenericFactory_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = FT::GenericFactory::_nil (); + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr +FT::GenericFactory_var::_retn (void) +{ + // yield ownership of managed obj reference + FT::GenericFactory_ptr val = this->ptr_; + this->ptr_ = FT::GenericFactory::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_GENERICFACTORY___OUT_CI_) +#define _FT_GENERICFACTORY___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::GenericFactory_out +// ************************************************************* + +ACE_INLINE +FT::GenericFactory_out::GenericFactory_out (FT::GenericFactory_ptr &p) + : ptr_ (p) +{ + this->ptr_ = FT::GenericFactory::_nil (); +} + +ACE_INLINE +FT::GenericFactory_out::GenericFactory_out (FT::GenericFactory_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = FT::GenericFactory::_nil (); +} + +ACE_INLINE +FT::GenericFactory_out::GenericFactory_out (const FT::GenericFactory_out &p) // copy constructor + : ptr_ (ACE_const_cast (FT::GenericFactory_out&,p).ptr_) +{} + +ACE_INLINE FT::GenericFactory_out & +FT::GenericFactory_out::operator= (const FT::GenericFactory_out &p) +{ + this->ptr_ = ACE_const_cast (FT::GenericFactory_out&,p).ptr_; + return *this; +} + +ACE_INLINE FT::GenericFactory_out & +FT::GenericFactory_out::operator= (const FT::GenericFactory_var &p) +{ + this->ptr_ = FT::GenericFactory::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::GenericFactory_out & +FT::GenericFactory_out::operator= (FT::GenericFactory_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::GenericFactory_out::operator FT::GenericFactory_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr & +FT::GenericFactory_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE FT::GenericFactory_ptr +FT::GenericFactory_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +ACE_INLINE +FT::FaultNotifier::FaultNotifier (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_FAULTNOTIFIER___VAR_CI_) +#define _FT_FAULTNOTIFIER___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::FaultNotifier_var +// ************************************************************* + +ACE_INLINE +FT::FaultNotifier_var::FaultNotifier_var (void) // default constructor + : ptr_ (FT::FaultNotifier::_nil ()) +{} + +ACE_INLINE +FT::FaultNotifier_var::FaultNotifier_var (FT::FaultNotifier_ptr p) + : ptr_ (p) +{} + +ACE_INLINE FT::FaultNotifier_ptr +FT::FaultNotifier_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::FaultNotifier_var::FaultNotifier_var (const FT::FaultNotifier_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (FaultNotifier::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::FaultNotifier_var::~FaultNotifier_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::FaultNotifier_var & +FT::FaultNotifier_var::operator= (FT::FaultNotifier_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::FaultNotifier_var & +FT::FaultNotifier_var::operator= (const FT::FaultNotifier_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = FT::FaultNotifier::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::FaultNotifier_var::operator const FT::FaultNotifier_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::FaultNotifier_var::operator FT::FaultNotifier_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr +FT::FaultNotifier_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr +FT::FaultNotifier_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr & +FT::FaultNotifier_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr & +FT::FaultNotifier_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = FT::FaultNotifier::_nil (); + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr +FT::FaultNotifier_var::_retn (void) +{ + // yield ownership of managed obj reference + FT::FaultNotifier_ptr val = this->ptr_; + this->ptr_ = FT::FaultNotifier::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_FAULTNOTIFIER___OUT_CI_) +#define _FT_FAULTNOTIFIER___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::FaultNotifier_out +// ************************************************************* + +ACE_INLINE +FT::FaultNotifier_out::FaultNotifier_out (FT::FaultNotifier_ptr &p) + : ptr_ (p) +{ + this->ptr_ = FT::FaultNotifier::_nil (); +} + +ACE_INLINE +FT::FaultNotifier_out::FaultNotifier_out (FT::FaultNotifier_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = FT::FaultNotifier::_nil (); +} + +ACE_INLINE +FT::FaultNotifier_out::FaultNotifier_out (const FT::FaultNotifier_out &p) // copy constructor + : ptr_ (ACE_const_cast (FT::FaultNotifier_out&,p).ptr_) +{} + +ACE_INLINE FT::FaultNotifier_out & +FT::FaultNotifier_out::operator= (const FT::FaultNotifier_out &p) +{ + this->ptr_ = ACE_const_cast (FT::FaultNotifier_out&,p).ptr_; + return *this; +} + +ACE_INLINE FT::FaultNotifier_out & +FT::FaultNotifier_out::operator= (const FT::FaultNotifier_var &p) +{ + this->ptr_ = FT::FaultNotifier::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::FaultNotifier_out & +FT::FaultNotifier_out::operator= (FT::FaultNotifier_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::FaultNotifier_out::operator FT::FaultNotifier_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr & +FT::FaultNotifier_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE FT::FaultNotifier_ptr +FT::FaultNotifier_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +// ************************************************************* +// Inline operations for class FT::FaultMonitoringIntervalAndTimeoutValue_var +// ************************************************************* + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::FaultMonitoringIntervalAndTimeoutValue_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::FaultMonitoringIntervalAndTimeoutValue_var (FaultMonitoringIntervalAndTimeoutValue *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::FaultMonitoringIntervalAndTimeoutValue_var (const ::FT::FaultMonitoringIntervalAndTimeoutValue_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::FaultMonitoringIntervalAndTimeoutValue (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size types only +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::FaultMonitoringIntervalAndTimeoutValue_var (const ::FT::FaultMonitoringIntervalAndTimeoutValue &p) +{ + ACE_NEW (this->ptr_, ::FT::FaultMonitoringIntervalAndTimeoutValue (p)); +} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::~FaultMonitoringIntervalAndTimeoutValue_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::FaultMonitoringIntervalAndTimeoutValue_var & +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator= (FaultMonitoringIntervalAndTimeoutValue *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue_var & +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator= (const ::FT::FaultMonitoringIntervalAndTimeoutValue_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::FaultMonitoringIntervalAndTimeoutValue (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE FT::FaultMonitoringIntervalAndTimeoutValue_var & +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator= (const ::FT::FaultMonitoringIntervalAndTimeoutValue &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::FaultMonitoringIntervalAndTimeoutValue (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::FaultMonitoringIntervalAndTimeoutValue * +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue * +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator const ::FT::FaultMonitoringIntervalAndTimeoutValue &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator ::FT::FaultMonitoringIntervalAndTimeoutValue &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::FaultMonitoringIntervalAndTimeoutValue_var::operator ::FT::FaultMonitoringIntervalAndTimeoutValue &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE const ::FT::FaultMonitoringIntervalAndTimeoutValue & +FT::FaultMonitoringIntervalAndTimeoutValue_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue & +FT::FaultMonitoringIntervalAndTimeoutValue_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for fixed size +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue & +FT::FaultMonitoringIntervalAndTimeoutValue_var::out (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue +FT::FaultMonitoringIntervalAndTimeoutValue_var::_retn (void) +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::FaultMonitoringIntervalAndTimeoutValue * +FT::FaultMonitoringIntervalAndTimeoutValue_var::ptr (void) const +{ + return this->ptr_; +} + + +#if !defined (_FT_STATE_CI_) +#define _FT_STATE_CI_ + +// ************************************************************* +// Inline operations for class FT::State_var +// ************************************************************* + +ACE_INLINE +FT::State_var::State_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +FT::State_var::State_var (State *p) + : ptr_ (p) +{} + +ACE_INLINE +FT::State_var::State_var (const ::FT::State_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::FT::State (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size base types only +ACE_INLINE +FT::State_var::State_var (const ::FT::State &p) +{ + ACE_NEW (this->ptr_, ::FT::State (p)); +} + +ACE_INLINE +FT::State_var::~State_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE FT::State_var & +FT::State_var::operator= (State *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::State_var & +FT::State_var::operator= (const ::FT::State_var &p) // deep copy +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::State (*p.ptr_), *this); + } + return *this; +} + +// fixed-size types only +ACE_INLINE ::FT::State_var & +FT::State_var::operator= (const ::FT::State &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::FT::State (p), *this); + } + return *this; +} + +ACE_INLINE const ::FT::State * +FT::State_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::State * +FT::State_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +FT::State_var::operator const ::FT::State &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::State_var::operator ::FT::State &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +FT::State_var::operator ::FT::State &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE CORBA::Octet & +FT::State_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE const ::FT::State & +FT::State_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::FT::State & +FT::State_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::FT::State *& +FT::State_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::FT::State * +FT::State_var::_retn (void) +{ + ::FT::State *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::FT::State * +FT::State_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class FT::State_out +// ************************************************************* + +ACE_INLINE +FT::State_out::State_out (State *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +FT::State_out::State_out (State_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +FT::State_out::State_out (const ::FT::State_out &p) // copy constructor + : ptr_ (ACE_const_cast (State_out&, p).ptr_) +{} + +ACE_INLINE ::FT::State_out & +FT::State_out::operator= (const ::FT::State_out &p) +{ + this->ptr_ = ACE_const_cast (State_out&, p).ptr_; + return *this; +} + +ACE_INLINE ::FT::State_out & +FT::State_out::operator= (State *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::State_out::operator ::FT::State *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::State *& +FT::State_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::State * +FT::State_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE CORBA::Octet & +FT::State_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + + +#endif /* end #if !defined */ + +// ************************************************************* +// Inline operations for exception FT::NoStateAvailable +// ************************************************************* + +// ************************************************************* +// Inline operations for exception FT::InvalidState +// ************************************************************* + +// ************************************************************* +// Inline operations for exception FT::NoUpdateAvailable +// ************************************************************* + +// ************************************************************* +// Inline operations for exception FT::InvalidUpdate +// ************************************************************* + +ACE_INLINE +FT::Checkpointable::Checkpointable (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_CHECKPOINTABLE___VAR_CI_) +#define _FT_CHECKPOINTABLE___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::Checkpointable_var +// ************************************************************* + +ACE_INLINE +FT::Checkpointable_var::Checkpointable_var (void) // default constructor + : ptr_ (Checkpointable::_nil ()) +{} + +ACE_INLINE +FT::Checkpointable_var::Checkpointable_var (Checkpointable_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::FT::Checkpointable_ptr +FT::Checkpointable_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::Checkpointable_var::Checkpointable_var (const ::FT::Checkpointable_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (Checkpointable::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::Checkpointable_var::~Checkpointable_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::Checkpointable_var & +FT::Checkpointable_var::operator= (Checkpointable_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::Checkpointable_var & +FT::Checkpointable_var::operator= (const ::FT::Checkpointable_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Checkpointable::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::Checkpointable_var::operator const ::FT::Checkpointable_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::Checkpointable_var::operator ::FT::Checkpointable_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr +FT::Checkpointable_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr +FT::Checkpointable_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr & +FT::Checkpointable_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr & +FT::Checkpointable_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Checkpointable::_nil (); + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr +FT::Checkpointable_var::_retn (void) +{ + // yield ownership of managed obj reference + ::FT::Checkpointable_ptr val = this->ptr_; + this->ptr_ = ::FT::Checkpointable::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_CHECKPOINTABLE___OUT_CI_) +#define _FT_CHECKPOINTABLE___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::Checkpointable_out +// ************************************************************* + +ACE_INLINE +FT::Checkpointable_out::Checkpointable_out (Checkpointable_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::FT::Checkpointable::_nil (); +} + +ACE_INLINE +FT::Checkpointable_out::Checkpointable_out (Checkpointable_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Checkpointable::_nil (); +} + +ACE_INLINE +FT::Checkpointable_out::Checkpointable_out (const ::FT::Checkpointable_out &p) // copy constructor + : ptr_ (ACE_const_cast (Checkpointable_out &, p).ptr_) +{} + +ACE_INLINE ::FT::Checkpointable_out & +FT::Checkpointable_out::operator= (const ::FT::Checkpointable_out &p) +{ + this->ptr_ = ACE_const_cast (Checkpointable_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::Checkpointable_out & +FT::Checkpointable_out::operator= (const ::FT::Checkpointable_var &p) +{ + this->ptr_ = ::FT::Checkpointable::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::Checkpointable_out & +FT::Checkpointable_out::operator= (Checkpointable_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::Checkpointable_out::operator ::FT::Checkpointable_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr & +FT::Checkpointable_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Checkpointable_ptr +FT::Checkpointable_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +ACE_INLINE +FT::Updateable::Updateable (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor + : CORBA_Object (objref, _tao_servant, _tao_collocated) +{} + + +#if !defined (_FT_UPDATEABLE___VAR_CI_) +#define _FT_UPDATEABLE___VAR_CI_ + +// ************************************************************* +// Inline operations for class FT::Updateable_var +// ************************************************************* + +ACE_INLINE +FT::Updateable_var::Updateable_var (void) // default constructor + : ptr_ (Updateable::_nil ()) +{} + +ACE_INLINE +FT::Updateable_var::Updateable_var (Updateable_ptr p) + : ptr_ (p) +{} + +ACE_INLINE ::FT::Updateable_ptr +FT::Updateable_var::ptr (void) const +{ + return this->ptr_; +} + +ACE_INLINE +FT::Updateable_var::Updateable_var (const ::FT::Updateable_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (Updateable::_duplicate (p.ptr ())) +{} + +ACE_INLINE +FT::Updateable_var::~Updateable_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +ACE_INLINE FT::Updateable_var & +FT::Updateable_var::operator= (Updateable_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +ACE_INLINE FT::Updateable_var & +FT::Updateable_var::operator= (const ::FT::Updateable_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Updateable::_duplicate (p.ptr ()); + } + return *this; +} + +ACE_INLINE +FT::Updateable_var::operator const ::FT::Updateable_ptr &() const // cast +{ + return this->ptr_; +} + +ACE_INLINE +FT::Updateable_var::operator ::FT::Updateable_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr +FT::Updateable_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr +FT::Updateable_var::in (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr & +FT::Updateable_var::inout (void) +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr & +FT::Updateable_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Updateable::_nil (); + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr +FT::Updateable_var::_retn (void) +{ + // yield ownership of managed obj reference + ::FT::Updateable_ptr val = this->ptr_; + this->ptr_ = ::FT::Updateable::_nil (); + return val; +} + + +#endif /* end #if !defined */ + + +#if !defined (_FT_UPDATEABLE___OUT_CI_) +#define _FT_UPDATEABLE___OUT_CI_ + +// ************************************************************* +// Inline operations for class FT::Updateable_out +// ************************************************************* + +ACE_INLINE +FT::Updateable_out::Updateable_out (Updateable_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::FT::Updateable::_nil (); +} + +ACE_INLINE +FT::Updateable_out::Updateable_out (Updateable_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::FT::Updateable::_nil (); +} + +ACE_INLINE +FT::Updateable_out::Updateable_out (const ::FT::Updateable_out &p) // copy constructor + : ptr_ (ACE_const_cast (Updateable_out &, p).ptr_) +{} + +ACE_INLINE ::FT::Updateable_out & +FT::Updateable_out::operator= (const ::FT::Updateable_out &p) +{ + this->ptr_ = ACE_const_cast (Updateable_out&, p).ptr_; + return *this; +} + +ACE_INLINE FT::Updateable_out & +FT::Updateable_out::operator= (const ::FT::Updateable_var &p) +{ + this->ptr_ = ::FT::Updateable::_duplicate (p.ptr ()); + return *this; +} + +ACE_INLINE FT::Updateable_out & +FT::Updateable_out::operator= (Updateable_ptr p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +FT::Updateable_out::operator ::FT::Updateable_ptr &() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr & +FT::Updateable_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::FT::Updateable_ptr +FT::Updateable_out::operator-> (void) +{ + return this->ptr_; +} + + +#endif /* end #if !defined */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::TagFTGroupTaggedComponent &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.version) && + (strm << _tao_aggregate.ft_domain_id.in ()) && + (strm << _tao_aggregate.object_group_id) && + (strm << _tao_aggregate.object_group_ref_version) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::TagFTGroupTaggedComponent &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.version) && + (strm >> _tao_aggregate.ft_domain_id.out ()) && + (strm >> _tao_aggregate.object_group_id) && + (strm >> _tao_aggregate.object_group_ref_version) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::TagFTPrimaryTaggedComponent &_tao_aggregate) +{ + if ( + (strm << CORBA::Any::from_boolean (_tao_aggregate.primary)) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::TagFTPrimaryTaggedComponent &_tao_aggregate) +{ + if ( + (strm >> CORBA::Any::to_boolean (_tao_aggregate.primary)) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::FTGroupVersionServiceContext &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.object_group_ref_version) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::FTGroupVersionServiceContext &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.object_group_ref_version) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::FTRequestServiceContext &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.client_id.in ()) && + (strm << _tao_aggregate.retention_id) && + (strm << _tao_aggregate.expiration_time) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::FTRequestServiceContext &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.client_id.out ()) && + (strm >> _tao_aggregate.retention_id) && + (strm >> _tao_aggregate.expiration_time) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::RequestDurationPolicy_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::RequestDurationPolicy_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const FT::RequestDurationPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + FT::RequestDurationPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + FT::RequestDurationPolicy::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::TagFTHeartbeatEnabledTaggedComponent &_tao_aggregate) +{ + if ( + (strm << CORBA::Any::from_boolean (_tao_aggregate.heartbeat_enabled)) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::TagFTHeartbeatEnabledTaggedComponent &_tao_aggregate) +{ + if ( + (strm >> CORBA::Any::to_boolean (_tao_aggregate.heartbeat_enabled)) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::HeartbeatPolicyValue &_tao_aggregate) +{ + if ( + (strm << CORBA::Any::from_boolean (_tao_aggregate.heartbeat)) && + (strm << _tao_aggregate.heartbeat_interval) && + (strm << _tao_aggregate.heartbeat_timeout) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::HeartbeatPolicyValue &_tao_aggregate) +{ + if ( + (strm >> CORBA::Any::to_boolean (_tao_aggregate.heartbeat)) && + (strm >> _tao_aggregate.heartbeat_interval) && + (strm >> _tao_aggregate.heartbeat_timeout) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::HeartbeatPolicy_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::HeartbeatPolicy_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const FT::HeartbeatPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + FT::HeartbeatPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + FT::HeartbeatPolicy::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::HeartbeatEnabledPolicy_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::HeartbeatEnabledPolicy_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const FT::HeartbeatEnabledPolicy_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + FT::HeartbeatEnabledPolicy_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + FT::HeartbeatEnabledPolicy::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::GenericFactory_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::GenericFactory_ptr & + ); +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::FaultNotifier_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::FaultNotifier_ptr & + ); +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::FaultMonitoringIntervalAndTimeoutValue &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.monitoring_interval) && + (strm << _tao_aggregate.timeout) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, FT::FaultMonitoringIntervalAndTimeoutValue &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.monitoring_interval) && + (strm >> _tao_aggregate.timeout) + ) + return 1; + else + return 0; + +} + + +#if !defined _TAO_CDR_OP_FT_State_I_ +#define _TAO_CDR_OP_FT_State_I_ + +CORBA::Boolean TAO_Export operator<< ( + TAO_OutputCDR &, + const FT::State & + ); +CORBA::Boolean TAO_Export operator>> ( + TAO_InputCDR &, + FT::State & + ); + +#endif /* _TAO_CDR_OP_FT_State_I_ */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::NoStateAvailable &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + return 1; + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,FT::NoStateAvailable&) +{ + return 1; +} + +#if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +ACE_INLINE +ostream & operator<< (ostream &os, const FT::NoStateAvailable &_tao_aggregate) +{ + CORBA::TypeCode_ptr tc = _tao_aggregate._type (); + if (tc) + { + os << tc->name () << " ("; + } + os << _tao_aggregate._id (); + if (tc) + { + os << ")"; + } + return os; +} + +#endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::InvalidState &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + return 1; + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,FT::InvalidState&) +{ + return 1; +} + +#if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +ACE_INLINE +ostream & operator<< (ostream &os, const FT::InvalidState &_tao_aggregate) +{ + CORBA::TypeCode_ptr tc = _tao_aggregate._type (); + if (tc) + { + os << tc->name () << " ("; + } + os << _tao_aggregate._id (); + if (tc) + { + os << ")"; + } + return os; +} + +#endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::NoUpdateAvailable &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + return 1; + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,FT::NoUpdateAvailable&) +{ + return 1; +} + +#if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +ACE_INLINE +ostream & operator<< (ostream &os, const FT::NoUpdateAvailable &_tao_aggregate) +{ + CORBA::TypeCode_ptr tc = _tao_aggregate._type (); + if (tc) + { + os << tc->name () << " ("; + } + os << _tao_aggregate._id (); + if (tc) + { + os << ")"; + } + return os; +} + +#endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::InvalidUpdate &_tao_aggregate) +{ + // first marshal the repository ID + if (strm << _tao_aggregate._id ()) + return 1; + else + return 0; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &,FT::InvalidUpdate&) +{ + return 1; +} + +#if !defined (ACE_LACKS_IOSTREAM_TOTALLY) + +ACE_INLINE +ostream & operator<< (ostream &os, const FT::InvalidUpdate &_tao_aggregate) +{ + CORBA::TypeCode_ptr tc = _tao_aggregate._type (); + if (tc) + { + os << tc->name () << " ("; + } + os << _tao_aggregate._id (); + if (tc) + { + os << ")"; + } + return os; +} + +#endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::Checkpointable_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::Checkpointable_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const FT::Checkpointable_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + FT::Checkpointable_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + FT::Checkpointable::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &, + const FT::Updateable_ptr + ); +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &, + FT::Updateable_ptr & + ); + +ACE_INLINE CORBA::Boolean +operator<< ( + TAO_OutputCDR &strm, + const FT::Updateable_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +ACE_INLINE CORBA::Boolean +operator>> ( + TAO_InputCDR &strm, + FT::Updateable_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + FT::Updateable::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} + diff --git a/TAO/tao/GIOPC.h b/TAO/tao/GIOPC.h index 8003d004385..b9bf33ba682 100644 --- a/TAO/tao/GIOPC.h +++ b/TAO/tao/GIOPC.h @@ -77,6 +77,7 @@ TAO_NAMESPACE GIOP TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short ReferenceAddr; + struct IORAddressingInfo; class IORAddressingInfo_var; @@ -142,7 +143,7 @@ TAO_NAMESPACE GIOP class TargetAddress; class TargetAddress_var; - + class TAO_Export TargetAddress { public: @@ -237,6 +238,14 @@ private: void operator= (const TargetAddress_var &); }; +// We dont have the _var _out for this struct. If need arises we can +// add them later. For the present the Version struct alone should be +// sufficient +struct TAO_Export Version +{ + CORBA::Octet major; + CORBA::Octet minor; +}; } TAO_NAMESPACE_CLOSE // module GIOP diff --git a/TAO/tao/Profile.h b/TAO/tao/Profile.h index 59e0a13718e..31fa9b622b3 100644 --- a/TAO/tao/Profile.h +++ b/TAO/tao/Profile.h @@ -70,7 +70,7 @@ public: #if (TAO_HAS_FT_CORBA == 1) - CORBA::Boolean is_primary (void); + CORBA::Boolean is_primary (void) const; // Is this profile a primary? #endif /*TAO_HAS_FT_CORBA */ @@ -158,15 +158,15 @@ protected: TAO_Stub *stub_; // Pointer to the TAO_Stub to which this profile is related. - + CORBA::PolicyList *policy_list_; // Client exposed policies of this profile. - - // NOTE: In this implementation it is assumed that the + + // NOTE: In this implementation it is assumed that the // is exactly the same for each profile. // So to save memory, each TAO_Profile has a pointer to the same // PolicyList object. The life cycle of this object is managed - // by the TAO_MProfile class. + // by the TAO_MProfile class. private: diff --git a/TAO/tao/Stub.cpp b/TAO/tao/Stub.cpp index 647fb1b2c7b..72096fd4cbc 100644 --- a/TAO/tao/Stub.cpp +++ b/TAO/tao/Stub.cpp @@ -535,8 +535,8 @@ TAO_Stub::set_profile_from_primary (void) // For FT_CORBA we need to find the profile with FT_TAG_PRIMARY for (;;) { - TAO_Profile *profile = this->base_profile_.get_next (); - + TAO_Profile *profile = this->base_profiles_.get_next (); + if (profile) { if (profile->is_primary ()) @@ -547,7 +547,7 @@ TAO_Stub::set_profile_from_primary (void) // problem starts kicking in if the primary happens to be // the last profile in a combined IOGR, we may run out of // luck. So, we need a btter way to do this. But for the - // present let us start with this + // present let us start with this this->set_profile_in_use_i (profile); break; } @@ -560,22 +560,22 @@ TAO_Stub::set_profile_from_primary (void) // with TAO_HAS_FT_CORBA = 1, has received an IOR from a // non-compliant ORB. We cannot think this of an // error. Rather we need to fall back on the normal - // methodolody that we use. + // methodolody that we use. // So let us rewind our MProfile list and set the first one // as the starting point. - this->base_profile_.rewind (); - this->set_profile_in_use_i (base_profiles_.get_next ()); - + this->base_profiles_.rewind (); + this->set_profile_in_use_i (this->base_profiles_.get_next ()); + // @@ All said and done, what if we receive an IOGR from a - // FT-compliant ORB with no primaries? + // FT-compliant ORB with no primaries? // Ans: The above usage of the first profile in the list // as the start point would NOT be a mistake. We should // get a LOCATION_FORWARD or some such thing to get to // the primary. } } - + return; } diff --git a/TAO/tao/TAO.dsp b/TAO/tao/TAO.dsp index c78f14afab1..dbce783f05a 100644 --- a/TAO/tao/TAO.dsp +++ b/TAO/tao/TAO.dsp @@ -974,6 +974,25 @@ SOURCE=.\Forwarding_Servant.cpp # End Source File # Begin Source File +SOURCE=.\FT_CORBAC.cpp + +!IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" + +!ELSEIF "$(CFG)" == "TAO DLL - Win32 Alpha Debug" + +!ELSEIF "$(CFG)" == "TAO DLL - Win32 MFC Release" + +!ELSEIF "$(CFG)" == "TAO DLL - Win32 MFC Debug" + +!ELSEIF "$(CFG)" == "TAO DLL - Win32 Release" + +!ELSEIF "$(CFG)" == "TAO DLL - Win32 Debug" + +!ENDIF + +# End Source File +# Begin Source File + SOURCE=.\GIOP_Message_Accept_State.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2038,7 +2057,7 @@ SOURCE=.\POA.cpp # End Source File # Begin Source File -SOURCE=.\PortableServerC.cpp +SOURCE=.\POAManager.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2057,7 +2076,7 @@ SOURCE=.\PortableServerC.cpp # End Source File # Begin Source File -SOURCE=.\POAManager.cpp +SOURCE=.\Policy_Factory.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2076,7 +2095,7 @@ SOURCE=.\POAManager.cpp # End Source File # Begin Source File -SOURCE=.\Policy_Factory.cpp +SOURCE=.\Policy_Manager.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2095,7 +2114,7 @@ SOURCE=.\Policy_Factory.cpp # End Source File # Begin Source File -SOURCE=.\Policy_Manager.cpp +SOURCE=.\PolicyC.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2114,7 +2133,7 @@ SOURCE=.\Policy_Manager.cpp # End Source File # Begin Source File -SOURCE=.\PolicyC.cpp +SOURCE=.\PolicyS.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2133,7 +2152,7 @@ SOURCE=.\PolicyC.cpp # End Source File # Begin Source File -SOURCE=.\PolicyS.cpp +SOURCE=.\PollableC.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2152,7 +2171,7 @@ SOURCE=.\PolicyS.cpp # End Source File # Begin Source File -SOURCE=.\PollableC.cpp +SOURCE=.\PollableS.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2171,7 +2190,7 @@ SOURCE=.\PollableC.cpp # End Source File # Begin Source File -SOURCE=.\PollableS.cpp +SOURCE=.\Pool_Per_Endpoint.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -2190,7 +2209,7 @@ SOURCE=.\PollableS.cpp # End Source File # Begin Source File -SOURCE=.\Pool_Per_Endpoint.cpp +SOURCE=.\PortableServerC.cpp !IF "$(CFG)" == "TAO DLL - Win32 Alpha Release" @@ -3520,6 +3539,10 @@ SOURCE=.\Forwarding_Servant.h # End Source File # Begin Source File +SOURCE=.\FT_CORBAC.h +# End Source File +# Begin Source File + SOURCE=.\giop.h # End Source File # Begin Source File @@ -3724,10 +3747,6 @@ SOURCE=.\poa_macros.h # End Source File # Begin Source File -SOURCE=.\PortableServerC.h -# End Source File -# Begin Source File - SOURCE=.\POAManager.h # End Source File # Begin Source File @@ -3756,6 +3775,10 @@ SOURCE=.\Pool_Per_Endpoint.h # End Source File # Begin Source File +SOURCE=.\PortableServerC.h +# End Source File +# Begin Source File + SOURCE=.\Principal.h # End Source File # Begin Source File @@ -4092,6 +4115,10 @@ SOURCE=.\Exception.i # End Source File # Begin Source File +SOURCE=.\FT_CORBAC.i +# End Source File +# Begin Source File + SOURCE=.\giop.i # End Source File # Begin Source File @@ -4228,10 +4255,6 @@ SOURCE=.\params.i # End Source File # Begin Source File -SOURCE=.\PortableServerC.i -# End Source File -# Begin Source File - SOURCE=.\POAManager.i # End Source File # Begin Source File @@ -4256,6 +4279,10 @@ SOURCE=.\Pool_Per_Endpoint.i # End Source File # Begin Source File +SOURCE=.\PortableServerC.i +# End Source File +# Begin Source File + SOURCE=.\Priority_Mapping.i # End Source File # Begin Source File diff --git a/TAO/tao/Tagged_Components.h b/TAO/tao/Tagged_Components.h index 25c82f224fc..d9b542a7d63 100644 --- a/TAO/tao/Tagged_Components.h +++ b/TAO/tao/Tagged_Components.h @@ -25,6 +25,7 @@ #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "tao/CONV_FRAMEC.h" +#include "tao/FT_CORBAC.h" class TAO_Export TAO_Tagged_Components { @@ -108,9 +109,9 @@ public: # if (TAO_HAS_FT_CORBA == 1) - CORBA::Boolean is_primary (void); + CORBA::Boolean is_primary (void) const; // Does the profile represent an endpoint of a primary - + struct TAO_FT_Group_Tagged_Component { // = TITLE @@ -119,21 +120,21 @@ public: // = DESCRIPTION // Tagged components in the profile containing TAG_FT_GROUP - IOP::FTDomainID ft_domain_id_; + FT::FTDomainId ft_domain_id_; // Identifier of the FT domain - - IOP::ObjectGroupID object_group_id_; + + FT::ObjectGroupId object_group_id_; // The idetifier of the Object Group - - IOP::ObjectGroupRefVersion object_group_ref_version_; + + FT::ObjectGroupRefVersion object_group_ref_version_; // The version number of the Object Group Reference }; - + TAO_Tagged_Components::TAO_FT_Group_Tagged_Component & ft_group_tagged_component (void); - + const TAO_Tagged_Components::TAO_FT_Group_Tagged_Component & - ft_group_tagged_component (void); + ft_group_tagged_component (void) const; #endif /*TAO_HAS_FT_CORBA */ private: @@ -178,7 +179,7 @@ private: CORBA::Boolean ft_tag_primary_; // Flag that indicates whether the profile is from a PRIMARY - TAO_FT_Tagged_Component ft_tagged_component_; + TAO_FT_Group_Tagged_Component ft_tagged_component_; // Tagged components in TAG_FT_GROUP #endif /*TAO_HAS_FT_CORBA */ diff --git a/TAO/tao/Tagged_Components.i b/TAO/tao/Tagged_Components.i index 6b36927ffe8..295c4e0eb01 100644 --- a/TAO/tao/Tagged_Components.i +++ b/TAO/tao/Tagged_Components.i @@ -87,8 +87,10 @@ TAO_Tagged_Components::components (void) return this->components_; } -ACE_INLINE CORBA::Boolean -TAO_Tagged_Components::is_primary (void) +#if (TAO_HAS_FT_CORBA == 1) + +ACE_INLINE CORBA::Boolean +TAO_Tagged_Components::is_primary (void) const { return this->ft_tag_primary_; } @@ -104,3 +106,5 @@ TAO_Tagged_Components::ft_group_tagged_component (void) { return this->ft_tagged_component_; } + +#endif /*TAO_HAS_FT_CORBA */ -- cgit v1.2.1