// -*- C++ -*-
//
// $Id$

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// TAO and the TAO IDL Compiler have been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// and
//       Distributed Object Computing Laboratory
//       University of California at Irvine
//       Irvine, CA
//       USA
//       http://doc.ece.uci.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html

#include "Messaging.h"

#include "tao/Stub.h"
#include "tao/Invocation.h"
#include "tao/PortableInterceptor.h"

#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#include "tao/ClientRequestInfo_i.h"
#include "tao/ClientInterceptorAdapter.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

#if defined (__BORLANDC__)
#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig
#endif /* __BORLANDC__ */

#if !defined (__ACE_INLINE__)
#include "MessagingC.i"
#endif /* !defined INLINE */

static const CORBA::Long _oc_Messaging_RebindMode[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x62696e64), 
  ACE_NTOHL (0x4d6f6465), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/Messaging/RebindMode:1.0
  11,
  ACE_NTOHL (0x52656269), 
  ACE_NTOHL (0x6e644d6f), 
  ACE_NTOHL (0x64650000),  // name = RebindMode
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RebindMode (
    CORBA::tk_alias,
    sizeof (_oc_Messaging_RebindMode),
    (char *) &_oc_Messaging_RebindMode,
    0,
    sizeof (Messaging::RebindMode)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RebindMode, &_tc_TAO_tc_Messaging_RebindMode)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, TRANSPARENT, 0)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, NO_REBIND, 1)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, NO_RECONNECT, 2)
TAO_NAMESPACE_END
static const CORBA::Long _oc_Messaging_RoutingType[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f526f), 
  ACE_NTOHL (0x7574696e), 
  ACE_NTOHL (0x67547970), 
  ACE_NTOHL (0x653a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/RoutingType:1.0
  12,
  ACE_NTOHL (0x526f7574), 
  ACE_NTOHL (0x696e6754), 
  ACE_NTOHL (0x79706500),  // name = RoutingType
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RoutingType (
    CORBA::tk_alias,
    sizeof (_oc_Messaging_RoutingType),
    (char *) &_oc_Messaging_RoutingType,
    0,
    sizeof (Messaging::RoutingType)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RoutingType, &_tc_TAO_tc_Messaging_RoutingType)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, ROUTE_NONE, 0)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, ROUTE_FORWARD, 1)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::Short, ROUTE_STORE_AND_FORWARD, 2)
TAO_NAMESPACE_END
static const CORBA::Long _oc_Messaging_Timeout[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5469), 
  ACE_NTOHL (0x6d656f75), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/Timeout:1.0
  8,
  ACE_NTOHL (0x54696d65), 
  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_Messaging_Timeout (
    CORBA::tk_alias,
    sizeof (_oc_Messaging_Timeout),
    (char *) &_oc_Messaging_Timeout,
    0,
    sizeof (Messaging::Timeout)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Timeout, &_tc_TAO_tc_Messaging_Timeout)
TAO_NAMESPACE_END

static const CORBA::Long _oc_Messaging_Priority[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5072), 
  ACE_NTOHL (0x696f7269), 
  ACE_NTOHL (0x74793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/Priority:1.0
  9,
  ACE_NTOHL (0x5072696f), 
  ACE_NTOHL (0x72697479), 
  ACE_NTOHL (0x0),  // name = Priority
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_Messaging_Priority (
    CORBA::tk_alias,
    sizeof (_oc_Messaging_Priority),
    (char *) &_oc_Messaging_Priority,
    0,
    sizeof (Messaging::Priority)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Priority, &_tc_TAO_tc_Messaging_Priority)
TAO_NAMESPACE_END

static const CORBA::Long _oc_Messaging_Ordering[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f4f72), 
  ACE_NTOHL (0x64657269), 
  ACE_NTOHL (0x6e673a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/Ordering:1.0
  9,
  ACE_NTOHL (0x4f726465), 
  ACE_NTOHL (0x72696e67), 
  ACE_NTOHL (0x0),  // name = Ordering
  CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_Messaging_Ordering (
    CORBA::tk_alias,
    sizeof (_oc_Messaging_Ordering),
    (char *) &_oc_Messaging_Ordering,
    0,
    sizeof (Messaging::Ordering)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Ordering, &_tc_TAO_tc_Messaging_Ordering)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::UShort)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::UShort, ORDER_ANY, 1U)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::UShort)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::UShort, ORDER_TEMPORAL, 2U)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::UShort)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::UShort, ORDER_PRIORITY, 4U)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::UShort)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::UShort, ORDER_DEADLINE, 8U)
TAO_NAMESPACE_END

#if (TAO_HAS_REBIND_POLICY == 1)
TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REBIND_POLICY_TYPE, 23U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RebindPolicy::_tao_class_id = 0;

Messaging::RebindPolicy_ptr
tao_Messaging_RebindPolicy_duplicate (
    Messaging::RebindPolicy_ptr p
  )
{
  return Messaging::RebindPolicy::_duplicate (p);
}

void
tao_Messaging_RebindPolicy_release (
    Messaging::RebindPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RebindPolicy_ptr
tao_Messaging_RebindPolicy_nil (
    void
  )
{
  return Messaging::RebindPolicy::_nil ();
}

Messaging::RebindPolicy_ptr
tao_Messaging_RebindPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RebindPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RebindPolicy_upcast (
    void *src
  )
{
  Messaging::RebindPolicy **tmp =
    ACE_static_cast (Messaging::RebindPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RebindPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RebindPolicy_var::RebindPolicy_var (void) // default constructor
  : ptr_ (RebindPolicy::_nil ())
{}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RebindPolicy_var::RebindPolicy_var (const ::Messaging::RebindPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RebindPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RebindPolicy_var &
Messaging::RebindPolicy_var::operator= (RebindPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RebindPolicy_var &
Messaging::RebindPolicy_var::operator= (const ::Messaging::RebindPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RebindPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RebindPolicy_var::operator const ::Messaging::RebindPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RebindPolicy_var::operator ::Messaging::RebindPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RebindPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
  return val;
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::tao_duplicate (RebindPolicy_ptr p)
{
  return ::Messaging::RebindPolicy::_duplicate (p);
}

void
Messaging::RebindPolicy_var::tao_release (RebindPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::tao_nil (void)
{
  return ::Messaging::RebindPolicy::_nil ();
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RebindPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RebindPolicy_var::tao_upcast (void *src)
{
  RebindPolicy **tmp =
    ACE_static_cast (RebindPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RebindPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RebindPolicy_out::RebindPolicy_out (RebindPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
}

Messaging::RebindPolicy_out::RebindPolicy_out (RebindPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RebindPolicy::_nil ();
}

Messaging::RebindPolicy_out::RebindPolicy_out (const ::Messaging::RebindPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RebindPolicy_out &, p).ptr_)
{}

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

Messaging::RebindPolicy_out &
Messaging::RebindPolicy_out::operator= (const ::Messaging::RebindPolicy_var &p)
{
  this->ptr_ = ::Messaging::RebindPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RebindPolicy_out &
Messaging::RebindPolicy_out::operator= (RebindPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RebindPolicy_out::operator ::Messaging::RebindPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr &
Messaging::RebindPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RebindPolicy_ptr
Messaging::RebindPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RebindPolicy::RebindPolicy (void)
{}

Messaging::RebindPolicy::~RebindPolicy (void)
{}

void Messaging::RebindPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RebindPolicy *tmp = ACE_static_cast (RebindPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RebindPolicy_ptr Messaging::RebindPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RebindPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RebindPolicy_ptr 
Messaging::RebindPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RebindPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RebindPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RebindPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RebindPolicy_ptr
Messaging::RebindPolicy::_duplicate (RebindPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RebindPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RebindPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RebindPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RebindPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RebindPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x62696e64), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/RebindPolicy:1.0
  13,
  ACE_NTOHL (0x52656269), 
  ACE_NTOHL (0x6e64506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x0),  // name = RebindPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RebindPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RebindPolicy),
    (char *) &_oc_Messaging_RebindPolicy,
    0,
    sizeof (Messaging::RebindPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RebindPolicy, &_tc_TAO_tc_Messaging_RebindPolicy)
TAO_NAMESPACE_END

#if (TAO_HAS_SYNC_SCOPE_POLICY == 1)
TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, SYNC_SCOPE_POLICY_TYPE, 24U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::SyncScopePolicy::_tao_class_id = 0;

Messaging::SyncScopePolicy_ptr
tao_Messaging_SyncScopePolicy_duplicate (
    Messaging::SyncScopePolicy_ptr p
  )
{
  return Messaging::SyncScopePolicy::_duplicate (p);
}

void
tao_Messaging_SyncScopePolicy_release (
    Messaging::SyncScopePolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::SyncScopePolicy_ptr
tao_Messaging_SyncScopePolicy_nil (
    void
  )
{
  return Messaging::SyncScopePolicy::_nil ();
}

Messaging::SyncScopePolicy_ptr
tao_Messaging_SyncScopePolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::SyncScopePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_SyncScopePolicy_upcast (
    void *src
  )
{
  Messaging::SyncScopePolicy **tmp =
    ACE_static_cast (Messaging::SyncScopePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::SyncScopePolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::SyncScopePolicy_var::SyncScopePolicy_var (void) // default constructor
  : ptr_ (SyncScopePolicy::_nil ())
{}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::ptr (void) const
{
  return this->ptr_;
}

#endif /* TAO_HAS_REBIND_POLICY == 1 */

Messaging::SyncScopePolicy_var::SyncScopePolicy_var (const ::Messaging::SyncScopePolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (SyncScopePolicy::_duplicate (p.ptr ()))
{}

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

Messaging::SyncScopePolicy_var &
Messaging::SyncScopePolicy_var::operator= (SyncScopePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::SyncScopePolicy_var &
Messaging::SyncScopePolicy_var::operator= (const ::Messaging::SyncScopePolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::SyncScopePolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::SyncScopePolicy_var::operator const ::Messaging::SyncScopePolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::SyncScopePolicy_var::operator ::Messaging::SyncScopePolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::SyncScopePolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
  return val;
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::tao_duplicate (SyncScopePolicy_ptr p)
{
  return ::Messaging::SyncScopePolicy::_duplicate (p);
}

void
Messaging::SyncScopePolicy_var::tao_release (SyncScopePolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::tao_nil (void)
{
  return ::Messaging::SyncScopePolicy::_nil ();
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::SyncScopePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::SyncScopePolicy_var::tao_upcast (void *src)
{
  SyncScopePolicy **tmp =
    ACE_static_cast (SyncScopePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::SyncScopePolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::SyncScopePolicy_out::SyncScopePolicy_out (SyncScopePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
}

Messaging::SyncScopePolicy_out::SyncScopePolicy_out (SyncScopePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::SyncScopePolicy::_nil ();
}

Messaging::SyncScopePolicy_out::SyncScopePolicy_out (const ::Messaging::SyncScopePolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (SyncScopePolicy_out &, p).ptr_)
{}

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

Messaging::SyncScopePolicy_out &
Messaging::SyncScopePolicy_out::operator= (const ::Messaging::SyncScopePolicy_var &p)
{
  this->ptr_ = ::Messaging::SyncScopePolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::SyncScopePolicy_out &
Messaging::SyncScopePolicy_out::operator= (SyncScopePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::SyncScopePolicy_out::operator ::Messaging::SyncScopePolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr &
Messaging::SyncScopePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::SyncScopePolicy::SyncScopePolicy (void)
{}

Messaging::SyncScopePolicy::~SyncScopePolicy (void)
{}

void Messaging::SyncScopePolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  SyncScopePolicy *tmp = ACE_static_cast (SyncScopePolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::SyncScopePolicy_ptr Messaging::SyncScopePolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return SyncScopePolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::SyncScopePolicy_ptr 
Messaging::SyncScopePolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return SyncScopePolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          SyncScopePolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &SyncScopePolicy::_tao_class_id
                  )
              )
        );
}

Messaging::SyncScopePolicy_ptr
Messaging::SyncScopePolicy::_duplicate (SyncScopePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::SyncScopePolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, SyncScopePolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::SyncScopePolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/SyncScopePolicy:1.0";
}

static const CORBA::Long _oc_Messaging_SyncScopePolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5379), 
  ACE_NTOHL (0x6e635363), 
  ACE_NTOHL (0x6f706550), 
  ACE_NTOHL (0x6f6c6963), 
  ACE_NTOHL (0x793a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/SyncScopePolicy:1.0
  16,
  ACE_NTOHL (0x53796e63), 
  ACE_NTOHL (0x53636f70), 
  ACE_NTOHL (0x65506f6c), 
  ACE_NTOHL (0x69637900),  // name = SyncScopePolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_SyncScopePolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_SyncScopePolicy),
    (char *) &_oc_Messaging_SyncScopePolicy,
    0,
    sizeof (Messaging::SyncScopePolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_SyncScopePolicy, &_tc_TAO_tc_Messaging_SyncScopePolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */

#if (TAO_HAS_PRIORITY_POLICIES == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_PRIORITY_POLICY_TYPE, 25U)
TAO_NAMESPACE_END
static const CORBA::Long _oc_Messaging_PriorityRange[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5072), 
  ACE_NTOHL (0x696f7269), 
  ACE_NTOHL (0x74795261), 
  ACE_NTOHL (0x6e67653a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/Messaging/PriorityRange:1.0
  14,
  ACE_NTOHL (0x5072696f), 
  ACE_NTOHL (0x72697479), 
  ACE_NTOHL (0x52616e67), 
  ACE_NTOHL (0x65000000),  // name = PriorityRange
  2, // member count
  4,
  ACE_NTOHL (0x6d696e00),  // name = min
  CORBA::tk_alias, // typecode kind for typedefs
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    35,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x4d657373), 
    ACE_NTOHL (0x6167696e), 
    ACE_NTOHL (0x672f5072), 
    ACE_NTOHL (0x696f7269), 
    ACE_NTOHL (0x74793a31), 
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/Priority:1.0
    9,
    ACE_NTOHL (0x5072696f), 
    ACE_NTOHL (0x72697479), 
    ACE_NTOHL (0x0),  // name = Priority
    CORBA::tk_short,


  4,
  ACE_NTOHL (0x6d617800),  // name = max
  0xffffffff, // indirection
  0xffffffac, // negative offset (-84)
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_PriorityRange (
    CORBA::tk_struct,
    sizeof (_oc_Messaging_PriorityRange),
    (char *) &_oc_Messaging_PriorityRange,
    0,
    sizeof (Messaging::PriorityRange)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PriorityRange, &_tc_TAO_tc_Messaging_PriorityRange)
TAO_NAMESPACE_END

void Messaging::PriorityRange::_tao_any_destructor (void *_tao_void_pointer)
{
  PriorityRange *tmp = ACE_static_cast (PriorityRange*, _tao_void_pointer);
  delete tmp;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RequestPriorityPolicy::_tao_class_id = 0;

Messaging::RequestPriorityPolicy_ptr
tao_Messaging_RequestPriorityPolicy_duplicate (
    Messaging::RequestPriorityPolicy_ptr p
  )
{
  return Messaging::RequestPriorityPolicy::_duplicate (p);
}

void
tao_Messaging_RequestPriorityPolicy_release (
    Messaging::RequestPriorityPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RequestPriorityPolicy_ptr
tao_Messaging_RequestPriorityPolicy_nil (
    void
  )
{
  return Messaging::RequestPriorityPolicy::_nil ();
}

Messaging::RequestPriorityPolicy_ptr
tao_Messaging_RequestPriorityPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RequestPriorityPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RequestPriorityPolicy_upcast (
    void *src
  )
{
  Messaging::RequestPriorityPolicy **tmp =
    ACE_static_cast (Messaging::RequestPriorityPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestPriorityPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (void) // default constructor
  : ptr_ (RequestPriorityPolicy::_nil ())
{}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RequestPriorityPolicy_var::RequestPriorityPolicy_var (const ::Messaging::RequestPriorityPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RequestPriorityPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RequestPriorityPolicy_var &
Messaging::RequestPriorityPolicy_var::operator= (RequestPriorityPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RequestPriorityPolicy_var &
Messaging::RequestPriorityPolicy_var::operator= (const ::Messaging::RequestPriorityPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RequestPriorityPolicy_var::operator const ::Messaging::RequestPriorityPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RequestPriorityPolicy_var::operator ::Messaging::RequestPriorityPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RequestPriorityPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
  return val;
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::tao_duplicate (RequestPriorityPolicy_ptr p)
{
  return ::Messaging::RequestPriorityPolicy::_duplicate (p);
}

void
Messaging::RequestPriorityPolicy_var::tao_release (RequestPriorityPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::tao_nil (void)
{
  return ::Messaging::RequestPriorityPolicy::_nil ();
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RequestPriorityPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RequestPriorityPolicy_var::tao_upcast (void *src)
{
  RequestPriorityPolicy **tmp =
    ACE_static_cast (RequestPriorityPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestPriorityPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (RequestPriorityPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
}

Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (RequestPriorityPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestPriorityPolicy::_nil ();
}

Messaging::RequestPriorityPolicy_out::RequestPriorityPolicy_out (const ::Messaging::RequestPriorityPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RequestPriorityPolicy_out &, p).ptr_)
{}

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

Messaging::RequestPriorityPolicy_out &
Messaging::RequestPriorityPolicy_out::operator= (const ::Messaging::RequestPriorityPolicy_var &p)
{
  this->ptr_ = ::Messaging::RequestPriorityPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RequestPriorityPolicy_out &
Messaging::RequestPriorityPolicy_out::operator= (RequestPriorityPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RequestPriorityPolicy_out::operator ::Messaging::RequestPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr &
Messaging::RequestPriorityPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RequestPriorityPolicy::RequestPriorityPolicy (void)
{}

Messaging::RequestPriorityPolicy::~RequestPriorityPolicy (void)
{}

void Messaging::RequestPriorityPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RequestPriorityPolicy *tmp = ACE_static_cast (RequestPriorityPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RequestPriorityPolicy_ptr Messaging::RequestPriorityPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RequestPriorityPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RequestPriorityPolicy_ptr 
Messaging::RequestPriorityPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RequestPriorityPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RequestPriorityPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RequestPriorityPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RequestPriorityPolicy_ptr
Messaging::RequestPriorityPolicy::_duplicate (RequestPriorityPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RequestPriorityPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RequestPriorityPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RequestPriorityPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RequestPriorityPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RequestPriorityPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x71756573), 
  ACE_NTOHL (0x74507269), 
  ACE_NTOHL (0x6f726974), 
  ACE_NTOHL (0x79506f6c), 
  ACE_NTOHL (0x6963793a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/Messaging/RequestPriorityPolicy:1.0
  22,
  ACE_NTOHL (0x52657175), 
  ACE_NTOHL (0x65737450), 
  ACE_NTOHL (0x72696f72), 
  ACE_NTOHL (0x69747950), 
  ACE_NTOHL (0x6f6c6963), 
  ACE_NTOHL (0x79000000),  // name = RequestPriorityPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RequestPriorityPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RequestPriorityPolicy),
    (char *) &_oc_Messaging_RequestPriorityPolicy,
    0,
    sizeof (Messaging::RequestPriorityPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RequestPriorityPolicy, &_tc_TAO_tc_Messaging_RequestPriorityPolicy)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REPLY_PRIORITY_POLICY_TYPE, 26U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::ReplyPriorityPolicy::_tao_class_id = 0;

Messaging::ReplyPriorityPolicy_ptr
tao_Messaging_ReplyPriorityPolicy_duplicate (
    Messaging::ReplyPriorityPolicy_ptr p
  )
{
  return Messaging::ReplyPriorityPolicy::_duplicate (p);
}

void
tao_Messaging_ReplyPriorityPolicy_release (
    Messaging::ReplyPriorityPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::ReplyPriorityPolicy_ptr
tao_Messaging_ReplyPriorityPolicy_nil (
    void
  )
{
  return Messaging::ReplyPriorityPolicy::_nil ();
}

Messaging::ReplyPriorityPolicy_ptr
tao_Messaging_ReplyPriorityPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::ReplyPriorityPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_ReplyPriorityPolicy_upcast (
    void *src
  )
{
  Messaging::ReplyPriorityPolicy **tmp =
    ACE_static_cast (Messaging::ReplyPriorityPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyPriorityPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (void) // default constructor
  : ptr_ (ReplyPriorityPolicy::_nil ())
{}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::ReplyPriorityPolicy_var::ReplyPriorityPolicy_var (const ::Messaging::ReplyPriorityPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ReplyPriorityPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::ReplyPriorityPolicy_var &
Messaging::ReplyPriorityPolicy_var::operator= (ReplyPriorityPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyPriorityPolicy_var &
Messaging::ReplyPriorityPolicy_var::operator= (const ::Messaging::ReplyPriorityPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::ReplyPriorityPolicy_var::operator const ::Messaging::ReplyPriorityPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::ReplyPriorityPolicy_var::operator ::Messaging::ReplyPriorityPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::ReplyPriorityPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
  return val;
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::tao_duplicate (ReplyPriorityPolicy_ptr p)
{
  return ::Messaging::ReplyPriorityPolicy::_duplicate (p);
}

void
Messaging::ReplyPriorityPolicy_var::tao_release (ReplyPriorityPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::tao_nil (void)
{
  return ::Messaging::ReplyPriorityPolicy::_nil ();
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::ReplyPriorityPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::ReplyPriorityPolicy_var::tao_upcast (void *src)
{
  ReplyPriorityPolicy **tmp =
    ACE_static_cast (ReplyPriorityPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyPriorityPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (ReplyPriorityPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
}

Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (ReplyPriorityPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_nil ();
}

Messaging::ReplyPriorityPolicy_out::ReplyPriorityPolicy_out (const ::Messaging::ReplyPriorityPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ReplyPriorityPolicy_out &, p).ptr_)
{}

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

Messaging::ReplyPriorityPolicy_out &
Messaging::ReplyPriorityPolicy_out::operator= (const ::Messaging::ReplyPriorityPolicy_var &p)
{
  this->ptr_ = ::Messaging::ReplyPriorityPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::ReplyPriorityPolicy_out &
Messaging::ReplyPriorityPolicy_out::operator= (ReplyPriorityPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyPriorityPolicy_out::operator ::Messaging::ReplyPriorityPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr &
Messaging::ReplyPriorityPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::ReplyPriorityPolicy::ReplyPriorityPolicy (void)
{}

Messaging::ReplyPriorityPolicy::~ReplyPriorityPolicy (void)
{}

void Messaging::ReplyPriorityPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ReplyPriorityPolicy *tmp = ACE_static_cast (ReplyPriorityPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::ReplyPriorityPolicy_ptr Messaging::ReplyPriorityPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ReplyPriorityPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::ReplyPriorityPolicy_ptr 
Messaging::ReplyPriorityPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ReplyPriorityPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ReplyPriorityPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ReplyPriorityPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::ReplyPriorityPolicy_ptr
Messaging::ReplyPriorityPolicy::_duplicate (ReplyPriorityPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::ReplyPriorityPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, ReplyPriorityPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::ReplyPriorityPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/ReplyPriorityPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_ReplyPriorityPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  46,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x706c7950), 
  ACE_NTOHL (0x72696f72), 
  ACE_NTOHL (0x69747950), 
  ACE_NTOHL (0x6f6c6963), 
  ACE_NTOHL (0x793a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/ReplyPriorityPolicy:1.0
  20,
  ACE_NTOHL (0x5265706c), 
  ACE_NTOHL (0x79507269), 
  ACE_NTOHL (0x6f726974), 
  ACE_NTOHL (0x79506f6c), 
  ACE_NTOHL (0x69637900),  // name = ReplyPriorityPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_ReplyPriorityPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_ReplyPriorityPolicy),
    (char *) &_oc_Messaging_ReplyPriorityPolicy,
    0,
    sizeof (Messaging::ReplyPriorityPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ReplyPriorityPolicy, &_tc_TAO_tc_Messaging_ReplyPriorityPolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */

#if (TAO_HAS_REQUEST_START_TIME_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_START_TIME_POLICY_TYPE, 27U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RequestStartTimePolicy::_tao_class_id = 0;

Messaging::RequestStartTimePolicy_ptr
tao_Messaging_RequestStartTimePolicy_duplicate (
    Messaging::RequestStartTimePolicy_ptr p
  )
{
  return Messaging::RequestStartTimePolicy::_duplicate (p);
}

void
tao_Messaging_RequestStartTimePolicy_release (
    Messaging::RequestStartTimePolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RequestStartTimePolicy_ptr
tao_Messaging_RequestStartTimePolicy_nil (
    void
  )
{
  return Messaging::RequestStartTimePolicy::_nil ();
}

Messaging::RequestStartTimePolicy_ptr
tao_Messaging_RequestStartTimePolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RequestStartTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RequestStartTimePolicy_upcast (
    void *src
  )
{
  Messaging::RequestStartTimePolicy **tmp =
    ACE_static_cast (Messaging::RequestStartTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestStartTimePolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (void) // default constructor
  : ptr_ (RequestStartTimePolicy::_nil ())
{}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RequestStartTimePolicy_var::RequestStartTimePolicy_var (const ::Messaging::RequestStartTimePolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RequestStartTimePolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RequestStartTimePolicy_var &
Messaging::RequestStartTimePolicy_var::operator= (RequestStartTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RequestStartTimePolicy_var &
Messaging::RequestStartTimePolicy_var::operator= (const ::Messaging::RequestStartTimePolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RequestStartTimePolicy_var::operator const ::Messaging::RequestStartTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RequestStartTimePolicy_var::operator ::Messaging::RequestStartTimePolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RequestStartTimePolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
  return val;
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::tao_duplicate (RequestStartTimePolicy_ptr p)
{
  return ::Messaging::RequestStartTimePolicy::_duplicate (p);
}

void
Messaging::RequestStartTimePolicy_var::tao_release (RequestStartTimePolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::tao_nil (void)
{
  return ::Messaging::RequestStartTimePolicy::_nil ();
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RequestStartTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RequestStartTimePolicy_var::tao_upcast (void *src)
{
  RequestStartTimePolicy **tmp =
    ACE_static_cast (RequestStartTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestStartTimePolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (RequestStartTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
}

Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (RequestStartTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestStartTimePolicy::_nil ();
}

Messaging::RequestStartTimePolicy_out::RequestStartTimePolicy_out (const ::Messaging::RequestStartTimePolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RequestStartTimePolicy_out &, p).ptr_)
{}

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

Messaging::RequestStartTimePolicy_out &
Messaging::RequestStartTimePolicy_out::operator= (const ::Messaging::RequestStartTimePolicy_var &p)
{
  this->ptr_ = ::Messaging::RequestStartTimePolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RequestStartTimePolicy_out &
Messaging::RequestStartTimePolicy_out::operator= (RequestStartTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RequestStartTimePolicy_out::operator ::Messaging::RequestStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr &
Messaging::RequestStartTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RequestStartTimePolicy::RequestStartTimePolicy (void)
{}

Messaging::RequestStartTimePolicy::~RequestStartTimePolicy (void)
{}

void Messaging::RequestStartTimePolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RequestStartTimePolicy *tmp = ACE_static_cast (RequestStartTimePolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RequestStartTimePolicy_ptr Messaging::RequestStartTimePolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RequestStartTimePolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RequestStartTimePolicy_ptr 
Messaging::RequestStartTimePolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RequestStartTimePolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RequestStartTimePolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RequestStartTimePolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RequestStartTimePolicy_ptr
Messaging::RequestStartTimePolicy::_duplicate (RequestStartTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RequestStartTimePolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RequestStartTimePolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RequestStartTimePolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RequestStartTimePolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RequestStartTimePolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  49,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x71756573), 
  ACE_NTOHL (0x74537461), 
  ACE_NTOHL (0x72745469), 
  ACE_NTOHL (0x6d65506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/Messaging/RequestStartTimePolicy:1.0
  23,
  ACE_NTOHL (0x52657175), 
  ACE_NTOHL (0x65737453), 
  ACE_NTOHL (0x74617274), 
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63790000),  // name = RequestStartTimePolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RequestStartTimePolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RequestStartTimePolicy),
    (char *) &_oc_Messaging_RequestStartTimePolicy,
    0,
    sizeof (Messaging::RequestStartTimePolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RequestStartTimePolicy, &_tc_TAO_tc_Messaging_RequestStartTimePolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_REQUEST_START_TIME_POLICY == 1 */

#if (TAO_HAS_REQUEST_END_TIME_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REQUEST_END_TIME_POLICY_TYPE, 28U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RequestEndTimePolicy::_tao_class_id = 0;

Messaging::RequestEndTimePolicy_ptr
tao_Messaging_RequestEndTimePolicy_duplicate (
    Messaging::RequestEndTimePolicy_ptr p
  )
{
  return Messaging::RequestEndTimePolicy::_duplicate (p);
}

void
tao_Messaging_RequestEndTimePolicy_release (
    Messaging::RequestEndTimePolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RequestEndTimePolicy_ptr
tao_Messaging_RequestEndTimePolicy_nil (
    void
  )
{
  return Messaging::RequestEndTimePolicy::_nil ();
}

Messaging::RequestEndTimePolicy_ptr
tao_Messaging_RequestEndTimePolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RequestEndTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RequestEndTimePolicy_upcast (
    void *src
  )
{
  Messaging::RequestEndTimePolicy **tmp =
    ACE_static_cast (Messaging::RequestEndTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestEndTimePolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (void) // default constructor
  : ptr_ (RequestEndTimePolicy::_nil ())
{}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RequestEndTimePolicy_var::RequestEndTimePolicy_var (const ::Messaging::RequestEndTimePolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RequestEndTimePolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RequestEndTimePolicy_var &
Messaging::RequestEndTimePolicy_var::operator= (RequestEndTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RequestEndTimePolicy_var &
Messaging::RequestEndTimePolicy_var::operator= (const ::Messaging::RequestEndTimePolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RequestEndTimePolicy_var::operator const ::Messaging::RequestEndTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RequestEndTimePolicy_var::operator ::Messaging::RequestEndTimePolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RequestEndTimePolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
  return val;
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::tao_duplicate (RequestEndTimePolicy_ptr p)
{
  return ::Messaging::RequestEndTimePolicy::_duplicate (p);
}

void
Messaging::RequestEndTimePolicy_var::tao_release (RequestEndTimePolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::tao_nil (void)
{
  return ::Messaging::RequestEndTimePolicy::_nil ();
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RequestEndTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RequestEndTimePolicy_var::tao_upcast (void *src)
{
  RequestEndTimePolicy **tmp =
    ACE_static_cast (RequestEndTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RequestEndTimePolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (RequestEndTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
}

Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (RequestEndTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RequestEndTimePolicy::_nil ();
}

Messaging::RequestEndTimePolicy_out::RequestEndTimePolicy_out (const ::Messaging::RequestEndTimePolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RequestEndTimePolicy_out &, p).ptr_)
{}

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

Messaging::RequestEndTimePolicy_out &
Messaging::RequestEndTimePolicy_out::operator= (const ::Messaging::RequestEndTimePolicy_var &p)
{
  this->ptr_ = ::Messaging::RequestEndTimePolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RequestEndTimePolicy_out &
Messaging::RequestEndTimePolicy_out::operator= (RequestEndTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RequestEndTimePolicy_out::operator ::Messaging::RequestEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr &
Messaging::RequestEndTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RequestEndTimePolicy::RequestEndTimePolicy (void)
{}

Messaging::RequestEndTimePolicy::~RequestEndTimePolicy (void)
{}

void Messaging::RequestEndTimePolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RequestEndTimePolicy *tmp = ACE_static_cast (RequestEndTimePolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RequestEndTimePolicy_ptr Messaging::RequestEndTimePolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RequestEndTimePolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RequestEndTimePolicy_ptr 
Messaging::RequestEndTimePolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RequestEndTimePolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RequestEndTimePolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RequestEndTimePolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RequestEndTimePolicy_ptr
Messaging::RequestEndTimePolicy::_duplicate (RequestEndTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RequestEndTimePolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RequestEndTimePolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RequestEndTimePolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RequestEndTimePolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RequestEndTimePolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  47,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x71756573), 
  ACE_NTOHL (0x74456e64), 
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/RequestEndTimePolicy:1.0
  21,
  ACE_NTOHL (0x52657175), 
  ACE_NTOHL (0x65737445), 
  ACE_NTOHL (0x6e645469), 
  ACE_NTOHL (0x6d65506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x0),  // name = RequestEndTimePolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RequestEndTimePolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RequestEndTimePolicy),
    (char *) &_oc_Messaging_RequestEndTimePolicy,
    0,
    sizeof (Messaging::RequestEndTimePolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RequestEndTimePolicy, &_tc_TAO_tc_Messaging_RequestEndTimePolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_REQUEST_END_TIME_POLICY == 1 */

#if (TAO_HAS_REPLY_START_TIME_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REPLY_START_TIME_POLICY_TYPE, 29U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::ReplyStartTimePolicy::_tao_class_id = 0;

Messaging::ReplyStartTimePolicy_ptr
tao_Messaging_ReplyStartTimePolicy_duplicate (
    Messaging::ReplyStartTimePolicy_ptr p
  )
{
  return Messaging::ReplyStartTimePolicy::_duplicate (p);
}

void
tao_Messaging_ReplyStartTimePolicy_release (
    Messaging::ReplyStartTimePolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::ReplyStartTimePolicy_ptr
tao_Messaging_ReplyStartTimePolicy_nil (
    void
  )
{
  return Messaging::ReplyStartTimePolicy::_nil ();
}

Messaging::ReplyStartTimePolicy_ptr
tao_Messaging_ReplyStartTimePolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::ReplyStartTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_ReplyStartTimePolicy_upcast (
    void *src
  )
{
  Messaging::ReplyStartTimePolicy **tmp =
    ACE_static_cast (Messaging::ReplyStartTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyStartTimePolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (void) // default constructor
  : ptr_ (ReplyStartTimePolicy::_nil ())
{}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::ReplyStartTimePolicy_var::ReplyStartTimePolicy_var (const ::Messaging::ReplyStartTimePolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ReplyStartTimePolicy::_duplicate (p.ptr ()))
{}

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

Messaging::ReplyStartTimePolicy_var &
Messaging::ReplyStartTimePolicy_var::operator= (ReplyStartTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyStartTimePolicy_var &
Messaging::ReplyStartTimePolicy_var::operator= (const ::Messaging::ReplyStartTimePolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::ReplyStartTimePolicy_var::operator const ::Messaging::ReplyStartTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::ReplyStartTimePolicy_var::operator ::Messaging::ReplyStartTimePolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::ReplyStartTimePolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
  return val;
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::tao_duplicate (ReplyStartTimePolicy_ptr p)
{
  return ::Messaging::ReplyStartTimePolicy::_duplicate (p);
}

void
Messaging::ReplyStartTimePolicy_var::tao_release (ReplyStartTimePolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::tao_nil (void)
{
  return ::Messaging::ReplyStartTimePolicy::_nil ();
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::ReplyStartTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::ReplyStartTimePolicy_var::tao_upcast (void *src)
{
  ReplyStartTimePolicy **tmp =
    ACE_static_cast (ReplyStartTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyStartTimePolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (ReplyStartTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
}

Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (ReplyStartTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_nil ();
}

Messaging::ReplyStartTimePolicy_out::ReplyStartTimePolicy_out (const ::Messaging::ReplyStartTimePolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ReplyStartTimePolicy_out &, p).ptr_)
{}

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

Messaging::ReplyStartTimePolicy_out &
Messaging::ReplyStartTimePolicy_out::operator= (const ::Messaging::ReplyStartTimePolicy_var &p)
{
  this->ptr_ = ::Messaging::ReplyStartTimePolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::ReplyStartTimePolicy_out &
Messaging::ReplyStartTimePolicy_out::operator= (ReplyStartTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyStartTimePolicy_out::operator ::Messaging::ReplyStartTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr &
Messaging::ReplyStartTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::ReplyStartTimePolicy::ReplyStartTimePolicy (void)
{}

Messaging::ReplyStartTimePolicy::~ReplyStartTimePolicy (void)
{}

void Messaging::ReplyStartTimePolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ReplyStartTimePolicy *tmp = ACE_static_cast (ReplyStartTimePolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::ReplyStartTimePolicy_ptr Messaging::ReplyStartTimePolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ReplyStartTimePolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::ReplyStartTimePolicy_ptr 
Messaging::ReplyStartTimePolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ReplyStartTimePolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ReplyStartTimePolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ReplyStartTimePolicy::_tao_class_id
                  )
              )
        );
}

Messaging::ReplyStartTimePolicy_ptr
Messaging::ReplyStartTimePolicy::_duplicate (ReplyStartTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::ReplyStartTimePolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, ReplyStartTimePolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::ReplyStartTimePolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/ReplyStartTimePolicy:1.0";
}

static const CORBA::Long _oc_Messaging_ReplyStartTimePolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  47,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x706c7953), 
  ACE_NTOHL (0x74617274), 
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/ReplyStartTimePolicy:1.0
  21,
  ACE_NTOHL (0x5265706c), 
  ACE_NTOHL (0x79537461), 
  ACE_NTOHL (0x72745469), 
  ACE_NTOHL (0x6d65506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x0),  // name = ReplyStartTimePolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_ReplyStartTimePolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_ReplyStartTimePolicy),
    (char *) &_oc_Messaging_ReplyStartTimePolicy,
    0,
    sizeof (Messaging::ReplyStartTimePolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ReplyStartTimePolicy, &_tc_TAO_tc_Messaging_ReplyStartTimePolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_REPLY_START_TIME_POLICY == 1 */

#if (TAO_HAS_REPLY_END_TIME_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, REPLY_END_TIME_POLICY_TYPE, 30U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::ReplyEndTimePolicy::_tao_class_id = 0;

Messaging::ReplyEndTimePolicy_ptr
tao_Messaging_ReplyEndTimePolicy_duplicate (
    Messaging::ReplyEndTimePolicy_ptr p
  )
{
  return Messaging::ReplyEndTimePolicy::_duplicate (p);
}

void
tao_Messaging_ReplyEndTimePolicy_release (
    Messaging::ReplyEndTimePolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::ReplyEndTimePolicy_ptr
tao_Messaging_ReplyEndTimePolicy_nil (
    void
  )
{
  return Messaging::ReplyEndTimePolicy::_nil ();
}

Messaging::ReplyEndTimePolicy_ptr
tao_Messaging_ReplyEndTimePolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::ReplyEndTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_ReplyEndTimePolicy_upcast (
    void *src
  )
{
  Messaging::ReplyEndTimePolicy **tmp =
    ACE_static_cast (Messaging::ReplyEndTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyEndTimePolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (void) // default constructor
  : ptr_ (ReplyEndTimePolicy::_nil ())
{}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::ReplyEndTimePolicy_var::ReplyEndTimePolicy_var (const ::Messaging::ReplyEndTimePolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ReplyEndTimePolicy::_duplicate (p.ptr ()))
{}

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

Messaging::ReplyEndTimePolicy_var &
Messaging::ReplyEndTimePolicy_var::operator= (ReplyEndTimePolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyEndTimePolicy_var &
Messaging::ReplyEndTimePolicy_var::operator= (const ::Messaging::ReplyEndTimePolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::ReplyEndTimePolicy_var::operator const ::Messaging::ReplyEndTimePolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::ReplyEndTimePolicy_var::operator ::Messaging::ReplyEndTimePolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::ReplyEndTimePolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
  return val;
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::tao_duplicate (ReplyEndTimePolicy_ptr p)
{
  return ::Messaging::ReplyEndTimePolicy::_duplicate (p);
}

void
Messaging::ReplyEndTimePolicy_var::tao_release (ReplyEndTimePolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::tao_nil (void)
{
  return ::Messaging::ReplyEndTimePolicy::_nil ();
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::ReplyEndTimePolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::ReplyEndTimePolicy_var::tao_upcast (void *src)
{
  ReplyEndTimePolicy **tmp =
    ACE_static_cast (ReplyEndTimePolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyEndTimePolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (ReplyEndTimePolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
}

Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (ReplyEndTimePolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_nil ();
}

Messaging::ReplyEndTimePolicy_out::ReplyEndTimePolicy_out (const ::Messaging::ReplyEndTimePolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ReplyEndTimePolicy_out &, p).ptr_)
{}

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

Messaging::ReplyEndTimePolicy_out &
Messaging::ReplyEndTimePolicy_out::operator= (const ::Messaging::ReplyEndTimePolicy_var &p)
{
  this->ptr_ = ::Messaging::ReplyEndTimePolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::ReplyEndTimePolicy_out &
Messaging::ReplyEndTimePolicy_out::operator= (ReplyEndTimePolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyEndTimePolicy_out::operator ::Messaging::ReplyEndTimePolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr &
Messaging::ReplyEndTimePolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::ReplyEndTimePolicy::ReplyEndTimePolicy (void)
{}

Messaging::ReplyEndTimePolicy::~ReplyEndTimePolicy (void)
{}

void Messaging::ReplyEndTimePolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ReplyEndTimePolicy *tmp = ACE_static_cast (ReplyEndTimePolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::ReplyEndTimePolicy_ptr Messaging::ReplyEndTimePolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ReplyEndTimePolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::ReplyEndTimePolicy_ptr 
Messaging::ReplyEndTimePolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ReplyEndTimePolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ReplyEndTimePolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ReplyEndTimePolicy::_tao_class_id
                  )
              )
        );
}

Messaging::ReplyEndTimePolicy_ptr
Messaging::ReplyEndTimePolicy::_duplicate (ReplyEndTimePolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::ReplyEndTimePolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, ReplyEndTimePolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::ReplyEndTimePolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/ReplyEndTimePolicy:1.0";
}

static const CORBA::Long _oc_Messaging_ReplyEndTimePolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  45,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x706c7945), 
  ACE_NTOHL (0x6e645469), 
  ACE_NTOHL (0x6d65506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/Messaging/ReplyEndTimePolicy:1.0
  19,
  ACE_NTOHL (0x5265706c), 
  ACE_NTOHL (0x79456e64), 
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63790000),  // name = ReplyEndTimePolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_ReplyEndTimePolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_ReplyEndTimePolicy),
    (char *) &_oc_Messaging_ReplyEndTimePolicy,
    0,
    sizeof (Messaging::ReplyEndTimePolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ReplyEndTimePolicy, &_tc_TAO_tc_Messaging_ReplyEndTimePolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_REPLY_END_TIME_POLICY == 1 */

#if (TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, RELATIVE_REQ_TIMEOUT_POLICY_TYPE, 31U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RelativeRequestTimeoutPolicy::_tao_class_id = 0;

Messaging::RelativeRequestTimeoutPolicy_ptr
tao_Messaging_RelativeRequestTimeoutPolicy_duplicate (
    Messaging::RelativeRequestTimeoutPolicy_ptr p
  )
{
  return Messaging::RelativeRequestTimeoutPolicy::_duplicate (p);
}

void
tao_Messaging_RelativeRequestTimeoutPolicy_release (
    Messaging::RelativeRequestTimeoutPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RelativeRequestTimeoutPolicy_ptr
tao_Messaging_RelativeRequestTimeoutPolicy_nil (
    void
  )
{
  return Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

Messaging::RelativeRequestTimeoutPolicy_ptr
tao_Messaging_RelativeRequestTimeoutPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RelativeRequestTimeoutPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RelativeRequestTimeoutPolicy_upcast (
    void *src
  )
{
  Messaging::RelativeRequestTimeoutPolicy **tmp =
    ACE_static_cast (Messaging::RelativeRequestTimeoutPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RelativeRequestTimeoutPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (void) // default constructor
  : ptr_ (RelativeRequestTimeoutPolicy::_nil ())
{}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RelativeRequestTimeoutPolicy_var::RelativeRequestTimeoutPolicy_var (const ::Messaging::RelativeRequestTimeoutPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RelativeRequestTimeoutPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RelativeRequestTimeoutPolicy_var &
Messaging::RelativeRequestTimeoutPolicy_var::operator= (RelativeRequestTimeoutPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RelativeRequestTimeoutPolicy_var &
Messaging::RelativeRequestTimeoutPolicy_var::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RelativeRequestTimeoutPolicy_var::operator const ::Messaging::RelativeRequestTimeoutPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RelativeRequestTimeoutPolicy_var::operator ::Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RelativeRequestTimeoutPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
  return val;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::tao_duplicate (RelativeRequestTimeoutPolicy_ptr p)
{
  return ::Messaging::RelativeRequestTimeoutPolicy::_duplicate (p);
}

void
Messaging::RelativeRequestTimeoutPolicy_var::tao_release (RelativeRequestTimeoutPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::tao_nil (void)
{
  return ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RelativeRequestTimeoutPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RelativeRequestTimeoutPolicy_var::tao_upcast (void *src)
{
  RelativeRequestTimeoutPolicy **tmp =
    ACE_static_cast (RelativeRequestTimeoutPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RelativeRequestTimeoutPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (RelativeRequestTimeoutPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (RelativeRequestTimeoutPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_nil ();
}

Messaging::RelativeRequestTimeoutPolicy_out::RelativeRequestTimeoutPolicy_out (const ::Messaging::RelativeRequestTimeoutPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RelativeRequestTimeoutPolicy_out &, p).ptr_)
{}

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

Messaging::RelativeRequestTimeoutPolicy_out &
Messaging::RelativeRequestTimeoutPolicy_out::operator= (const ::Messaging::RelativeRequestTimeoutPolicy_var &p)
{
  this->ptr_ = ::Messaging::RelativeRequestTimeoutPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RelativeRequestTimeoutPolicy_out &
Messaging::RelativeRequestTimeoutPolicy_out::operator= (RelativeRequestTimeoutPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RelativeRequestTimeoutPolicy_out::operator ::Messaging::RelativeRequestTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr &
Messaging::RelativeRequestTimeoutPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RelativeRequestTimeoutPolicy::RelativeRequestTimeoutPolicy (void)
{}

Messaging::RelativeRequestTimeoutPolicy::~RelativeRequestTimeoutPolicy (void)
{}

void Messaging::RelativeRequestTimeoutPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RelativeRequestTimeoutPolicy *tmp = ACE_static_cast (RelativeRequestTimeoutPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RelativeRequestTimeoutPolicy_ptr Messaging::RelativeRequestTimeoutPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RelativeRequestTimeoutPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RelativeRequestTimeoutPolicy_ptr 
Messaging::RelativeRequestTimeoutPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RelativeRequestTimeoutPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RelativeRequestTimeoutPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RelativeRequestTimeoutPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RelativeRequestTimeoutPolicy_ptr
Messaging::RelativeRequestTimeoutPolicy::_duplicate (RelativeRequestTimeoutPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RelativeRequestTimeoutPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RelativeRequestTimeoutPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RelativeRequestTimeoutPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RelativeRequestTimeoutPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RelativeRequestTimeoutPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  55,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x6c617469), 
  ACE_NTOHL (0x76655265), 
  ACE_NTOHL (0x71756573), 
  ACE_NTOHL (0x7454696d), 
  ACE_NTOHL (0x656f7574), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/RelativeRequestTimeoutPolicy:1.0
  29,
  ACE_NTOHL (0x52656c61), 
  ACE_NTOHL (0x74697665), 
  ACE_NTOHL (0x52657175), 
  ACE_NTOHL (0x65737454), 
  ACE_NTOHL (0x696d656f), 
  ACE_NTOHL (0x7574506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x0),  // name = RelativeRequestTimeoutPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RelativeRequestTimeoutPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RelativeRequestTimeoutPolicy),
    (char *) &_oc_Messaging_RelativeRequestTimeoutPolicy,
    0,
    sizeof (Messaging::RelativeRequestTimeoutPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RelativeRequestTimeoutPolicy, &_tc_TAO_tc_Messaging_RelativeRequestTimeoutPolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1 */

#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, RELATIVE_RT_TIMEOUT_POLICY_TYPE, 32U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RelativeRoundtripTimeoutPolicy::_tao_class_id = 0;

Messaging::RelativeRoundtripTimeoutPolicy_ptr
tao_Messaging_RelativeRoundtripTimeoutPolicy_duplicate (
    Messaging::RelativeRoundtripTimeoutPolicy_ptr p
  )
{
  return Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p);
}

void
tao_Messaging_RelativeRoundtripTimeoutPolicy_release (
    Messaging::RelativeRoundtripTimeoutPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RelativeRoundtripTimeoutPolicy_ptr
tao_Messaging_RelativeRoundtripTimeoutPolicy_nil (
    void
  )
{
  return Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

Messaging::RelativeRoundtripTimeoutPolicy_ptr
tao_Messaging_RelativeRoundtripTimeoutPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RelativeRoundtripTimeoutPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RelativeRoundtripTimeoutPolicy_upcast (
    void *src
  )
{
  Messaging::RelativeRoundtripTimeoutPolicy **tmp =
    ACE_static_cast (Messaging::RelativeRoundtripTimeoutPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RelativeRoundtripTimeoutPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (void) // default constructor
  : ptr_ (RelativeRoundtripTimeoutPolicy::_nil ())
{}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RelativeRoundtripTimeoutPolicy_var::RelativeRoundtripTimeoutPolicy_var (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RelativeRoundtripTimeoutPolicy_var &
Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (RelativeRoundtripTimeoutPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RelativeRoundtripTimeoutPolicy_var &
Messaging::RelativeRoundtripTimeoutPolicy_var::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RelativeRoundtripTimeoutPolicy_var::operator const ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RelativeRoundtripTimeoutPolicy_var::operator ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RelativeRoundtripTimeoutPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
  return val;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::tao_duplicate (RelativeRoundtripTimeoutPolicy_ptr p)
{
  return ::Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p);
}

void
Messaging::RelativeRoundtripTimeoutPolicy_var::tao_release (RelativeRoundtripTimeoutPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::tao_nil (void)
{
  return ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RelativeRoundtripTimeoutPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RelativeRoundtripTimeoutPolicy_var::tao_upcast (void *src)
{
  RelativeRoundtripTimeoutPolicy **tmp =
    ACE_static_cast (RelativeRoundtripTimeoutPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RelativeRoundtripTimeoutPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (RelativeRoundtripTimeoutPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (RelativeRoundtripTimeoutPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
}

Messaging::RelativeRoundtripTimeoutPolicy_out::RelativeRoundtripTimeoutPolicy_out (const ::Messaging::RelativeRoundtripTimeoutPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RelativeRoundtripTimeoutPolicy_out &, p).ptr_)
{}

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

Messaging::RelativeRoundtripTimeoutPolicy_out &
Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (const ::Messaging::RelativeRoundtripTimeoutPolicy_var &p)
{
  this->ptr_ = ::Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RelativeRoundtripTimeoutPolicy_out &
Messaging::RelativeRoundtripTimeoutPolicy_out::operator= (RelativeRoundtripTimeoutPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RelativeRoundtripTimeoutPolicy_out::operator ::Messaging::RelativeRoundtripTimeoutPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr &
Messaging::RelativeRoundtripTimeoutPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RelativeRoundtripTimeoutPolicy::RelativeRoundtripTimeoutPolicy (void)
{}

Messaging::RelativeRoundtripTimeoutPolicy::~RelativeRoundtripTimeoutPolicy (void)
{}

void Messaging::RelativeRoundtripTimeoutPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RelativeRoundtripTimeoutPolicy *tmp = ACE_static_cast (RelativeRoundtripTimeoutPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RelativeRoundtripTimeoutPolicy_ptr Messaging::RelativeRoundtripTimeoutPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RelativeRoundtripTimeoutPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RelativeRoundtripTimeoutPolicy_ptr 
Messaging::RelativeRoundtripTimeoutPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RelativeRoundtripTimeoutPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RelativeRoundtripTimeoutPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RelativeRoundtripTimeoutPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RelativeRoundtripTimeoutPolicy_ptr
Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (RelativeRoundtripTimeoutPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RelativeRoundtripTimeoutPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RelativeRoundtripTimeoutPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RelativeRoundtripTimeoutPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RelativeRoundtripTimeoutPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RelativeRoundtripTimeoutPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  57,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x6c617469), 
  ACE_NTOHL (0x7665526f), 
  ACE_NTOHL (0x756e6474), 
  ACE_NTOHL (0x72697054), 
  ACE_NTOHL (0x696d656f), 
  ACE_NTOHL (0x7574506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/Messaging/RelativeRoundtripTimeoutPolicy:1.0
  31,
  ACE_NTOHL (0x52656c61), 
  ACE_NTOHL (0x74697665), 
  ACE_NTOHL (0x526f756e), 
  ACE_NTOHL (0x64747269), 
  ACE_NTOHL (0x7054696d), 
  ACE_NTOHL (0x656f7574), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63790000),  // name = RelativeRoundtripTimeoutPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RelativeRoundtripTimeoutPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RelativeRoundtripTimeoutPolicy),
    (char *) &_oc_Messaging_RelativeRoundtripTimeoutPolicy,
    0,
    sizeof (Messaging::RelativeRoundtripTimeoutPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RelativeRoundtripTimeoutPolicy, &_tc_TAO_tc_Messaging_RelativeRoundtripTimeoutPolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */

#if (TAO_HAS_ROUTING_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, ROUTING_POLICY_TYPE, 33U)
TAO_NAMESPACE_END
static const CORBA::Long _oc_Messaging_RoutingTypeRange[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f526f), 
  ACE_NTOHL (0x7574696e), 
  ACE_NTOHL (0x67547970), 
  ACE_NTOHL (0x6552616e), 
  ACE_NTOHL (0x67653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/RoutingTypeRange:1.0
  17,
  ACE_NTOHL (0x526f7574), 
  ACE_NTOHL (0x696e6754), 
  ACE_NTOHL (0x79706552), 
  ACE_NTOHL (0x616e6765), 
  ACE_NTOHL (0x0),  // name = RoutingTypeRange
  2, // member count
  4,
  ACE_NTOHL (0x6d696e00),  // name = min
  CORBA::tk_alias, // typecode kind for typedefs
  68, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    38,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x4d657373), 
    ACE_NTOHL (0x6167696e), 
    ACE_NTOHL (0x672f526f), 
    ACE_NTOHL (0x7574696e), 
    ACE_NTOHL (0x67547970), 
    ACE_NTOHL (0x653a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/RoutingType:1.0
    12,
    ACE_NTOHL (0x526f7574), 
    ACE_NTOHL (0x696e6754), 
    ACE_NTOHL (0x79706500),  // name = RoutingType
    CORBA::tk_short,


  4,
  ACE_NTOHL (0x6d617800),  // name = max
  0xffffffff, // indirection
  0xffffffa8, // negative offset (-88)
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RoutingTypeRange (
    CORBA::tk_struct,
    sizeof (_oc_Messaging_RoutingTypeRange),
    (char *) &_oc_Messaging_RoutingTypeRange,
    0,
    sizeof (Messaging::RoutingTypeRange)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RoutingTypeRange, &_tc_TAO_tc_Messaging_RoutingTypeRange)
TAO_NAMESPACE_END

void Messaging::RoutingTypeRange::_tao_any_destructor (void *_tao_void_pointer)
{
  RoutingTypeRange *tmp = ACE_static_cast (RoutingTypeRange*, _tao_void_pointer);
  delete tmp;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::RoutingPolicy::_tao_class_id = 0;

Messaging::RoutingPolicy_ptr
tao_Messaging_RoutingPolicy_duplicate (
    Messaging::RoutingPolicy_ptr p
  )
{
  return Messaging::RoutingPolicy::_duplicate (p);
}

void
tao_Messaging_RoutingPolicy_release (
    Messaging::RoutingPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::RoutingPolicy_ptr
tao_Messaging_RoutingPolicy_nil (
    void
  )
{
  return Messaging::RoutingPolicy::_nil ();
}

Messaging::RoutingPolicy_ptr
tao_Messaging_RoutingPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::RoutingPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_RoutingPolicy_upcast (
    void *src
  )
{
  Messaging::RoutingPolicy **tmp =
    ACE_static_cast (Messaging::RoutingPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RoutingPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::RoutingPolicy_var::RoutingPolicy_var (void) // default constructor
  : ptr_ (RoutingPolicy::_nil ())
{}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::RoutingPolicy_var::RoutingPolicy_var (const ::Messaging::RoutingPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RoutingPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::RoutingPolicy_var &
Messaging::RoutingPolicy_var::operator= (RoutingPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::RoutingPolicy_var &
Messaging::RoutingPolicy_var::operator= (const ::Messaging::RoutingPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::RoutingPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::RoutingPolicy_var::operator const ::Messaging::RoutingPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::RoutingPolicy_var::operator ::Messaging::RoutingPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::RoutingPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
  return val;
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::tao_duplicate (RoutingPolicy_ptr p)
{
  return ::Messaging::RoutingPolicy::_duplicate (p);
}

void
Messaging::RoutingPolicy_var::tao_release (RoutingPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::tao_nil (void)
{
  return ::Messaging::RoutingPolicy::_nil ();
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::RoutingPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::RoutingPolicy_var::tao_upcast (void *src)
{
  RoutingPolicy **tmp =
    ACE_static_cast (RoutingPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::RoutingPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::RoutingPolicy_out::RoutingPolicy_out (RoutingPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
}

Messaging::RoutingPolicy_out::RoutingPolicy_out (RoutingPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::RoutingPolicy::_nil ();
}

Messaging::RoutingPolicy_out::RoutingPolicy_out (const ::Messaging::RoutingPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RoutingPolicy_out &, p).ptr_)
{}

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

Messaging::RoutingPolicy_out &
Messaging::RoutingPolicy_out::operator= (const ::Messaging::RoutingPolicy_var &p)
{
  this->ptr_ = ::Messaging::RoutingPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::RoutingPolicy_out &
Messaging::RoutingPolicy_out::operator= (RoutingPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::RoutingPolicy_out::operator ::Messaging::RoutingPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr &
Messaging::RoutingPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::RoutingPolicy::RoutingPolicy (void)
{}

Messaging::RoutingPolicy::~RoutingPolicy (void)
{}

void Messaging::RoutingPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  RoutingPolicy *tmp = ACE_static_cast (RoutingPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::RoutingPolicy_ptr Messaging::RoutingPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RoutingPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::RoutingPolicy_ptr 
Messaging::RoutingPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RoutingPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          RoutingPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RoutingPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::RoutingPolicy_ptr
Messaging::RoutingPolicy::_duplicate (RoutingPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::RoutingPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, RoutingPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::RoutingPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/RoutingPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_RoutingPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f526f), 
  ACE_NTOHL (0x7574696e), 
  ACE_NTOHL (0x67506f6c), 
  ACE_NTOHL (0x6963793a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/Messaging/RoutingPolicy:1.0
  14,
  ACE_NTOHL (0x526f7574), 
  ACE_NTOHL (0x696e6750), 
  ACE_NTOHL (0x6f6c6963), 
  ACE_NTOHL (0x79000000),  // name = RoutingPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_RoutingPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_RoutingPolicy),
    (char *) &_oc_Messaging_RoutingPolicy,
    0,
    sizeof (Messaging::RoutingPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_RoutingPolicy, &_tc_TAO_tc_Messaging_RoutingPolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_ROUTING_POLICY == 1 */

#if (TAO_HAS_MAX_HOPS_POLICY == 1)

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, MAX_HOPS_POLICY_TYPE, 34U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::MaxHopsPolicy::_tao_class_id = 0;

Messaging::MaxHopsPolicy_ptr
tao_Messaging_MaxHopsPolicy_duplicate (
    Messaging::MaxHopsPolicy_ptr p
  )
{
  return Messaging::MaxHopsPolicy::_duplicate (p);
}

void
tao_Messaging_MaxHopsPolicy_release (
    Messaging::MaxHopsPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::MaxHopsPolicy_ptr
tao_Messaging_MaxHopsPolicy_nil (
    void
  )
{
  return Messaging::MaxHopsPolicy::_nil ();
}

Messaging::MaxHopsPolicy_ptr
tao_Messaging_MaxHopsPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::MaxHopsPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_MaxHopsPolicy_upcast (
    void *src
  )
{
  Messaging::MaxHopsPolicy **tmp =
    ACE_static_cast (Messaging::MaxHopsPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::MaxHopsPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (void) // default constructor
  : ptr_ (MaxHopsPolicy::_nil ())
{}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::MaxHopsPolicy_var::MaxHopsPolicy_var (const ::Messaging::MaxHopsPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (MaxHopsPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::MaxHopsPolicy_var &
Messaging::MaxHopsPolicy_var::operator= (MaxHopsPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::MaxHopsPolicy_var &
Messaging::MaxHopsPolicy_var::operator= (const ::Messaging::MaxHopsPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::MaxHopsPolicy_var::operator const ::Messaging::MaxHopsPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::MaxHopsPolicy_var::operator ::Messaging::MaxHopsPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::MaxHopsPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
  return val;
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::tao_duplicate (MaxHopsPolicy_ptr p)
{
  return ::Messaging::MaxHopsPolicy::_duplicate (p);
}

void
Messaging::MaxHopsPolicy_var::tao_release (MaxHopsPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::tao_nil (void)
{
  return ::Messaging::MaxHopsPolicy::_nil ();
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::MaxHopsPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::MaxHopsPolicy_var::tao_upcast (void *src)
{
  MaxHopsPolicy **tmp =
    ACE_static_cast (MaxHopsPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::MaxHopsPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (MaxHopsPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
}

Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (MaxHopsPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::MaxHopsPolicy::_nil ();
}

Messaging::MaxHopsPolicy_out::MaxHopsPolicy_out (const ::Messaging::MaxHopsPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (MaxHopsPolicy_out &, p).ptr_)
{}

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

Messaging::MaxHopsPolicy_out &
Messaging::MaxHopsPolicy_out::operator= (const ::Messaging::MaxHopsPolicy_var &p)
{
  this->ptr_ = ::Messaging::MaxHopsPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::MaxHopsPolicy_out &
Messaging::MaxHopsPolicy_out::operator= (MaxHopsPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::MaxHopsPolicy_out::operator ::Messaging::MaxHopsPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr &
Messaging::MaxHopsPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::MaxHopsPolicy::MaxHopsPolicy (void)
{}

Messaging::MaxHopsPolicy::~MaxHopsPolicy (void)
{}

void Messaging::MaxHopsPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  MaxHopsPolicy *tmp = ACE_static_cast (MaxHopsPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::MaxHopsPolicy_ptr Messaging::MaxHopsPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return MaxHopsPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::MaxHopsPolicy_ptr 
Messaging::MaxHopsPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return MaxHopsPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          MaxHopsPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &MaxHopsPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::MaxHopsPolicy_ptr
Messaging::MaxHopsPolicy::_duplicate (MaxHopsPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::MaxHopsPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, MaxHopsPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::MaxHopsPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/MaxHopsPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_MaxHopsPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f4d61), 
  ACE_NTOHL (0x78486f70), 
  ACE_NTOHL (0x73506f6c), 
  ACE_NTOHL (0x6963793a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/Messaging/MaxHopsPolicy:1.0
  14,
  ACE_NTOHL (0x4d617848), 
  ACE_NTOHL (0x6f707350), 
  ACE_NTOHL (0x6f6c6963), 
  ACE_NTOHL (0x79000000),  // name = MaxHopsPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_MaxHopsPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_MaxHopsPolicy),
    (char *) &_oc_Messaging_MaxHopsPolicy,
    0,
    sizeof (Messaging::MaxHopsPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_MaxHopsPolicy, &_tc_TAO_tc_Messaging_MaxHopsPolicy)
TAO_NAMESPACE_END

#endif /* TAO_HAS_MAX_HOPS_POLICY == 1 */



TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, QUEUE_ORDER_POLICY_TYPE, 35U)
TAO_NAMESPACE_END

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::QueueOrderPolicy::_tao_class_id = 0;

Messaging::QueueOrderPolicy_ptr
tao_Messaging_QueueOrderPolicy_duplicate (
    Messaging::QueueOrderPolicy_ptr p
  )
{
  return Messaging::QueueOrderPolicy::_duplicate (p);
}

void
tao_Messaging_QueueOrderPolicy_release (
    Messaging::QueueOrderPolicy_ptr p
  )
{
  CORBA::release (p);
}

Messaging::QueueOrderPolicy_ptr
tao_Messaging_QueueOrderPolicy_nil (
    void
  )
{
  return Messaging::QueueOrderPolicy::_nil ();
}

Messaging::QueueOrderPolicy_ptr
tao_Messaging_QueueOrderPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::QueueOrderPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_QueueOrderPolicy_upcast (
    void *src
  )
{
  Messaging::QueueOrderPolicy **tmp =
    ACE_static_cast (Messaging::QueueOrderPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::QueueOrderPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (void) // default constructor
  : ptr_ (QueueOrderPolicy::_nil ())
{}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::QueueOrderPolicy_var::QueueOrderPolicy_var (const ::Messaging::QueueOrderPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (QueueOrderPolicy::_duplicate (p.ptr ()))
{}

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

Messaging::QueueOrderPolicy_var &
Messaging::QueueOrderPolicy_var::operator= (QueueOrderPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::QueueOrderPolicy_var &
Messaging::QueueOrderPolicy_var::operator= (const ::Messaging::QueueOrderPolicy_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::QueueOrderPolicy_var::operator const ::Messaging::QueueOrderPolicy_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::QueueOrderPolicy_var::operator ::Messaging::QueueOrderPolicy_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::in (void) const
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_var::inout (void)
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::QueueOrderPolicy_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
  return val;
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::tao_duplicate (QueueOrderPolicy_ptr p)
{
  return ::Messaging::QueueOrderPolicy::_duplicate (p);
}

void
Messaging::QueueOrderPolicy_var::tao_release (QueueOrderPolicy_ptr p)
{
  CORBA::release (p);
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::tao_nil (void)
{
  return ::Messaging::QueueOrderPolicy::_nil ();
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::QueueOrderPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::QueueOrderPolicy_var::tao_upcast (void *src)
{
  QueueOrderPolicy **tmp =
    ACE_static_cast (QueueOrderPolicy **, src);
  return *tmp;
}

// *************************************************************
// Messaging::QueueOrderPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (QueueOrderPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
}

Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (QueueOrderPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::QueueOrderPolicy::_nil ();
}

Messaging::QueueOrderPolicy_out::QueueOrderPolicy_out (const ::Messaging::QueueOrderPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (QueueOrderPolicy_out &, p).ptr_)
{}

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

Messaging::QueueOrderPolicy_out &
Messaging::QueueOrderPolicy_out::operator= (const ::Messaging::QueueOrderPolicy_var &p)
{
  this->ptr_ = ::Messaging::QueueOrderPolicy::_duplicate (p.ptr ());
  return *this;
}

Messaging::QueueOrderPolicy_out &
Messaging::QueueOrderPolicy_out::operator= (QueueOrderPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::QueueOrderPolicy_out::operator ::Messaging::QueueOrderPolicy_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr &
Messaging::QueueOrderPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy_out::operator-> (void)
{
  return this->ptr_;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::QueueOrderPolicy::QueueOrderPolicy (void)
{}

Messaging::QueueOrderPolicy::~QueueOrderPolicy (void)
{}

void Messaging::QueueOrderPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  QueueOrderPolicy *tmp = ACE_static_cast (QueueOrderPolicy*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::QueueOrderPolicy_ptr Messaging::QueueOrderPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return QueueOrderPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::QueueOrderPolicy_ptr 
Messaging::QueueOrderPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return QueueOrderPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          QueueOrderPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &QueueOrderPolicy::_tao_class_id
                  )
              )
        );
}

Messaging::QueueOrderPolicy_ptr
Messaging::QueueOrderPolicy::_duplicate (QueueOrderPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *Messaging::QueueOrderPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, QueueOrderPolicy)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::QueueOrderPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/QueueOrderPolicy:1.0";
}

static const CORBA::Long _oc_Messaging_QueueOrderPolicy[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5175), 
  ACE_NTOHL (0x6575654f), 
  ACE_NTOHL (0x72646572), 
  ACE_NTOHL (0x506f6c69), 
  ACE_NTOHL (0x63793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/QueueOrderPolicy:1.0
  17,
  ACE_NTOHL (0x51756575), 
  ACE_NTOHL (0x654f7264), 
  ACE_NTOHL (0x6572506f), 
  ACE_NTOHL (0x6c696379), 
  ACE_NTOHL (0x0),  // name = QueueOrderPolicy
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_QueueOrderPolicy (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_QueueOrderPolicy),
    (char *) &_oc_Messaging_QueueOrderPolicy,
    0,
    sizeof (Messaging::QueueOrderPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_QueueOrderPolicy, &_tc_TAO_tc_Messaging_QueueOrderPolicy)
TAO_NAMESPACE_END



#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)

static const CORBA::Long _oc_Messaging_ExceptionHolder[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f4578), 
  ACE_NTOHL (0x63657074), 
  ACE_NTOHL (0x696f6e48), 
  ACE_NTOHL (0x6f6c6465), 
  ACE_NTOHL (0x723a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/Messaging/ExceptionHolder:1.0
  16,
  ACE_NTOHL (0x45786365), 
  ACE_NTOHL (0x7074696f), 
  ACE_NTOHL (0x6e486f6c), 
  ACE_NTOHL (0x64657200),  // name = ExceptionHolder
  0, // value modifier
  CORBA::tk_null, // no stateful base valuetype

  3, // member count
  20,
  ACE_NTOHL (0x69735f73), 
  ACE_NTOHL (0x79737465), 
  ACE_NTOHL (0x6d5f6578), 
  ACE_NTOHL (0x63657074), 
  ACE_NTOHL (0x696f6e00),  // name = is_system_exception
  CORBA::tk_boolean,

  1, // data memeber visibility marker

  11,
  ACE_NTOHL (0x62797465), 
  ACE_NTOHL (0x5f6f7264), 
  ACE_NTOHL (0x65720000),  // name = byte_order
  CORBA::tk_boolean,

  1, // data memeber visibility marker

  20,
  ACE_NTOHL (0x6d617273), 
  ACE_NTOHL (0x68616c65), 
  ACE_NTOHL (0x645f6578), 
  ACE_NTOHL (0x63657074), 
  ACE_NTOHL (0x696f6e00),  // name = marshaled_exception
  CORBA::tk_sequence, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_octet,

    0U,

  1, // data memeber visibility marker

};

static CORBA::TypeCode _tc_TAO_tc_Messaging_ExceptionHolder (
    CORBA::tk_value,
    sizeof (_oc_Messaging_ExceptionHolder),
    (char *) &_oc_Messaging_ExceptionHolder,
    0,
    sizeof (Messaging::ExceptionHolder)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ExceptionHolder, &_tc_TAO_tc_Messaging_ExceptionHolder)
TAO_NAMESPACE_END

void
tao_Messaging_ExceptionHolder_add_ref (
    Messaging::ExceptionHolder *p
  )
{
  CORBA::add_ref (p);
}

void
tao_Messaging_ExceptionHolder_remove_ref (
    Messaging::ExceptionHolder *p
  )
{
  CORBA::remove_ref (p);
}

// *************************************************************
// Operations for class Messaging::ExceptionHolder_var
// *************************************************************

Messaging::ExceptionHolder_var::ExceptionHolder_var (void) // default constructor
  : ptr_ (0)
{}

Messaging::ExceptionHolder_var::ExceptionHolder_var (ExceptionHolder* p)
  : ptr_ (p)
{}

Messaging::ExceptionHolder_var::ExceptionHolder_var (const ExceptionHolder* p)
  : ptr_ (ACE_const_cast(ExceptionHolder*, p))
{}

Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::ExceptionHolder_var::ExceptionHolder_var (const ExceptionHolder_var &p) // copy constructor
{
  CORBA::add_ref (p.ptr ());
  this->ptr_ = p.ptr ();
}

Messaging::ExceptionHolder_var::~ExceptionHolder_var (void) // destructor
{
  CORBA::remove_ref (this->ptr_);
}

Messaging::ExceptionHolder_var &
Messaging::ExceptionHolder_var::operator= (ExceptionHolder* p)
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::ExceptionHolder_var &
Messaging::ExceptionHolder_var::operator= (const ExceptionHolder_var &p)
{
  if (this != &p)
  {
    CORBA::remove_ref (this->ptr_);
    ExceptionHolder* tmp = p.ptr ();
    CORBA::add_ref (tmp);
    this->ptr_ = tmp;
  }
  return *this;
}

Messaging::ExceptionHolder_var::operator const Messaging::ExceptionHolder* () const // cast
{
  return this->ptr_;
}

Messaging::ExceptionHolder_var::operator Messaging::ExceptionHolder* () // cast 
{
  return this->ptr_;
}

Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::operator-> (void) const
{
  return this->ptr_;
}

Messaging::ExceptionHolder*
Messaging::ExceptionHolder_var::in (void) const
{
  return this->ptr_;
}

Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_var::inout (void)
{
  return this->ptr_;
}

Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_var::out (void)
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = 0;
  return this->ptr_;
}

Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_var::_retn (void)
{
  // yield ownership of managed obj reference
  ExceptionHolder* tmp = this->ptr_;
  this->ptr_ = 0;
  return tmp;
}

void
Messaging::ExceptionHolder_var::tao_add_ref (
    ExceptionHolder *p
  )
{
  CORBA::add_ref (p);
}

void
Messaging::ExceptionHolder_var::tao_remove_ref (
    ExceptionHolder *p
  )
{
  CORBA::remove_ref (p);
}

// *************************************************************
// Operations for class Messaging::ExceptionHolder_out
// *************************************************************

Messaging::ExceptionHolder_out::ExceptionHolder_out (ExceptionHolder* &p)
  : ptr_ (p)
{
  this->ptr_ = 0;
}

Messaging::ExceptionHolder_out::ExceptionHolder_out (ExceptionHolder_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::remove_ref (this->ptr_);
  this->ptr_ = 0;
}

Messaging::ExceptionHolder_out::ExceptionHolder_out (const ExceptionHolder_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ExceptionHolder_out&,p).ptr_)
{}

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

Messaging::ExceptionHolder_out &
Messaging::ExceptionHolder_out::operator= (const ExceptionHolder_var &p)
{
  ExceptionHolder* tmp = p.ptr ();
  CORBA::add_ref (tmp);
  this->ptr_ = tmp;
  return *this;
}

Messaging::ExceptionHolder_out &
Messaging::ExceptionHolder_out::operator= (ExceptionHolder* p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::ExceptionHolder_out::operator Messaging::ExceptionHolder* &() // cast
{
  return this->ptr_;
}

Messaging::ExceptionHolder* &
Messaging::ExceptionHolder_out::ptr (void) // ptr
{
  return this->ptr_;
}

Messaging::ExceptionHolder* 
Messaging::ExceptionHolder_out::operator-> (void)
{
  return this->ptr_;
}


Messaging::ExceptionHolder* Messaging::ExceptionHolder::_downcast (CORBA::ValueBase* v)
{
  if (v == 0) return 0;
  return (ExceptionHolder* ) v->_tao_obv_narrow ((ptr_arith_t) &_downcast);
}

const char* Messaging::ExceptionHolder::_tao_obv_repository_id () const
{
  return this->_tao_obv_static_repository_id ();
}

void* Messaging::ExceptionHolder::_tao_obv_narrow (ptr_arith_t type_id)
{
  if (type_id == (ptr_arith_t) &_downcast)
    return this;
  void *rval = 0;
  return rval;
}

void
Messaging::ExceptionHolder::_tao_any_destructor (void *_tao_void_pointer)
{
  ExceptionHolder *tmp = ACE_static_cast (ExceptionHolder*, _tao_void_pointer);
  delete tmp;
}

CORBA::Boolean Messaging::ExceptionHolder::_tao_marshal_v (TAO_OutputCDR & strm)
{
  return this->_tao_marshal__Messaging_ExceptionHolder (strm);
}

CORBA::Boolean Messaging::ExceptionHolder::_tao_unmarshal_v (TAO_InputCDR & strm)
{
  return this->_tao_unmarshal__Messaging_ExceptionHolder (strm);
}

CORBA::Boolean Messaging::ExceptionHolder::_tao_unmarshal (
    TAO_InputCDR &strm, 
    ExceptionHolder *&new_object
  )
{
  CORBA::ValueBase *base;
  CORBA::ValueFactory_var factory;
  CORBA::Boolean retval = 
    CORBA::ValueBase::_tao_unmarshal_pre (
        strm, 
        factory.out (), 
        base,
        ExceptionHolder::_tao_obv_static_repository_id ()
      );

  if (retval == 0 || factory.in () == 0)
    {
      return 0;
    }

  base = factory->create_for_unmarshal ();

  if (base == 0)
    {
      return 0;  // %! except.?
    }

  retval = base->_tao_unmarshal_v (strm);

  if (!retval) 
    {
      return 0;
    }

  // Now base must be null or point to the unmarshaled object.
  // Align the pointer to the right subobject.
  new_object = ExceptionHolder::_downcast (base);
  return retval;
}

Messaging::ExceptionHolder_init::ExceptionHolder_init ()
{
}

Messaging::ExceptionHolder_init::~ExceptionHolder_init ()
{
}

const char* 
Messaging::ExceptionHolder_init::tao_repository_id (void)
{
  return Messaging::ExceptionHolder::_tao_obv_static_repository_id ();
}

CORBA_ValueBase* 
Messaging::ExceptionHolder_init::create_for_unmarshal (void)
{
  CORBA_ValueBase* ret_val = 0;
  ACE_NEW_RETURN(ret_val, 
                 OBV_Messaging::ExceptionHolder, 
                 0);
  return ret_val;
}

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:67

int Messaging::ReplyHandler::_tao_class_id = 0;

Messaging::ReplyHandler_ptr
tao_Messaging_ReplyHandler_duplicate (
    Messaging::ReplyHandler_ptr p
  )
{
  return Messaging::ReplyHandler::_duplicate (p);
}

void
tao_Messaging_ReplyHandler_release (
    Messaging::ReplyHandler_ptr p
  )
{
  CORBA::release (p);
}

Messaging::ReplyHandler_ptr
tao_Messaging_ReplyHandler_nil (
    void
  )
{
  return Messaging::ReplyHandler::_nil ();
}

Messaging::ReplyHandler_ptr
tao_Messaging_ReplyHandler_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return Messaging::ReplyHandler::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_Messaging_ReplyHandler_upcast (
    void *src
  )
{
  Messaging::ReplyHandler **tmp =
    ACE_static_cast (Messaging::ReplyHandler **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyHandler_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

Messaging::ReplyHandler_var::ReplyHandler_var (void) // default constructor
  : ptr_ (ReplyHandler::_nil ())
{}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::ptr (void) const
{
  return this->ptr_;
}

Messaging::ReplyHandler_var::ReplyHandler_var (const ::Messaging::ReplyHandler_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ReplyHandler::_duplicate (p.ptr ()))
{}

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

Messaging::ReplyHandler_var &
Messaging::ReplyHandler_var::operator= (ReplyHandler_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyHandler_var &
Messaging::ReplyHandler_var::operator= (const ::Messaging::ReplyHandler_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::Messaging::ReplyHandler::_duplicate (p.ptr ());
  }
  return *this;
}

Messaging::ReplyHandler_var::operator const ::Messaging::ReplyHandler_ptr &() const // cast
{
  return this->ptr_;
}

Messaging::ReplyHandler_var::operator ::Messaging::ReplyHandler_ptr &() // cast 
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::operator-> (void) const
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::in (void) const
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_var::inout (void)
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::Messaging::ReplyHandler_ptr val = this->ptr_;
  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
  return val;
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::tao_duplicate (ReplyHandler_ptr p)
{
  return ::Messaging::ReplyHandler::_duplicate (p);
}

void
Messaging::ReplyHandler_var::tao_release (ReplyHandler_ptr p)
{
  CORBA::release (p);
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::tao_nil (void)
{
  return ::Messaging::ReplyHandler::_nil ();
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::Messaging::ReplyHandler::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
Messaging::ReplyHandler_var::tao_upcast (void *src)
{
  ReplyHandler **tmp =
    ACE_static_cast (ReplyHandler **, src);
  return *tmp;
}

// *************************************************************
// Messaging::ReplyHandler_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

Messaging::ReplyHandler_out::ReplyHandler_out (ReplyHandler_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
}

Messaging::ReplyHandler_out::ReplyHandler_out (ReplyHandler_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::Messaging::ReplyHandler::_nil ();
}

Messaging::ReplyHandler_out::ReplyHandler_out (const ::Messaging::ReplyHandler_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ReplyHandler_out &, p).ptr_)
{}

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

Messaging::ReplyHandler_out &
Messaging::ReplyHandler_out::operator= (const ::Messaging::ReplyHandler_var &p)
{
  this->ptr_ = ::Messaging::ReplyHandler::_duplicate (p.ptr ());
  return *this;
}

Messaging::ReplyHandler_out &
Messaging::ReplyHandler_out::operator= (ReplyHandler_ptr p)
{
  this->ptr_ = p;
  return *this;
}

Messaging::ReplyHandler_out::operator ::Messaging::ReplyHandler_ptr &() // cast
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr &
Messaging::ReplyHandler_out::ptr (void) // ptr
{
  return this->ptr_;
}

::Messaging::ReplyHandler_ptr
Messaging::ReplyHandler_out::operator-> (void)
{
  return this->ptr_;
}


#if (TAO_HAS_INTERCEPTORS == 1)
#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//                Base & Remote Proxy  Implementation. 
//

Messaging::_TAO_ReplyHandler_Proxy_Impl::_TAO_ReplyHandler_Proxy_Impl (void)
{}

Messaging::_TAO_ReplyHandler_Remote_Proxy_Impl::_TAO_ReplyHandler_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods


//
//            End  Base & Remote  Proxy Implemeentation. 
///////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////
//           Remote & Base  Proxy Broker Implementation
//

Messaging::_TAO_ReplyHandler_Proxy_Broker::_TAO_ReplyHandler_Proxy_Broker (void)
{
}

Messaging::_TAO_ReplyHandler_Proxy_Broker::~_TAO_ReplyHandler_Proxy_Broker (void)
{
}

Messaging::_TAO_ReplyHandler_Proxy_Broker * (*Messaging__TAO_ReplyHandler_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker *
Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker::the_TAO_ReplyHandler_Remote_Proxy_Broker (void)
{
  static ::Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker::_TAO_ReplyHandler_Remote_Proxy_Broker (void)
{
}

Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker::~_TAO_ReplyHandler_Remote_Proxy_Broker (void)
{
}

Messaging::_TAO_ReplyHandler_Proxy_Impl&
Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker::select_proxy (
  ::Messaging::ReplyHandler *
  ACE_ENV_ARG_DECL_NOT_USED
)
{
  return this->remote_proxy_impl_;
}


//
//           End Remote & Base Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////


// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_cs.cpp:198

Messaging::ReplyHandler::ReplyHandler (int collocated)
{
  this->Messaging_ReplyHandler_setup_collocation (collocated);
}

Messaging::ReplyHandler::~ReplyHandler (void)
{}

void
Messaging::ReplyHandler::Messaging_ReplyHandler_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_ReplyHandler_Proxy_Broker_ =
      ::Messaging__TAO_ReplyHandler_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_ReplyHandler_Proxy_Broker_ =
      ::Messaging::_TAO_ReplyHandler_Remote_Proxy_Broker::the_TAO_ReplyHandler_Remote_Proxy_Broker ();
}

void Messaging::ReplyHandler::_tao_any_destructor (void *_tao_void_pointer)
{
  ReplyHandler *tmp = ACE_static_cast (ReplyHandler*, _tao_void_pointer);
  CORBA::release (tmp);
}

Messaging::ReplyHandler_ptr Messaging::ReplyHandler::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    return ReplyHandler::_nil ();
  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/Messaging/ReplyHandler:1.0" ACE_ENV_ARG_PARAMETER);
      ACE_CHECK_RETURN (ReplyHandler::_nil ());
      if (is_a == 0)
        return ReplyHandler::_nil ();
    }
  return ReplyHandler::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

Messaging::ReplyHandler_ptr 
Messaging::ReplyHandler::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ReplyHandler::_nil ();
  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();
      if (stub)
        stub->_incr_refcnt ();
      ReplyHandler_ptr default_proxy = ReplyHandler::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          Messaging__TAO_ReplyHandler_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::Messaging::ReplyHandler (
                  stub,
                  1,
                  obj->_servant ()
                ),
              ReplyHandler::_nil ()
            );
        }
      
      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::Messaging::ReplyHandler (
                  stub,
                  0,
                  obj->_servant ()
                ),
              ReplyHandler::_nil ()
            );
        }
      
      return default_proxy;
    }
  else 
    return
      ACE_reinterpret_cast
        (
          ReplyHandler_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ReplyHandler::_tao_class_id
                  )
              )
        );
}

Messaging::ReplyHandler_ptr
Messaging::ReplyHandler::_duplicate (ReplyHandler_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

CORBA::Boolean Messaging::ReplyHandler::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
{
  if (
    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/Messaging/ReplyHandler: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_ENV_ARG_PARAMETER);
}

void *Messaging::ReplyHandler::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::Messaging, ReplyHandler)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

const char* Messaging::ReplyHandler::_interface_repository_id (void) const
{
  return "IDL:omg.org/Messaging/ReplyHandler:1.0";
}

static const CORBA::Long _oc_Messaging_ReplyHandler[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x4d657373), 
  ACE_NTOHL (0x6167696e), 
  ACE_NTOHL (0x672f5265), 
  ACE_NTOHL (0x706c7948), 
  ACE_NTOHL (0x616e646c), 
  ACE_NTOHL (0x65723a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/Messaging/ReplyHandler:1.0
  13,
  ACE_NTOHL (0x5265706c), 
  ACE_NTOHL (0x7948616e), 
  ACE_NTOHL (0x646c6572), 
  ACE_NTOHL (0x0),  // name = ReplyHandler
};

static CORBA::TypeCode _tc_TAO_tc_Messaging_ReplyHandler (
    CORBA::tk_objref,
    sizeof (_oc_Messaging_ReplyHandler),
    (char *) &_oc_Messaging_ReplyHandler,
    0,
    sizeof (Messaging::ReplyHandler)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (Messaging)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ReplyHandler, &_tc_TAO_tc_Messaging_ReplyHandler)
TAO_NAMESPACE_END


#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */

#if (TAO_HAS_AMI_CALLBACK == 1)

CORBA::Boolean 
OBV_Messaging::ExceptionHolder::_tao_marshal__Messaging_ExceptionHolder (TAO_OutputCDR &strm){
  return _tao_marshal_state (strm);
  
}
CORBA::Boolean OBV_Messaging::ExceptionHolder::_tao_unmarshal__Messaging_ExceptionHolder (TAO_InputCDR &strm){
  return _tao_unmarshal_state (strm);
  
}
// accessor to set the member
void
OBV_Messaging::ExceptionHolder::is_system_exception (CORBA::Boolean val) // set
{
  // set the value
  this->_pd_is_system_exception = val;
}
// retrieve the member
CORBA::Boolean
OBV_Messaging::ExceptionHolder::is_system_exception (void) const
{
  return this->_pd_is_system_exception;
}

// accessor to set the member
void
OBV_Messaging::ExceptionHolder::byte_order (CORBA::Boolean val) // set
{
  // set the value
  this->_pd_byte_order = val;
}
// retrieve the member
CORBA::Boolean
OBV_Messaging::ExceptionHolder::byte_order (void) const
{
  return this->_pd_byte_order;
}


#if !defined (_MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_)
#define _MESSAGING_EXCEPTIONHOLDER__TAO_SEQ_OCTET_CS_

// *************************************************************
// Messaging::ExceptionHolder::_tao_seq_Octet
// *************************************************************

Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (void)
{}
Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (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)
{}
Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (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)
{}
Messaging::ExceptionHolder::_tao_seq_Octet::_tao_seq_Octet (const _tao_seq_Octet &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)
{}
Messaging::ExceptionHolder::_tao_seq_Octet::~_tao_seq_Octet (void) // dtor
{}
void Messaging::ExceptionHolder::_tao_seq_Octet::_tao_any_destructor (void *_tao_void_pointer)
{
  _tao_seq_Octet *tmp = ACE_static_cast (_tao_seq_Octet*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

// accessor to set the member
void
OBV_Messaging::ExceptionHolder::marshaled_exception (const Messaging::ExceptionHolder::_tao_seq_Octet &val)
{
  this->_pd_marshaled_exception = val;
}

// readonly get method 
const Messaging::ExceptionHolder::_tao_seq_Octet &
OBV_Messaging::ExceptionHolder::marshaled_exception (void) const
{
  return this->_pd_marshaled_exception;
}

// read/write get method 
Messaging::ExceptionHolder::_tao_seq_Octet &
OBV_Messaging::ExceptionHolder::marshaled_exception (void)
{
  return this->_pd_marshaled_exception;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RebindPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RebindPolicy, 
      1,
      Messaging::RebindPolicy::_duplicate (_tao_elem),
      Messaging::RebindPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RebindPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RebindPolicy, 
      1,
      *_tao_elem,
      Messaging::RebindPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RebindPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RebindPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RebindPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RebindPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RebindPolicy::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RebindPolicy,Messaging::RebindPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RebindPolicy,Messaging::RebindPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::SyncScopePolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_SyncScopePolicy, 
      1,
      Messaging::SyncScopePolicy::_duplicate (_tao_elem),
      Messaging::SyncScopePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::SyncScopePolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_SyncScopePolicy, 
      1,
      *_tao_elem,
      Messaging::SyncScopePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::SyncScopePolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::SyncScopePolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_SyncScopePolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::SyncScopePolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::SyncScopePolicy::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::SyncScopePolicy,Messaging::SyncScopePolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::SyncScopePolicy,Messaging::SyncScopePolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#endif /* TAO_HAS_AMI_CALLBACK == 1 */

#if (TAO_HAS_PRIORITY_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:58

// Copying insertion.
TAO_Messaging_Export
void operator<<= (
    CORBA::Any &_tao_any,
    const Messaging::PriorityRange &_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << _tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_PriorityRange,
          TAO_ENCAP_BYTE_ORDER,
          stream.begin ()
        );
    }
}

// Non-copying insertion.
TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::PriorityRange *_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << *_tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_PriorityRange,
          TAO_ENCAP_BYTE_ORDER,
          stream.begin (),
          1,
          _tao_elem,
          Messaging::PriorityRange::_tao_any_destructor
        );
    }
}

// Extraction to non-const pointer (deprecated).
TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::PriorityRange *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast (
      const Messaging::PriorityRange *&,
      _tao_elem
    );
}

// Extraction to const pointer.
TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const Messaging::PriorityRange *&_tao_elem
  )
{
  _tao_elem = 0;
  
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_PriorityRange
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (result == 0)
      {
        return 0; // not equivalent
      }
    
    if (_tao_any.any_owns_data ())
      {
        _tao_elem = ACE_static_cast (
            const Messaging::PriorityRange*,
            _tao_any.value ()
          );
        
        return 1;
      }
    else
      {
        Messaging::PriorityRange *tmp;
        ACE_NEW_RETURN (
            tmp,
            Messaging::PriorityRange,
            0
          );
        
        TAO_InputCDR stream (
            _tao_any._tao_get_cdr (),
            _tao_any._tao_byte_order ()
          );
        
        if (stream >> *tmp)
          {
            ((CORBA::Any *)&_tao_any)->_tao_replace (
                Messaging::_tc_PriorityRange,
                1,
                ACE_static_cast (void *, tmp),
                Messaging::PriorityRange::_tao_any_destructor
              );
            
            _tao_elem = tmp;
            return 1;
          }
        else
          {
            delete tmp;
          }
      }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  
  return 0;
}

#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */

#if (TAO_HAS_REQUEST_PRIORITY_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestPriorityPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestPriorityPolicy, 
      1,
      Messaging::RequestPriorityPolicy::_duplicate (_tao_elem),
      Messaging::RequestPriorityPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestPriorityPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestPriorityPolicy, 
      1,
      *_tao_elem,
      Messaging::RequestPriorityPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RequestPriorityPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RequestPriorityPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RequestPriorityPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RequestPriorityPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RequestPriorityPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REQUEST_PRIORITY_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RequestPriorityPolicy,Messaging::RequestPriorityPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RequestPriorityPolicy,Messaging::RequestPriorityPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_REPLY_PRIORITY_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyPriorityPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyPriorityPolicy, 
      1,
      Messaging::ReplyPriorityPolicy::_duplicate (_tao_elem),
      Messaging::ReplyPriorityPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyPriorityPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyPriorityPolicy, 
      1,
      *_tao_elem,
      Messaging::ReplyPriorityPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::ReplyPriorityPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::ReplyPriorityPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_ReplyPriorityPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::ReplyPriorityPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::ReplyPriorityPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REPLY_PRIORITY_POLICIES == 1 */


#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::ReplyPriorityPolicy,Messaging::ReplyPriorityPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::ReplyPriorityPolicy,Messaging::ReplyPriorityPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_REQUEST_START_TIME_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestStartTimePolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestStartTimePolicy, 
      1,
      Messaging::RequestStartTimePolicy::_duplicate (_tao_elem),
      Messaging::RequestStartTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestStartTimePolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestStartTimePolicy, 
      1,
      *_tao_elem,
      Messaging::RequestStartTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RequestStartTimePolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RequestStartTimePolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RequestStartTimePolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RequestStartTimePolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RequestStartTimePolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REQUEST_START_TIME_POLICIES == 1 */


#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RequestStartTimePolicy,Messaging::RequestStartTimePolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RequestStartTimePolicy,Messaging::RequestStartTimePolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_REQUEST_END_TIME_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestEndTimePolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestEndTimePolicy, 
      1,
      Messaging::RequestEndTimePolicy::_duplicate (_tao_elem),
      Messaging::RequestEndTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RequestEndTimePolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RequestEndTimePolicy, 
      1,
      *_tao_elem,
      Messaging::RequestEndTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RequestEndTimePolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RequestEndTimePolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RequestEndTimePolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RequestEndTimePolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RequestEndTimePolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REQUEST_END_TIME_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RequestEndTimePolicy,Messaging::RequestEndTimePolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RequestEndTimePolicy,Messaging::RequestEndTimePolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_REPLY_START_TIME_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyStartTimePolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyStartTimePolicy, 
      1,
      Messaging::ReplyStartTimePolicy::_duplicate (_tao_elem),
      Messaging::ReplyStartTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyStartTimePolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyStartTimePolicy, 
      1,
      *_tao_elem,
      Messaging::ReplyStartTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::ReplyStartTimePolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::ReplyStartTimePolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_ReplyStartTimePolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::ReplyStartTimePolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::ReplyStartTimePolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REPLY_START_TIME_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::ReplyStartTimePolicy,Messaging::ReplyStartTimePolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::ReplyStartTimePolicy,Messaging::ReplyStartTimePolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_REPLY_END_TIME_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyEndTimePolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyEndTimePolicy, 
      1,
      Messaging::ReplyEndTimePolicy::_duplicate (_tao_elem),
      Messaging::ReplyEndTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyEndTimePolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_ReplyEndTimePolicy, 
      1,
      *_tao_elem,
      Messaging::ReplyEndTimePolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::ReplyEndTimePolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::ReplyEndTimePolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_ReplyEndTimePolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::ReplyEndTimePolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::ReplyEndTimePolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_REPLY_END_TIME_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::ReplyEndTimePolicy,Messaging::ReplyEndTimePolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::ReplyEndTimePolicy,Messaging::ReplyEndTimePolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_RELATIVE_REQ_TIMEOUT_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RelativeRequestTimeoutPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RelativeRequestTimeoutPolicy, 
      1,
      Messaging::RelativeRequestTimeoutPolicy::_duplicate (_tao_elem),
      Messaging::RelativeRequestTimeoutPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RelativeRequestTimeoutPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RelativeRequestTimeoutPolicy, 
      1,
      *_tao_elem,
      Messaging::RelativeRequestTimeoutPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RelativeRequestTimeoutPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RelativeRequestTimeoutPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RelativeRequestTimeoutPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RelativeRequestTimeoutPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_RELATIVE_REQ_TIMEOUT_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RelativeRequestTimeoutPolicy,Messaging::RelativeRequestTimeoutPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RelativeRequestTimeoutPolicy,Messaging::RelativeRequestTimeoutPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_RELATIVE_RT_TIMEOUT_POLICIES == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RelativeRoundtripTimeoutPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RelativeRoundtripTimeoutPolicy, 
      1,
      Messaging::RelativeRoundtripTimeoutPolicy::_duplicate (_tao_elem),
      Messaging::RelativeRoundtripTimeoutPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RelativeRoundtripTimeoutPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RelativeRoundtripTimeoutPolicy, 
      1,
      *_tao_elem,
      Messaging::RelativeRoundtripTimeoutPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RelativeRoundtripTimeoutPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RelativeRoundtripTimeoutPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RelativeRoundtripTimeoutPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RelativeRoundtripTimeoutPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_RELATIVE_RT_TIMEOUT_POLICIES == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RelativeRoundtripTimeoutPolicy,Messaging::RelativeRoundtripTimeoutPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RelativeRoundtripTimeoutPolicy,Messaging::RelativeRoundtripTimeoutPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_ROUTING_POLICY == 1)

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:58

// Copying insertion.
TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    const Messaging::RoutingTypeRange &_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << _tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_RoutingTypeRange,
          TAO_ENCAP_BYTE_ORDER,
          stream.begin ()
        );
    }
}

// Non-copying insertion.
TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RoutingTypeRange *_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << *_tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_RoutingTypeRange,
          TAO_ENCAP_BYTE_ORDER,
          stream.begin (),
          1,
          _tao_elem,
          Messaging::RoutingTypeRange::_tao_any_destructor
        );
    }
}

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RoutingTypeRange *&_tao_elem
  )
{
  return _tao_any >>= ACE_const_cast (
      const Messaging::RoutingTypeRange *&,
      _tao_elem
    );
}

// Extraction to const pointer.
TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const Messaging::RoutingTypeRange *&_tao_elem
  )
{
  _tao_elem = 0;
  
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RoutingTypeRange
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (result == 0)
      {
        return 0; // not equivalent
      }
    
    if (_tao_any.any_owns_data ())
      {
        _tao_elem = ACE_static_cast (
            const Messaging::RoutingTypeRange*,
            _tao_any.value ()
          );
        
        return 1;
      }
    else
      {
        Messaging::RoutingTypeRange *tmp;
        ACE_NEW_RETURN (
            tmp,
            Messaging::RoutingTypeRange,
            0
          );
        
        TAO_InputCDR stream (
            _tao_any._tao_get_cdr (),
            _tao_any._tao_byte_order ()
          );
        
        if (stream >> *tmp)
          {
            ((CORBA::Any *)&_tao_any)->_tao_replace (
                Messaging::_tc_RoutingTypeRange,
                1,
                ACE_static_cast (void *, tmp),
                Messaging::RoutingTypeRange::_tao_any_destructor
              );
            
            _tao_elem = tmp;
            return 1;
          }
        else
          {
            delete tmp;
          }
      }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  
  return 0;
}


// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RoutingPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RoutingPolicy, 
      1,
      Messaging::RoutingPolicy::_duplicate (_tao_elem),
      Messaging::RoutingPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::RoutingPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_RoutingPolicy, 
      1,
      *_tao_elem,
      Messaging::RoutingPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::RoutingPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::RoutingPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_RoutingPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::RoutingPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::RoutingPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_ROUTING_POLICY == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::RoutingPolicy,Messaging::RoutingPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::RoutingPolicy,Messaging::RoutingPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_MAX_HOPS_POLICY == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::MaxHopsPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_MaxHopsPolicy, 
      1,
      Messaging::MaxHopsPolicy::_duplicate (_tao_elem),
      Messaging::MaxHopsPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::MaxHopsPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_MaxHopsPolicy, 
      1,
      *_tao_elem,
      Messaging::MaxHopsPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::MaxHopsPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::MaxHopsPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_MaxHopsPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::MaxHopsPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::MaxHopsPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_MAX_HOPS_POLICY == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::MaxHopsPolicy,Messaging::MaxHopsPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::MaxHopsPolicy,Messaging::MaxHopsPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_QUEUE_ORDER_POLICY == 1)

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::QueueOrderPolicy_ptr _tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_QueueOrderPolicy, 
      1,
      Messaging::QueueOrderPolicy::_duplicate (_tao_elem),
      Messaging::QueueOrderPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::QueueOrderPolicy_ptr *_tao_elem
  )
{
  _tao_any._tao_replace (
      Messaging::_tc_QueueOrderPolicy, 
      1,
      *_tao_elem,
      Messaging::QueueOrderPolicy::_tao_any_destructor
    );
  
  _tao_any.contains_local (1);
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::QueueOrderPolicy_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::QueueOrderPolicy::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_QueueOrderPolicy
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    _tao_elem =
      ACE_reinterpret_cast (
          Messaging::QueueOrderPolicy_ptr,
          ACE_const_cast (void *, _tao_any.value ())
        );
    
    return 1;
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  _tao_elem = Messaging::QueueOrderPolicy::_nil ();
  return 0;
}

#endif /* TAO_HAS_QUEUE_ORDER_POLICY == 1 */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::QueueOrderPolicy,Messaging::QueueOrderPolicy_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::QueueOrderPolicy,Messaging::QueueOrderPolicy_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1)

TAO_Messaging_Export void
operator<<= (CORBA::Any &any, Messaging::ExceptionHolder *value) // copying
{
  TAO_OutputCDR stream;
  if (stream << value)
  {
    any._tao_replace (
        Messaging::_tc_ExceptionHolder, 
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ());
  }
}

TAO_Messaging_Export void
operator<<= (CORBA::Any &any, Messaging::ExceptionHolder **value) // non-copying
{
  TAO_OutputCDR stream;
  if (stream << *value)
  {
    any._tao_replace (
        Messaging::_tc_ExceptionHolder, 
        TAO_ENCAP_BYTE_ORDER,
        stream.begin (),
        1,
        *value,
        Messaging::ExceptionHolder::_tao_any_destructor);
  }
}

TAO_Messaging_Export CORBA::Boolean
operator>>= (const CORBA::Any &any, Messaging::ExceptionHolder *&value)
{
  ACE_TRY_NEW_ENV
  {
    value = 0;
    CORBA::TypeCode_var type = any.type ();
    
    CORBA::Boolean result = type->equivalent (Messaging::_tc_ExceptionHolder ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
    {
      return 0; // not equivalent
    }
    if (any.any_owns_data ())
    {
      const Messaging::ExceptionHolder *const_holder = ACE_static_cast (
          const Messaging::ExceptionHolder*,
          any.value ());
      value = ACE_const_cast (
          Messaging::ExceptionHolder*,
          const_holder);
      return 1;
    }
    else
    {
      Messaging::ExceptionHolder *tmp;
      TAO_InputCDR stream (
          any._tao_get_cdr (),
          any._tao_byte_order ());
      if (stream >> tmp)
      {
        ((CORBA::Any *)&any)->_tao_replace (
            Messaging::_tc_ExceptionHolder,
            1,
            ACE_static_cast (void *, tmp),
            Messaging::ExceptionHolder::_tao_any_destructor);
        value = tmp;
        return 1;
      }
      
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}


#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Valuetype_Manager<Messaging::ExceptionHolder, Messaging::ExceptionHolder_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Valuetype_Manager<Messaging::ExceptionHolder, Messaging::ExceptionHolder_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from 
// be/be_visitor_interface/any_op_cs.cpp:60

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyHandler_ptr _tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << _tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_ReplyHandler, 
          TAO_ENCAP_BYTE_ORDER,
          stream.begin (),
          1,
          Messaging::ReplyHandler::_duplicate (_tao_elem),
          Messaging::ReplyHandler::_tao_any_destructor
        );
    }
}

TAO_Messaging_Export void operator<<= (
    CORBA::Any &_tao_any,
    Messaging::ReplyHandler_ptr *_tao_elem
  )
{
  TAO_OutputCDR stream;
  
  if (stream << *_tao_elem)
    {
      _tao_any._tao_replace (
          Messaging::_tc_ReplyHandler, 
          TAO_ENCAP_BYTE_ORDER,
          stream.begin (),
          1,
          *_tao_elem,
          Messaging::ReplyHandler::_tao_any_destructor
        );
    }
}

TAO_Messaging_Export CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    Messaging::ReplyHandler_ptr &_tao_elem
  )
{
  ACE_TRY_NEW_ENV
  {
    _tao_elem = Messaging::ReplyHandler::_nil ();
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result =
      type->equivalent (
          Messaging::_tc_ReplyHandler
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    
    if (!result)
      {
        return 0; // not equivalent
      }
    
    TAO_InputCDR stream (
        _tao_any._tao_get_cdr (),
        _tao_any._tao_byte_order ()
      );
    
    if (stream >> _tao_elem)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            Messaging::_tc_ReplyHandler,
            1,
            _tao_elem,
            Messaging::ReplyHandler::_tao_any_destructor
          );
        
        return 1;
      }
  }
  ACE_CATCHANY
  {
    _tao_elem = Messaging::ReplyHandler::_nil ();
    return 0;
  }
  ACE_ENDTRY;
  
  _tao_elem = Messaging::ReplyHandler::_nil ();
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
#  pragma instantiate TAO_Object_Manager<Messaging::ReplyHandler,Messaging::ReplyHandler_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

//@@ Boris: begin experimental

void
CORBA::add_ref (Messaging::ExceptionHolder * vt)
{
  if (vt != 0)
  {
    vt->_add_ref ();
  }
}

void
CORBA::remove_ref (Messaging::ExceptionHolder * vt)
{
  if (vt != 0)
  {
    vt->_remove_ref ();
  }
}


//@@ Boris: end experimental
CORBA::Boolean
operator<< (TAO_OutputCDR &strm, const Messaging::ExceptionHolder *_tao_valuetype)
{
  return CORBA_ValueBase::_tao_marshal (strm,
    ACE_const_cast (Messaging::ExceptionHolder*, _tao_valuetype),
    (ptr_arith_t) &Messaging::ExceptionHolder::_downcast);
}

CORBA::Boolean
operator>> (TAO_InputCDR &strm, Messaging::ExceptionHolder *&_tao_valuetype)
{
  return Messaging::ExceptionHolder::_tao_unmarshal (strm, _tao_valuetype);
}

CORBA::Boolean
OBV_Messaging::ExceptionHolder::_tao_marshal_state (TAO_OutputCDR &strm)
{
  if (
    (strm << CORBA::Any::from_boolean (_pd_is_system_exception)) &&
    (strm << CORBA::Any::from_boolean (_pd_byte_order)) &&
    (strm << _pd_marshaled_exception)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean
OBV_Messaging::ExceptionHolder::_tao_unmarshal_state (TAO_InputCDR &strm)
{
  if (
    (strm >> CORBA::Any::to_boolean (_pd_is_system_exception)) &&
    (strm >> CORBA::Any::to_boolean (_pd_byte_order)) &&
    (strm >> _pd_marshaled_exception)
  )
    return 1;
  else
    return 0;
  
}

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const Messaging::ReplyHandler_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    Messaging::ReplyHandler_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 =
      Messaging::ReplyHandler::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */