*** empty log message ***

4 files changed, 681 insertions, 21 deletions

diff --git a/TAO/tao/FT_CORBAC.cpp b/TAO/tao/FT_CORBAC.cpp
index f56877afe7c..505aebced40 100644
--- a/TAO/tao/FT_CORBAC.cpp
+++ b/TAO/tao/FT_CORBAC.cpp
@@ -1183,4 +1183,676 @@ static const CORBA::Long _oc_FT_Property[] =
 
 };
 
+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 */
+
 #endif /*TAO_HAS_FT_CORBA == 1 */
diff --git a/TAO/tao/FT_CORBAC.i b/TAO/tao/FT_CORBAC.i
index 6da5ea338cb..921500071fa 100644
--- a/TAO/tao/FT_CORBAC.i
+++ b/TAO/tao/FT_CORBAC.i
@@ -1365,6 +1365,9 @@ FT_HeartbeatEnabledPolicy_out::operator-> (void)
   return this->ptr_;
 }
 
+//***************************************************
+// Insertion and extraction operators
+//***************************************************
 ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const FT::TagFTGroupTaggedComponent &_tao_aggregate)
 {
   if (
diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile
index 4167ce8f126..21d36693b71 100644
--- a/TAO/tao/Makefile
+++ b/TAO/tao/Makefile
@@ -206,7 +206,8 @@ ORB_CORE_FILES = \
   BoundsC \
   TAOC \
   TAOS \
-  Object_Loader
+  Object_Loader \
+  FT_CORBAC
 
 DYNAMIC_ANY_FILES =
 
diff --git a/TAO/tao/ftcorbafwd.h b/TAO/tao/ftcorbafwd.h
index 5ed97f1b0c2..784b3185b70 100644
--- a/TAO/tao/ftcorbafwd.h
+++ b/TAO/tao/ftcorbafwd.h
@@ -73,6 +73,8 @@ struct FT_HeartbeatPolicyValue;
 class  FT_HeartbeatPolicyValue_var;
 
 
+class FT_Name;
+
 class   FT_HeartbeatPolicy;
 class   FT_HeartbeatPolicy_var;
 class   FT_HeartbeatPolicy_out;
@@ -93,10 +95,6 @@ class FT_FaultNotifier_var;
 class FT_FaultNotifier_out;
 typedef FT_FaultNotifier *FT_FaultNotifier_ptr;
 
-class FT_Name;
-class FT_Name_var;
-class FT_Name_out;
-
 struct FT_Property;
 class  FT_Property_var;
 class  FT_Property_out;
@@ -105,10 +103,6 @@ class FT_Properties;
 class FT_Properties_var;
 class FT_Properties_out;
 
-class FT_Location;
-class FT_Location_var;
-class FT_Location_out;
-
 class FT_Locations;
 class FT_Locations_var;
 class FT_Locations_out;
@@ -266,6 +260,8 @@ TAO_NAMESPACE FT
   typedef FT_FaultNotifier_out FaultNotifier_out;
   typedef FaultNotifier *FaultNotifier_ptr;
 
+  typedef FT_Name Name;
+
   typedef char * TypeId;
   typedef CORBA::String_var TypeId_var;
   typedef CORBA::String_out TypeId_out;
@@ -277,10 +273,6 @@ TAO_NAMESPACE FT
   typedef CORBA::Object_out ObjectGroup_out;
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ObjectGroup;
 
-  typedef FT_Name Name;
-  typedef FT_Name_var Name_var;
-  typedef FT_Name_out Name_out;
-
   typedef CORBA::Any Value;
   typedef CORBA::Any_ptr Value_ptr;
   typedef CORBA::Any_var Value_var;
@@ -297,14 +289,6 @@ TAO_NAMESPACE FT
   typedef FT_Properties_out Properties_out;
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Properties;
 
-  //  typedef Name Location;
-  //typedef Name_var Location_var;
-  //typedef Name_out Location_out;
-  typedef FT_Location Location;
-  typedef FT_Location_var Location_var;
-  typedef FT_Location_out Location_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Location;
-
   typedef FT_Locations Locations;
   typedef FT_Locations_var Locations_var;
   typedef FT_Locations_out Locations_out;