/* -*- 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
// *************************************************************

#if (TAO_HAS_FT_CORBA == 1)
ACE_INLINE
FT_TagFTGroupTaggedComponent_var::FT_TagFTGroupTaggedComponent_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_TagFTGroupTaggedComponent_var::FT_TagFTGroupTaggedComponent_var (FT_TagFTGroupTaggedComponent *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_TagFTGroupTaggedComponent_var::FT_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::~FT_TagFTGroupTaggedComponent_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_TagFTGroupTaggedComponent_var &
FT_TagFTGroupTaggedComponent_var::operator= (FT_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::FT_TagFTGroupTaggedComponent_out (::FT_TagFTGroupTaggedComponent *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
FT_TagFTGroupTaggedComponent_out::FT_TagFTGroupTaggedComponent_out (FT_TagFTGroupTaggedComponent_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
FT_TagFTGroupTaggedComponent_out::FT_TagFTGroupTaggedComponent_out (const ::FT::TagFTGroupTaggedComponent_out &p) // copy constructor
  : ptr_ (ACE_const_cast (FT_TagFTGroupTaggedComponent_out&, p).ptr_)
{}

ACE_INLINE FT_TagFTGroupTaggedComponent_out &
FT_TagFTGroupTaggedComponent_out::operator= (const ::FT::TagFTGroupTaggedComponent_out &p)
{
  this->ptr_ = ACE_const_cast (FT_TagFTGroupTaggedComponent_out&, p).ptr_;
  return *this;
}

ACE_INLINE FT_TagFTGroupTaggedComponent_out &
FT_TagFTGroupTaggedComponent_out::operator= (FT_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::FT_TagFTPrimaryTaggedComponent_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_TagFTPrimaryTaggedComponent_var::FT_TagFTPrimaryTaggedComponent_var (FT_TagFTPrimaryTaggedComponent *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_TagFTPrimaryTaggedComponent_var::FT_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::FT_TagFTPrimaryTaggedComponent_var (const ::FT_TagFTPrimaryTaggedComponent &p)
{
  ACE_NEW (this->ptr_, ::FT_TagFTPrimaryTaggedComponent (p));
}

ACE_INLINE
FT_TagFTPrimaryTaggedComponent_var::~FT_TagFTPrimaryTaggedComponent_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_TagFTPrimaryTaggedComponent_var &
FT_TagFTPrimaryTaggedComponent_var::operator= (FT_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::FT_FTGroupVersionServiceContext_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_FTGroupVersionServiceContext_var::FT_FTGroupVersionServiceContext_var (FT_FTGroupVersionServiceContext *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_FTGroupVersionServiceContext_var::FT_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::FT_FTGroupVersionServiceContext_var (const ::FT_FTGroupVersionServiceContext &p)
{
  ACE_NEW (this->ptr_, ::FT_FTGroupVersionServiceContext (p));
}

ACE_INLINE
FT_FTGroupVersionServiceContext_var::~FT_FTGroupVersionServiceContext_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_FTGroupVersionServiceContext_var &
FT_FTGroupVersionServiceContext_var::operator= (FT_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::FT_FTRequestServiceContext_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_FTRequestServiceContext_var::FT_FTRequestServiceContext_var (FT_FTRequestServiceContext *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_FTRequestServiceContext_var::FT_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::~FT_FTRequestServiceContext_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_FTRequestServiceContext_var &
FT_FTRequestServiceContext_var::operator= (FT_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::FT_FTRequestServiceContext_out (::FT_FTRequestServiceContext *&p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

ACE_INLINE
FT_FTRequestServiceContext_out::FT_FTRequestServiceContext_out (FT_FTRequestServiceContext_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  delete this->ptr_;
  this->ptr_ = 0;
}

ACE_INLINE
FT_FTRequestServiceContext_out::FT_FTRequestServiceContext_out (const ::FT_FTRequestServiceContext_out &p) // copy constructor
  : ptr_ (ACE_const_cast (FT_FTRequestServiceContext_out&, p).ptr_)
{}

ACE_INLINE FT_FTRequestServiceContext_out &
FT_FTRequestServiceContext_out::operator= (const ::FT_FTRequestServiceContext_out &p)
{
  this->ptr_ = ACE_const_cast (FT_FTRequestServiceContext_out&, p).ptr_;
  return *this;
}

ACE_INLINE FT_FTRequestServiceContext_out &
FT_FTRequestServiceContext_out::operator= (FT_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::FT_RequestDurationPolicy (TAO_Stub *objref, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_collocated)
{}


// *************************************************************
// Inline operations for class FT_RequestDurationPolicy_var
// *************************************************************

ACE_INLINE
FT_RequestDurationPolicy_var::FT_RequestDurationPolicy_var (void) // default constructor
  : ptr_ (FT_RequestDurationPolicy::_nil ())
{}

ACE_INLINE ::FT_RequestDurationPolicy_ptr
FT_RequestDurationPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
FT_RequestDurationPolicy_var::FT_RequestDurationPolicy_var (const ::FT_RequestDurationPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (FT_RequestDurationPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
FT_RequestDurationPolicy_var::~FT_RequestDurationPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE FT_RequestDurationPolicy_var &
FT_RequestDurationPolicy_var::operator= (FT_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;
}


// *************************************************************
// Inline operations for class FT_RequestDurationPolicy_out
// *************************************************************

ACE_INLINE
FT_RequestDurationPolicy_out::FT_RequestDurationPolicy_out (FT_RequestDurationPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::FT_RequestDurationPolicy::_nil ();
}

ACE_INLINE
FT_RequestDurationPolicy_out::FT_RequestDurationPolicy_out (FT_RequestDurationPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::FT_RequestDurationPolicy::_nil ();
}

ACE_INLINE
FT_RequestDurationPolicy_out::FT_RequestDurationPolicy_out (const ::FT_RequestDurationPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (FT_RequestDurationPolicy_out &, p).ptr_)
{}

ACE_INLINE ::FT_RequestDurationPolicy_out &
FT_RequestDurationPolicy_out::operator= (const ::FT_RequestDurationPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (FT_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= (FT_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_;
}

// *************************************************************
// Inline operations for class FT_TagFTHeartbeatEnabledTaggedComponent_var
// *************************************************************

ACE_INLINE
FT_TagFTHeartbeatEnabledTaggedComponent_var::FT_TagFTHeartbeatEnabledTaggedComponent_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_TagFTHeartbeatEnabledTaggedComponent_var::FT_TagFTHeartbeatEnabledTaggedComponent_var (FT_TagFTHeartbeatEnabledTaggedComponent *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_TagFTHeartbeatEnabledTaggedComponent_var::FT_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::FT_TagFTHeartbeatEnabledTaggedComponent_var (const ::FT_TagFTHeartbeatEnabledTaggedComponent &p)
{
  ACE_NEW (this->ptr_, ::FT_TagFTHeartbeatEnabledTaggedComponent (p));
}

ACE_INLINE
FT_TagFTHeartbeatEnabledTaggedComponent_var::~FT_TagFTHeartbeatEnabledTaggedComponent_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_TagFTHeartbeatEnabledTaggedComponent_var &
FT_TagFTHeartbeatEnabledTaggedComponent_var::operator= (FT_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::FT_HeartbeatPolicyValue_var (void) // default constructor
  : ptr_ (0)
{}

ACE_INLINE
FT_HeartbeatPolicyValue_var::FT_HeartbeatPolicyValue_var (FT_HeartbeatPolicyValue *p)
  : ptr_ (p)
{}

ACE_INLINE
FT_HeartbeatPolicyValue_var::FT_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::FT_HeartbeatPolicyValue_var (const ::FT_HeartbeatPolicyValue &p)
{
  ACE_NEW (this->ptr_, ::FT_HeartbeatPolicyValue (p));
}

ACE_INLINE
FT_HeartbeatPolicyValue_var::~FT_HeartbeatPolicyValue_var (void) // destructor
{
  delete this->ptr_;
}

ACE_INLINE FT_HeartbeatPolicyValue_var &
FT_HeartbeatPolicyValue_var::operator= (FT_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::FT_HeartbeatPolicy (TAO_Stub *objref, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_collocated)
{}


// *************************************************************
// Inline operations for class FT_HeartbeatPolicy_var
// *************************************************************

ACE_INLINE
FT_HeartbeatPolicy_var::FT_HeartbeatPolicy_var (void) // default constructor
  : ptr_ (FT_HeartbeatPolicy::_nil ())
{}

ACE_INLINE ::FT_HeartbeatPolicy_ptr
FT_HeartbeatPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
FT_HeartbeatPolicy_var::FT_HeartbeatPolicy_var (const ::FT_HeartbeatPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (FT_HeartbeatPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
FT_HeartbeatPolicy_var::~FT_HeartbeatPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE FT_HeartbeatPolicy_var &
FT_HeartbeatPolicy_var::operator= (FT_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;
}


// *************************************************************
// Inline operations for class FT_HeartbeatPolicy_out
// *************************************************************

ACE_INLINE
FT_HeartbeatPolicy_out::FT_HeartbeatPolicy_out (FT_HeartbeatPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::FT_HeartbeatPolicy::_nil ();
}

ACE_INLINE
FT_HeartbeatPolicy_out::FT_HeartbeatPolicy_out (FT_HeartbeatPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::FT_HeartbeatPolicy::_nil ();
}

ACE_INLINE
FT_HeartbeatPolicy_out::FT_HeartbeatPolicy_out (const ::FT_HeartbeatPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (FT_HeartbeatPolicy_out &, p).ptr_)
{}

ACE_INLINE ::FT_HeartbeatPolicy_out &
FT_HeartbeatPolicy_out::operator= (const ::FT_HeartbeatPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (FT_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= (FT_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_;
}


ACE_INLINE
FT_HeartbeatEnabledPolicy::FT_HeartbeatEnabledPolicy (TAO_Stub *objref, CORBA::Boolean _tao_collocated) // constructor
  : CORBA_Object (objref, _tao_collocated)
{}


// *************************************************************
// Inline operations for class FT_HeartbeatEnabledPolicy_var
// *************************************************************

ACE_INLINE
FT_HeartbeatEnabledPolicy_var::FT_HeartbeatEnabledPolicy_var (void) // default constructor
  : ptr_ (FT_HeartbeatEnabledPolicy::_nil ())
{}

ACE_INLINE ::FT_HeartbeatEnabledPolicy_ptr
FT_HeartbeatEnabledPolicy_var::ptr (void) const
{
  return this->ptr_;
}

ACE_INLINE
FT_HeartbeatEnabledPolicy_var::FT_HeartbeatEnabledPolicy_var (const ::FT_HeartbeatEnabledPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (FT_HeartbeatEnabledPolicy::_duplicate (p.ptr ()))
{}

ACE_INLINE
FT_HeartbeatEnabledPolicy_var::~FT_HeartbeatEnabledPolicy_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

ACE_INLINE FT_HeartbeatEnabledPolicy_var &
FT_HeartbeatEnabledPolicy_var::operator= (FT_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;
}



// *************************************************************
// Inline operations for class FT_HeartbeatEnabledPolicy_out
// *************************************************************

ACE_INLINE
FT_HeartbeatEnabledPolicy_out::FT_HeartbeatEnabledPolicy_out (FT_HeartbeatEnabledPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::FT_HeartbeatEnabledPolicy::_nil ();
}

ACE_INLINE
FT_HeartbeatEnabledPolicy_out::FT_HeartbeatEnabledPolicy_out (FT_HeartbeatEnabledPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::FT_HeartbeatEnabledPolicy::_nil ();
}

ACE_INLINE
FT_HeartbeatEnabledPolicy_out::FT_HeartbeatEnabledPolicy_out (const ::FT_HeartbeatEnabledPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (FT_HeartbeatEnabledPolicy_out &, p).ptr_)
{}

ACE_INLINE ::FT_HeartbeatEnabledPolicy_out &
FT_HeartbeatEnabledPolicy_out::operator= (const ::FT_HeartbeatEnabledPolicy_out &p)
{
  this->ptr_ = ACE_const_cast (FT_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= (FT_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_;
}

//***************************************************
// Insertion and extraction operators
//***************************************************
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;
}


#endif /*TAO_HAS_FT_CORBA == 1*/