*** empty log message ***

9 files changed, 8757 insertions, 45 deletions

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<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#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<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#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<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<CORBA::Octet>
+#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<FT::RequestDurationPolicy,FT::RequestDurationPolicy_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<FT::RequestDurationPolicy,FT::RequestDurationPolicy_var>
+#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<FT::HeartbeatPolicy,FT::HeartbeatPolicy_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<FT::HeartbeatPolicy,FT::HeartbeatPolicy_var>
+#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<FT::HeartbeatEnabledPolicy,FT::HeartbeatEnabledPolicy_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<FT::HeartbeatEnabledPolicy,FT::HeartbeatEnabledPolicy_var>
+#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<FT::Checkpointable,FT::Checkpointable_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<FT::Checkpointable,FT::Checkpointable_var>
+#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<FT::Updateable,FT::Updateable_var>;
+  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+  #  pragma instantiate TAO_Object_Manager<FT::Updateable,FT::Updateable_var>
+#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<CORBA::Octet> *oseq = 
+        ACE_static_cast (TAO_Unbounded_Sequence<CORBA::Octet>*, (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<CORBA::Octet> *oseq = 
+        ACE_static_cast(TAO_Unbounded_Sequence<CORBA::Octet>*, &_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<CORBA::Octet>
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<CORBA::Octet>
+#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<CORBA::Octet> (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 <policy_list> 
+
+  // NOTE: In this implementation it is assumed that the <policy_list>
   // 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 */