path: root/TAO/tao/FT_CORBAC.h

/* -*- 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 "ace/pre.h"
#include "tao/ftcorbafwd.h"
#include "tao/GIOPC.h"
#include "tao/Managed_Types.h"
#include "tao/PolicyC.h"

#if (TAO_HAS_FT_CORBA == 1)

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

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

struct TAO_Export FT_TagFTGroupTaggedComponent
{

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_TagFTGroupTaggedComponent_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  static void _tao_any_destructor (void*);

  GIOP::Version version;
  TAO_String_Manager ft_domain_id;
  FT::ObjectGroupId object_group_id;
  FT::ObjectGroupRefVersion object_group_ref_version;
};

class TAO_Export FT_TagFTGroupTaggedComponent_var
{
public:
  FT_TagFTGroupTaggedComponent_var (void);
  // default constructor
  FT_TagFTGroupTaggedComponent_var (FT_TagFTGroupTaggedComponent *);
  FT_TagFTGroupTaggedComponent_var (const FT_TagFTGroupTaggedComponent_var &);
  // copy constructor
  ~FT_TagFTGroupTaggedComponent_var (void);
  // destructor
  FT_TagFTGroupTaggedComponent_var &operator= (FT_TagFTGroupTaggedComponent *);
  FT_TagFTGroupTaggedComponent_var &operator= (const FT_TagFTGroupTaggedComponent_var &);
  FT_TagFTGroupTaggedComponent *operator-> (void);
  const FT_TagFTGroupTaggedComponent *operator-> (void) const;

  operator const FT_TagFTGroupTaggedComponent &() const;
  operator FT_TagFTGroupTaggedComponent &();
  operator FT_TagFTGroupTaggedComponent &() const;
  operator FT_TagFTGroupTaggedComponent *&();
  // variable-size types only

  // in, inout, out, _retn
  const FT_TagFTGroupTaggedComponent &in (void) const;
  FT_TagFTGroupTaggedComponent &inout (void);
  FT_TagFTGroupTaggedComponent *&out (void);
  FT_TagFTGroupTaggedComponent *_retn (void);
  FT_TagFTGroupTaggedComponent *ptr (void) const;

private:
  FT_TagFTGroupTaggedComponent *ptr_;
};


class TAO_Export FT_TagFTGroupTaggedComponent_out
{
public:
  FT_TagFTGroupTaggedComponent_out (FT_TagFTGroupTaggedComponent *&);
  FT_TagFTGroupTaggedComponent_out (FT_TagFTGroupTaggedComponent_var &);
  FT_TagFTGroupTaggedComponent_out (const FT_TagFTGroupTaggedComponent_out &);
  FT_TagFTGroupTaggedComponent_out &operator= (const FT_TagFTGroupTaggedComponent_out &);
  FT_TagFTGroupTaggedComponent_out &operator= (FT_TagFTGroupTaggedComponent *);
  operator FT_TagFTGroupTaggedComponent *&();
  FT_TagFTGroupTaggedComponent *&ptr (void);
  FT_TagFTGroupTaggedComponent *operator-> (void);

private:
  FT_TagFTGroupTaggedComponent *&ptr_;
  // assignment from T_var not allowed
  void operator= (const FT_TagFTGroupTaggedComponent_var &);
};



struct TAO_Export FT_TagFTPrimaryTaggedComponent
{

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_TagFTPrimaryTaggedComponent_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  static void _tao_any_destructor (void*);

    CORBA::Boolean primary;
};

class TAO_Export FT_TagFTPrimaryTaggedComponent_var
{
public:
  FT_TagFTPrimaryTaggedComponent_var (void);
  // default constructor
  FT_TagFTPrimaryTaggedComponent_var (FT_TagFTPrimaryTaggedComponent *);
  FT_TagFTPrimaryTaggedComponent_var (const FT_TagFTPrimaryTaggedComponent_var &);
  // copy constructor
  FT_TagFTPrimaryTaggedComponent_var (const FT_TagFTPrimaryTaggedComponent &);
  // fixed-size types only
  ~FT_TagFTPrimaryTaggedComponent_var (void);
  // destructor

  FT_TagFTPrimaryTaggedComponent_var &operator= (FT_TagFTPrimaryTaggedComponent *);
  FT_TagFTPrimaryTaggedComponent_var &operator= (const FT_TagFTPrimaryTaggedComponent_var &);
  FT_TagFTPrimaryTaggedComponent_var &operator= (const FT_TagFTPrimaryTaggedComponent &);
  // fixed-size types only
  FT_TagFTPrimaryTaggedComponent *operator-> (void);
  const FT_TagFTPrimaryTaggedComponent *operator-> (void) const;

  operator const FT_TagFTPrimaryTaggedComponent &() const;
  operator FT_TagFTPrimaryTaggedComponent &();
  operator FT_TagFTPrimaryTaggedComponent &() const;

  // in, inout, out, _retn
  const FT_TagFTPrimaryTaggedComponent &in (void) const;
  FT_TagFTPrimaryTaggedComponent &inout (void);
  FT_TagFTPrimaryTaggedComponent &out (void);
  FT_TagFTPrimaryTaggedComponent _retn (void);
  FT_TagFTPrimaryTaggedComponent *ptr (void) const;

  private:
  FT_TagFTPrimaryTaggedComponent *ptr_;
};

typedef FT_TagFTPrimaryTaggedComponent &FT_TagFTPrimaryTaggedComponent_out;

struct TAO_Export FT_FTGroupVersionServiceContext
{

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_FTGroupVersionServiceContext_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  static void _tao_any_destructor (void*);
  FT::ObjectGroupRefVersion object_group_ref_version;
};

class TAO_Export FT_FTGroupVersionServiceContext_var
{
public:
  FT_FTGroupVersionServiceContext_var (void); // default constructor
  FT_FTGroupVersionServiceContext_var (FT_FTGroupVersionServiceContext *);
  FT_FTGroupVersionServiceContext_var (const FT_FTGroupVersionServiceContext_var &); // copy constructor
  FT_FTGroupVersionServiceContext_var (const FT_FTGroupVersionServiceContext &); // fixed-size types only
  ~FT_FTGroupVersionServiceContext_var (void); // destructor

  FT_FTGroupVersionServiceContext_var &operator= (FT_FTGroupVersionServiceContext *);
  FT_FTGroupVersionServiceContext_var &operator= (const FT_FTGroupVersionServiceContext_var &);
  FT_FTGroupVersionServiceContext_var &operator= (const FT_FTGroupVersionServiceContext &); // fixed-size types only
  FT_FTGroupVersionServiceContext *operator-> (void);
  const FT_FTGroupVersionServiceContext *operator-> (void) const;

  operator const FT_FTGroupVersionServiceContext &() const;
  operator FT_FTGroupVersionServiceContext &();
  operator FT_FTGroupVersionServiceContext &() const;

  // in, inout, out, _retn
  const FT_FTGroupVersionServiceContext &in (void) const;
  FT_FTGroupVersionServiceContext &inout (void);
  FT_FTGroupVersionServiceContext &out (void);
  FT_FTGroupVersionServiceContext _retn (void);
  FT_FTGroupVersionServiceContext *ptr (void) const;

private:
  FT_FTGroupVersionServiceContext *ptr_;
};

typedef FT_FTGroupVersionServiceContext &FT_FTGroupVersionServiceContext_out;

struct TAO_Export FT_FTRequestServiceContext
{
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_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 FT_FTRequestServiceContext_var
{
public:
  FT_FTRequestServiceContext_var (void);   // default constructor
  FT_FTRequestServiceContext_var (FT_FTRequestServiceContext *);
  FT_FTRequestServiceContext_var (const FT_FTRequestServiceContext_var &); // copy constructor
  ~FT_FTRequestServiceContext_var (void); // destructor

  FT_FTRequestServiceContext_var &operator= (FT_FTRequestServiceContext *);
  FT_FTRequestServiceContext_var &operator= (const FT_FTRequestServiceContext_var &);
  FT_FTRequestServiceContext *operator-> (void);
  const FT_FTRequestServiceContext *operator-> (void) const;

  operator const FT_FTRequestServiceContext &() const;
  operator FT_FTRequestServiceContext &();
  operator FT_FTRequestServiceContext &() const;
  operator FT_FTRequestServiceContext *&(); // variable-size types only

  // in, inout, out, _retn
  const FT_FTRequestServiceContext &in (void) const;
  FT_FTRequestServiceContext &inout (void);
  FT_FTRequestServiceContext *&out (void);
  FT_FTRequestServiceContext *_retn (void);
  FT_FTRequestServiceContext *ptr (void) const;

private:
  FT_FTRequestServiceContext *ptr_;
};

class TAO_Export FT_FTRequestServiceContext_out
{
public:
  FT_FTRequestServiceContext_out (FT_FTRequestServiceContext *&);
  FT_FTRequestServiceContext_out (FT_FTRequestServiceContext_var &);
  FT_FTRequestServiceContext_out (const FT_FTRequestServiceContext_out &);
  FT_FTRequestServiceContext_out &operator= (const FT_FTRequestServiceContext_out &);
  FT_FTRequestServiceContext_out &operator= (FT_FTRequestServiceContext *);
  operator FT_FTRequestServiceContext *&();
  FT_FTRequestServiceContext *&ptr (void);
  FT_FTRequestServiceContext *operator-> (void);

private:
  FT_FTRequestServiceContext *&ptr_;
  // assignment from T_var not allowed
  void operator= (const FT_FTRequestServiceContext_var &);
};


class TAO_Export FT_RequestDurationPolicy_var : public TAO_Base_var
{
public:
  FT_RequestDurationPolicy_var (void); // default constructor
  FT_RequestDurationPolicy_var (FT_RequestDurationPolicy_ptr p) : ptr_ (p) {}
  FT_RequestDurationPolicy_var (const FT_RequestDurationPolicy_var &); // copy constructor
  ~FT_RequestDurationPolicy_var (void); // destructor

  FT_RequestDurationPolicy_var &operator= (FT_RequestDurationPolicy_ptr);
  FT_RequestDurationPolicy_var &operator= (const FT_RequestDurationPolicy_var &);
  FT_RequestDurationPolicy_ptr operator-> (void) const;

  operator const FT_RequestDurationPolicy_ptr &() const;
  operator FT_RequestDurationPolicy_ptr &();
  // in, inout, out, _retn
  FT_RequestDurationPolicy_ptr in (void) const;
  FT_RequestDurationPolicy_ptr &inout (void);
  FT_RequestDurationPolicy_ptr &out (void);
  FT_RequestDurationPolicy_ptr _retn (void);
  FT_RequestDurationPolicy_ptr ptr (void) const;

private:
  FT_RequestDurationPolicy_ptr ptr_;
  // Unimplemented - prevents widening assignment.
  FT_RequestDurationPolicy_var (const TAO_Base_var &rhs);
  FT_RequestDurationPolicy_var &operator= (const TAO_Base_var &rhs);
};


//#endif /* end #if !defined */


class TAO_Export FT_RequestDurationPolicy_out
{
public:
  FT_RequestDurationPolicy_out (FT_RequestDurationPolicy_ptr &);
  FT_RequestDurationPolicy_out (FT_RequestDurationPolicy_var &);
  FT_RequestDurationPolicy_out (const FT_RequestDurationPolicy_out &);
  FT_RequestDurationPolicy_out &operator= (const FT_RequestDurationPolicy_out &);
  FT_RequestDurationPolicy_out &operator= (const FT_RequestDurationPolicy_var &);
  FT_RequestDurationPolicy_out &operator= (FT_RequestDurationPolicy_ptr);
  operator FT_RequestDurationPolicy_ptr &();
  FT_RequestDurationPolicy_ptr &ptr (void);
  FT_RequestDurationPolicy_ptr operator-> (void);

private:
  FT_RequestDurationPolicy_ptr &ptr_;
};


class TAO_Export FT_RequestDurationPolicy: public virtual CORBA::Policy
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_RequestDurationPolicy_ptr _ptr_type;
  typedef FT_RequestDurationPolicy_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static FT_RequestDurationPolicy_ptr _duplicate (FT_RequestDurationPolicy_ptr obj);
  static FT_RequestDurationPolicy_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
      TAO_default_environment ()
    );
  static FT_RequestDurationPolicy_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
      TAO_default_environment ()
    );
  static FT_RequestDurationPolicy_ptr _nil (void)
    {
      return (FT_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:
  FT_RequestDurationPolicy (void);
  FT_RequestDurationPolicy (TAO_Stub *objref,
      CORBA::Boolean _tao_collocated = 0
    );
  virtual ~FT_RequestDurationPolicy (void);
private:
  FT_RequestDurationPolicy (const FT_RequestDurationPolicy &);
  void operator= (const FT_RequestDurationPolicy &);
};


struct TAO_Export FT_TagFTHeartbeatEnabledTaggedComponent
{

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_TagFTHeartbeatEnabledTaggedComponent_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  static void _tao_any_destructor (void*);

  CORBA::Boolean heartbeat_enabled;
};

class TAO_Export FT_TagFTHeartbeatEnabledTaggedComponent_var
{
public:
  FT_TagFTHeartbeatEnabledTaggedComponent_var (void); // default constructor
  FT_TagFTHeartbeatEnabledTaggedComponent_var (FT_TagFTHeartbeatEnabledTaggedComponent *);
  FT_TagFTHeartbeatEnabledTaggedComponent_var (const FT_TagFTHeartbeatEnabledTaggedComponent_var &); // copy constructor
  FT_TagFTHeartbeatEnabledTaggedComponent_var (const FT_TagFTHeartbeatEnabledTaggedComponent &); // fixed-size types only
  ~FT_TagFTHeartbeatEnabledTaggedComponent_var (void); // destructor

  FT_TagFTHeartbeatEnabledTaggedComponent_var &operator= (FT_TagFTHeartbeatEnabledTaggedComponent *);
  FT_TagFTHeartbeatEnabledTaggedComponent_var &operator= (const FT_TagFTHeartbeatEnabledTaggedComponent_var &);
  FT_TagFTHeartbeatEnabledTaggedComponent_var &operator= (const FT_TagFTHeartbeatEnabledTaggedComponent &); // fixed-size types only
  FT_TagFTHeartbeatEnabledTaggedComponent *operator-> (void);
  const FT_TagFTHeartbeatEnabledTaggedComponent *operator-> (void) const;

  operator const FT_TagFTHeartbeatEnabledTaggedComponent &() const;
  operator FT_TagFTHeartbeatEnabledTaggedComponent &();
  operator FT_TagFTHeartbeatEnabledTaggedComponent &() const;

  // in, inout, out, _retn
  const FT_TagFTHeartbeatEnabledTaggedComponent &in (void) const;
  FT_TagFTHeartbeatEnabledTaggedComponent &inout (void);
  FT_TagFTHeartbeatEnabledTaggedComponent &out (void);
  FT_TagFTHeartbeatEnabledTaggedComponent _retn (void);
  FT_TagFTHeartbeatEnabledTaggedComponent *ptr (void) const;

private:
  FT_TagFTHeartbeatEnabledTaggedComponent *ptr_;
};

typedef FT_TagFTHeartbeatEnabledTaggedComponent &FT_TagFTHeartbeatEnabledTaggedComponent_out;

struct TAO_Export FT_HeartbeatPolicyValue
{

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_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 FT_HeartbeatPolicyValue_var
{
public:
  FT_HeartbeatPolicyValue_var (void); // default constructor
  FT_HeartbeatPolicyValue_var (FT_HeartbeatPolicyValue *);
  FT_HeartbeatPolicyValue_var (const FT_HeartbeatPolicyValue_var &); // copy constructor
  FT_HeartbeatPolicyValue_var (const FT_HeartbeatPolicyValue &); // fixed-size types only
  ~FT_HeartbeatPolicyValue_var (void); // destructor

  FT_HeartbeatPolicyValue_var &operator= (FT_HeartbeatPolicyValue *);
  FT_HeartbeatPolicyValue_var &operator= (const FT_HeartbeatPolicyValue_var &);
  FT_HeartbeatPolicyValue_var &operator= (const FT_HeartbeatPolicyValue &); // fixed-size types only
  FT_HeartbeatPolicyValue *operator-> (void);
  const FT_HeartbeatPolicyValue *operator-> (void) const;

  operator const FT_HeartbeatPolicyValue &() const;
  operator FT_HeartbeatPolicyValue &();
  operator FT_HeartbeatPolicyValue &() const;

  // in, inout, out, _retn
  const FT_HeartbeatPolicyValue &in (void) const;
  FT_HeartbeatPolicyValue &inout (void);
  FT_HeartbeatPolicyValue &out (void);
  FT_HeartbeatPolicyValue _retn (void);
  FT_HeartbeatPolicyValue *ptr (void) const;

private:
  FT_HeartbeatPolicyValue *ptr_;
};

typedef FT_HeartbeatPolicyValue &FT_HeartbeatPolicyValue_out;



class TAO_Export FT_HeartbeatPolicy_var : public TAO_Base_var
{
public:
  FT_HeartbeatPolicy_var (void); // default constructor
  FT_HeartbeatPolicy_var (FT_HeartbeatPolicy_ptr p) : ptr_ (p) {}
  FT_HeartbeatPolicy_var (const FT_HeartbeatPolicy_var &); // copy constructor
  ~FT_HeartbeatPolicy_var (void); // destructor

  FT_HeartbeatPolicy_var &operator= (FT_HeartbeatPolicy_ptr);
  FT_HeartbeatPolicy_var &operator= (const FT_HeartbeatPolicy_var &);
  FT_HeartbeatPolicy_ptr operator-> (void) const;

  operator const FT_HeartbeatPolicy_ptr &() const;
  operator FT_HeartbeatPolicy_ptr &();
  // in, inout, out, _retn
  FT_HeartbeatPolicy_ptr in (void) const;
  FT_HeartbeatPolicy_ptr &inout (void);
  FT_HeartbeatPolicy_ptr &out (void);
  FT_HeartbeatPolicy_ptr _retn (void);
  FT_HeartbeatPolicy_ptr ptr (void) const;

private:
  FT_HeartbeatPolicy_ptr ptr_;
  // Unimplemented - prevents widening assignment.
  FT_HeartbeatPolicy_var (const TAO_Base_var &rhs);
  FT_HeartbeatPolicy_var &operator= (const TAO_Base_var &rhs);
};

class TAO_Export FT_HeartbeatPolicy_out
{
public:
  FT_HeartbeatPolicy_out (FT_HeartbeatPolicy_ptr &);
  FT_HeartbeatPolicy_out (FT_HeartbeatPolicy_var &);
  FT_HeartbeatPolicy_out (const FT_HeartbeatPolicy_out &);
  FT_HeartbeatPolicy_out &operator= (const FT_HeartbeatPolicy_out &);
  FT_HeartbeatPolicy_out &operator= (const FT_HeartbeatPolicy_var &);
  FT_HeartbeatPolicy_out &operator= (FT_HeartbeatPolicy_ptr);
  operator FT_HeartbeatPolicy_ptr &();
  FT_HeartbeatPolicy_ptr &ptr (void);
  FT_HeartbeatPolicy_ptr operator-> (void);

private:
  FT_HeartbeatPolicy_ptr &ptr_;
};


class TAO_Export FT_HeartbeatPolicy: public virtual CORBA::Policy
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_HeartbeatPolicy_ptr _ptr_type;
  typedef FT_HeartbeatPolicy_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static FT_HeartbeatPolicy_ptr _duplicate (FT_HeartbeatPolicy_ptr obj);
  static FT_HeartbeatPolicy_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
        TAO_default_environment ()
    );
  static FT_HeartbeatPolicy_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
        TAO_default_environment ()
    );
  static FT_HeartbeatPolicy_ptr _nil (void)
    {
      return (FT_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:
  FT_HeartbeatPolicy (void);
  FT_HeartbeatPolicy (TAO_Stub *objref,
      CORBA::Boolean _tao_collocated = 0
    );
  virtual ~FT_HeartbeatPolicy (void);
private:
  FT_HeartbeatPolicy (const FT_HeartbeatPolicy &);
  void operator= (const FT_HeartbeatPolicy &);
};


class TAO_Export FT_HeartbeatEnabledPolicy_var : public TAO_Base_var
{
public:
  FT_HeartbeatEnabledPolicy_var (void); // default constructor
  FT_HeartbeatEnabledPolicy_var (FT_HeartbeatEnabledPolicy_ptr p) : ptr_ (p) {}
  FT_HeartbeatEnabledPolicy_var (const FT_HeartbeatEnabledPolicy_var &); // copy constructor
  ~FT_HeartbeatEnabledPolicy_var (void); // destructor

  FT_HeartbeatEnabledPolicy_var &operator= (FT_HeartbeatEnabledPolicy_ptr);
  FT_HeartbeatEnabledPolicy_var &operator= (const FT_HeartbeatEnabledPolicy_var &);
  FT_HeartbeatEnabledPolicy_ptr operator-> (void) const;

  operator const FT_HeartbeatEnabledPolicy_ptr &() const;
  operator FT_HeartbeatEnabledPolicy_ptr &();
  // in, inout, out, _retn
  FT_HeartbeatEnabledPolicy_ptr in (void) const;
  FT_HeartbeatEnabledPolicy_ptr &inout (void);
  FT_HeartbeatEnabledPolicy_ptr &out (void);
  FT_HeartbeatEnabledPolicy_ptr _retn (void);
  FT_HeartbeatEnabledPolicy_ptr ptr (void) const;

private:
  FT_HeartbeatEnabledPolicy_ptr ptr_;
  // Unimplemented - prevents widening assignment.
  FT_HeartbeatEnabledPolicy_var (const TAO_Base_var &rhs);
  FT_HeartbeatEnabledPolicy_var &operator= (const TAO_Base_var &rhs);
};


class TAO_Export FT_HeartbeatEnabledPolicy_out
{
public:
  FT_HeartbeatEnabledPolicy_out (FT_HeartbeatEnabledPolicy_ptr &);
  FT_HeartbeatEnabledPolicy_out (FT_HeartbeatEnabledPolicy_var &);
  FT_HeartbeatEnabledPolicy_out (const FT_HeartbeatEnabledPolicy_out &);
  FT_HeartbeatEnabledPolicy_out &operator= (const FT_HeartbeatEnabledPolicy_out &);
  FT_HeartbeatEnabledPolicy_out &operator= (const FT_HeartbeatEnabledPolicy_var &);
  FT_HeartbeatEnabledPolicy_out &operator= (FT_HeartbeatEnabledPolicy_ptr);
  operator FT_HeartbeatEnabledPolicy_ptr &();
  FT_HeartbeatEnabledPolicy_ptr &ptr (void);
  FT_HeartbeatEnabledPolicy_ptr operator-> (void);

private:
  FT_HeartbeatEnabledPolicy_ptr &ptr_;
};


class TAO_Export FT_HeartbeatEnabledPolicy: public virtual CORBA::Policy
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef FT_HeartbeatEnabledPolicy_ptr _ptr_type;
  typedef FT_HeartbeatEnabledPolicy_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static FT_HeartbeatEnabledPolicy_ptr _duplicate (FT_HeartbeatEnabledPolicy_ptr obj);
  static FT_HeartbeatEnabledPolicy_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
        TAO_default_environment ()
    );
  static FT_HeartbeatEnabledPolicy_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &ACE_TRY_ENV =
        TAO_default_environment ()
    );
  static FT_HeartbeatEnabledPolicy_ptr _nil (void)
    {
      return (FT_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:
  FT_HeartbeatEnabledPolicy (void);
  FT_HeartbeatEnabledPolicy (TAO_Stub *objref,
      CORBA::Boolean _tao_collocated = 0
    );
    virtual ~FT_HeartbeatEnabledPolicy (void);
private:
  FT_HeartbeatEnabledPolicy (const FT_HeartbeatEnabledPolicy &);
  void operator= (const FT_HeartbeatEnabledPolicy &);
};

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 *&);


#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 &);

#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 /*TAO_HAS_FT_CORBA == 1 */

#endif /* ifndef */