// -*- C++ -*-
//
// RTCORBAC.cpp,v 1.6 2002/02/08 01:07:37 coryan Exp

// ****  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 "RTCORBA.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 "RTCORBAC.i"
#endif /* !defined INLINE */

//////////////////////////////////////////////////////
// CDR Encoding Support

CORBA::Boolean
RTCORBA::ProtocolProperties::_tao_encode (TAO_OutputCDR &)
{
  return 1;
}

CORBA::Boolean
RTCORBA::ProtocolProperties::_tao_decode (TAO_InputCDR &)
{
  return 1;
}

static const CORBA::Long _oc_RTCORBA_NativePriority[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x4e617469),
  ACE_NTOHL (0x76655072),
  ACE_NTOHL (0x696f7269),
  ACE_NTOHL (0x74793a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/RTCORBA/NativePriority:1.0
  15,
  ACE_NTOHL (0x4e617469),
  ACE_NTOHL (0x76655072),
  ACE_NTOHL (0x696f7269),
  ACE_NTOHL (0x74790000),  // name = NativePriority
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_NativePriority (
    CORBA::tk_alias,
    sizeof (_oc_RTCORBA_NativePriority),
    (char *) &_oc_RTCORBA_NativePriority,
    0,
    sizeof (RTCORBA::NativePriority)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_NativePriority, &_tc_TAO_tc_RTCORBA_NativePriority)
TAO_NAMESPACE_END

static const CORBA::Long _oc_RTCORBA_Priority[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  33,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/Priority:1.0
  9,
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x0),  // name = Priority
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_Priority (
    CORBA::tk_alias,
    sizeof (_oc_RTCORBA_Priority),
    (char *) &_oc_RTCORBA_Priority,
    0,
    sizeof (RTCORBA::Priority)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_Priority, &_tc_TAO_tc_RTCORBA_Priority)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::Short, minPriority, 0)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::Short, maxPriority, 32767)
TAO_NAMESPACE_END
static const CORBA::Long _oc_RTCORBA_ThreadpoolId[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4964),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/ThreadpoolId:1.0
  13,
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4964),
  ACE_NTOHL (0x0),  // name = ThreadpoolId
  CORBA::tk_ulong,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_ThreadpoolId (
    CORBA::tk_alias,
    sizeof (_oc_RTCORBA_ThreadpoolId),
    (char *) &_oc_RTCORBA_ThreadpoolId,
    0,
    sizeof (RTCORBA::ThreadpoolId)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ThreadpoolId, &_tc_TAO_tc_RTCORBA_ThreadpoolId)
TAO_NAMESPACE_END

static const CORBA::Long _oc_RTCORBA_ThreadpoolLane[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4c61),
  ACE_NTOHL (0x6e653a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/RTCORBA/ThreadpoolLane:1.0
  15,
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4c61),
  ACE_NTOHL (0x6e650000),  // name = ThreadpoolLane
  3, // member count
  14,
  ACE_NTOHL (0x6c616e65),
  ACE_NTOHL (0x5f707269),
  ACE_NTOHL (0x6f726974),
  ACE_NTOHL (0x79000000),  // name = lane_priority
  CORBA::tk_alias, // typecode kind for typedefs
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x5254434f),
    ACE_NTOHL (0x5242412f),
    ACE_NTOHL (0x5072696f),
    ACE_NTOHL (0x72697479),
    ACE_NTOHL (0x3a312e30),
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/Priority:1.0
    9,
    ACE_NTOHL (0x5072696f),
    ACE_NTOHL (0x72697479),
    ACE_NTOHL (0x0),  // name = Priority
    CORBA::tk_short,


  15,
  ACE_NTOHL (0x73746174),
  ACE_NTOHL (0x69635f74),
  ACE_NTOHL (0x68726561),
  ACE_NTOHL (0x64730000),  // name = static_threads
  CORBA::tk_ulong,

  16,
  ACE_NTOHL (0x64796e61),
  ACE_NTOHL (0x6d69635f),
  ACE_NTOHL (0x74687265),
  ACE_NTOHL (0x61647300),  // name = dynamic_threads
  CORBA::tk_ulong,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_ThreadpoolLane (
    CORBA::tk_struct,
    sizeof (_oc_RTCORBA_ThreadpoolLane),
    (char *) &_oc_RTCORBA_ThreadpoolLane,
    0,
    sizeof (RTCORBA::ThreadpoolLane)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ThreadpoolLane, &_tc_TAO_tc_RTCORBA_ThreadpoolLane)
TAO_NAMESPACE_END

void RTCORBA::ThreadpoolLane::_tao_any_destructor (void *_tao_void_pointer)
{
  ThreadpoolLane *tmp = ACE_static_cast (ThreadpoolLane*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CS_

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_allocate_buffer (CORBA::ULong length)
{
  RTCORBA::ThreadpoolLane* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::allocbuf (length);

  if (this->buffer_ != 0)
  {
    RTCORBA::ThreadpoolLane *old = ACE_reinterpret_cast (RTCORBA::ThreadpoolLane *,this->buffer_);

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];

    if (this->release_)
      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::freebuf (old);

  }
  this->buffer_ = tmp;
}

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  RTCORBA::ThreadpoolLane *tmp = ACE_reinterpret_cast (RTCORBA::ThreadpoolLane *,this->buffer_);

  _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::freebuf (tmp);
  this->buffer_ = 0;
}

RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes::~_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_THREADPOOLLANES_CS_)
#define _RTCORBA_THREADPOOLLANES_CS_

// *************************************************************
// RTCORBA::ThreadpoolLanes
// *************************************************************

RTCORBA::ThreadpoolLanes::ThreadpoolLanes (void)
{}
RTCORBA::ThreadpoolLanes::ThreadpoolLanes (CORBA::ULong max) // uses max size
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::ThreadpoolLane>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max)
{}
RTCORBA::ThreadpoolLanes::ThreadpoolLanes (CORBA::ULong max, CORBA::ULong length, RTCORBA::ThreadpoolLane *buffer, CORBA::Boolean release)
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::ThreadpoolLane>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max, length, buffer, release)
{}
RTCORBA::ThreadpoolLanes::ThreadpoolLanes (const ThreadpoolLanes &seq) // copy ctor
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::ThreadpoolLane>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (seq)
{}
RTCORBA::ThreadpoolLanes::~ThreadpoolLanes (void) // dtor
{}
void RTCORBA::ThreadpoolLanes::_tao_any_destructor (void *_tao_void_pointer)
{
  ThreadpoolLanes *tmp = ACE_static_cast (ThreadpoolLanes*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_RTCORBA_ThreadpoolLanes[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4c61),
  ACE_NTOHL (0x6e65733a),
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/RTCORBA/ThreadpoolLanes:1.0
  16,
  ACE_NTOHL (0x54687265),
  ACE_NTOHL (0x6164706f),
  ACE_NTOHL (0x6f6c4c61),
  ACE_NTOHL (0x6e657300),  // name = ThreadpoolLanes
  CORBA::tk_sequence, // typecode kind
  228, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    212, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      39,
      ACE_NTOHL (0x49444c3a),
      ACE_NTOHL (0x6f6d672e),
      ACE_NTOHL (0x6f72672f),
      ACE_NTOHL (0x5254434f),
      ACE_NTOHL (0x5242412f),
      ACE_NTOHL (0x54687265),
      ACE_NTOHL (0x6164706f),
      ACE_NTOHL (0x6f6c4c61),
      ACE_NTOHL (0x6e653a31),
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/RTCORBA/ThreadpoolLane:1.0
      15,
      ACE_NTOHL (0x54687265),
      ACE_NTOHL (0x6164706f),
      ACE_NTOHL (0x6f6c4c61),
      ACE_NTOHL (0x6e650000),  // name = ThreadpoolLane
      3, // member count
      14,
      ACE_NTOHL (0x6c616e65),
      ACE_NTOHL (0x5f707269),
      ACE_NTOHL (0x6f726974),
      ACE_NTOHL (0x79000000),  // name = lane_priority
      CORBA::tk_alias, // typecode kind for typedefs
      64, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        33,
        ACE_NTOHL (0x49444c3a),
        ACE_NTOHL (0x6f6d672e),
        ACE_NTOHL (0x6f72672f),
        ACE_NTOHL (0x5254434f),
        ACE_NTOHL (0x5242412f),
        ACE_NTOHL (0x5072696f),
        ACE_NTOHL (0x72697479),
        ACE_NTOHL (0x3a312e30),
        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/Priority:1.0
        9,
        ACE_NTOHL (0x5072696f),
        ACE_NTOHL (0x72697479),
        ACE_NTOHL (0x0),  // name = Priority
        CORBA::tk_short,


      15,
      ACE_NTOHL (0x73746174),
      ACE_NTOHL (0x69635f74),
      ACE_NTOHL (0x68726561),
      ACE_NTOHL (0x64730000),  // name = static_threads
      CORBA::tk_ulong,

      16,
      ACE_NTOHL (0x64796e61),
      ACE_NTOHL (0x6d69635f),
      ACE_NTOHL (0x74687265),
      ACE_NTOHL (0x61647300),  // name = dynamic_threads
      CORBA::tk_ulong,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_ThreadpoolLanes (
    CORBA::tk_alias,
    sizeof (_oc_RTCORBA_ThreadpoolLanes),
    (char *) &_oc_RTCORBA_ThreadpoolLanes,
    0,
    sizeof (RTCORBA::ThreadpoolLanes)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ThreadpoolLanes, &_tc_TAO_tc_RTCORBA_ThreadpoolLanes)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, PRIORITY_MODEL_POLICY_TYPE, 40U)
TAO_NAMESPACE_END
static const CORBA::Long _oc_RTCORBA_PriorityModel[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x4d6f6465),
  ACE_NTOHL (0x6c3a312e),
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/RTCORBA/PriorityModel:1.0
  14,
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x4d6f6465),
  ACE_NTOHL (0x6c000000),  // name = PriorityModel
  2, // member count
  18,
  ACE_NTOHL (0x434c4945),
  ACE_NTOHL (0x4e545f50),
  ACE_NTOHL (0x524f5041),
  ACE_NTOHL (0x47415445),
  ACE_NTOHL (0x44000000),  // name = CLIENT_PROPAGATED
  16,
  ACE_NTOHL (0x53455256),
  ACE_NTOHL (0x45525f44),
  ACE_NTOHL (0x45434c41),
  ACE_NTOHL (0x52454400),  // name = SERVER_DECLARED
};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_PriorityModel (
    CORBA::tk_enum,
    sizeof (_oc_RTCORBA_PriorityModel),
    (char *) &_oc_RTCORBA_PriorityModel,
    0,
    sizeof (RTCORBA::PriorityModel)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PriorityModel, &_tc_TAO_tc_RTCORBA_PriorityModel)
TAO_NAMESPACE_END

int RTCORBA::PriorityModelPolicy::_tao_class_id = 0;

RTCORBA::PriorityModelPolicy_ptr
tao_RTCORBA_PriorityModelPolicy_duplicate (
    RTCORBA::PriorityModelPolicy_ptr p
  )
{
  return RTCORBA::PriorityModelPolicy::_duplicate (p);
}

void
tao_RTCORBA_PriorityModelPolicy_release (
    RTCORBA::PriorityModelPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::PriorityModelPolicy_ptr
tao_RTCORBA_PriorityModelPolicy_nil (
    void
  )
{
  return RTCORBA::PriorityModelPolicy::_nil ();
}

RTCORBA::PriorityModelPolicy_ptr
tao_RTCORBA_PriorityModelPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::PriorityModelPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_PriorityModelPolicy_upcast (
    void *src
  )
{
  RTCORBA::PriorityModelPolicy **tmp =
    ACE_static_cast (RTCORBA::PriorityModelPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PriorityModelPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::PriorityModelPolicy_var::PriorityModelPolicy_var (void) // default constructor
  : ptr_ (PriorityModelPolicy::_nil ())
{}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::PriorityModelPolicy_var::PriorityModelPolicy_var (const ::RTCORBA::PriorityModelPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PriorityModelPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::PriorityModelPolicy_var &
RTCORBA::PriorityModelPolicy_var::operator= (PriorityModelPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::PriorityModelPolicy_var::operator const ::RTCORBA::PriorityModelPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::PriorityModelPolicy_var::operator ::RTCORBA::PriorityModelPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PriorityModelPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
  return val;
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::tao_duplicate (PriorityModelPolicy_ptr p)
{
  return ::RTCORBA::PriorityModelPolicy::_duplicate (p);
}

void
RTCORBA::PriorityModelPolicy_var::tao_release (PriorityModelPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::tao_nil (void)
{
  return ::RTCORBA::PriorityModelPolicy::_nil ();
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::PriorityModelPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::PriorityModelPolicy_var::tao_upcast (void *src)
{
  PriorityModelPolicy **tmp =
    ACE_static_cast (PriorityModelPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PriorityModelPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (PriorityModelPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
}

RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (PriorityModelPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_nil ();
}

RTCORBA::PriorityModelPolicy_out::PriorityModelPolicy_out (const ::RTCORBA::PriorityModelPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (PriorityModelPolicy_out &, p).ptr_)
{}

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

RTCORBA::PriorityModelPolicy_out &
RTCORBA::PriorityModelPolicy_out::operator= (const ::RTCORBA::PriorityModelPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PriorityModelPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::PriorityModelPolicy_out &
RTCORBA::PriorityModelPolicy_out::operator= (PriorityModelPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::PriorityModelPolicy_out::operator ::RTCORBA::PriorityModelPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr &
RTCORBA::PriorityModelPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::PriorityModelPolicy::PriorityModelPolicy (void)
{}

RTCORBA::PriorityModelPolicy::~PriorityModelPolicy (void)
{}

RTCORBA::PriorityModelPolicy_ptr RTCORBA::PriorityModelPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return PriorityModelPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return PriorityModelPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          PriorityModelPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &PriorityModelPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy::_duplicate (PriorityModelPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::PriorityModelPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, PriorityModelPolicy)::_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* RTCORBA::PriorityModelPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/PriorityModelPolicy:1.0";
}

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, THREADPOOL_POLICY_TYPE, 41U)
TAO_NAMESPACE_END
int RTCORBA::ThreadpoolPolicy::_tao_class_id = 0;

RTCORBA::ThreadpoolPolicy_ptr
tao_RTCORBA_ThreadpoolPolicy_duplicate (
    RTCORBA::ThreadpoolPolicy_ptr p
  )
{
  return RTCORBA::ThreadpoolPolicy::_duplicate (p);
}

void
tao_RTCORBA_ThreadpoolPolicy_release (
    RTCORBA::ThreadpoolPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::ThreadpoolPolicy_ptr
tao_RTCORBA_ThreadpoolPolicy_nil (
    void
  )
{
  return RTCORBA::ThreadpoolPolicy::_nil ();
}

RTCORBA::ThreadpoolPolicy_ptr
tao_RTCORBA_ThreadpoolPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::ThreadpoolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_ThreadpoolPolicy_upcast (
    void *src
  )
{
  RTCORBA::ThreadpoolPolicy **tmp =
    ACE_static_cast (RTCORBA::ThreadpoolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ThreadpoolPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::ThreadpoolPolicy_var::ThreadpoolPolicy_var (void) // default constructor
  : ptr_ (ThreadpoolPolicy::_nil ())
{}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::ThreadpoolPolicy_var::ThreadpoolPolicy_var (const ::RTCORBA::ThreadpoolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ThreadpoolPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::ThreadpoolPolicy_var &
RTCORBA::ThreadpoolPolicy_var::operator= (ThreadpoolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::ThreadpoolPolicy_var::operator const ::RTCORBA::ThreadpoolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::ThreadpoolPolicy_var::operator ::RTCORBA::ThreadpoolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ThreadpoolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
  return val;
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::tao_duplicate (ThreadpoolPolicy_ptr p)
{
  return ::RTCORBA::ThreadpoolPolicy::_duplicate (p);
}

void
RTCORBA::ThreadpoolPolicy_var::tao_release (ThreadpoolPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::tao_nil (void)
{
  return ::RTCORBA::ThreadpoolPolicy::_nil ();
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::ThreadpoolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::ThreadpoolPolicy_var::tao_upcast (void *src)
{
  ThreadpoolPolicy **tmp =
    ACE_static_cast (ThreadpoolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ThreadpoolPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (ThreadpoolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
}

RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (ThreadpoolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_nil ();
}

RTCORBA::ThreadpoolPolicy_out::ThreadpoolPolicy_out (const ::RTCORBA::ThreadpoolPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ThreadpoolPolicy_out &, p).ptr_)
{}

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

RTCORBA::ThreadpoolPolicy_out &
RTCORBA::ThreadpoolPolicy_out::operator= (const ::RTCORBA::ThreadpoolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ThreadpoolPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::ThreadpoolPolicy_out &
RTCORBA::ThreadpoolPolicy_out::operator= (ThreadpoolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::ThreadpoolPolicy_out::operator ::RTCORBA::ThreadpoolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr &
RTCORBA::ThreadpoolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::ThreadpoolPolicy::ThreadpoolPolicy (void)
{}

RTCORBA::ThreadpoolPolicy::~ThreadpoolPolicy (void)
{}

RTCORBA::ThreadpoolPolicy_ptr RTCORBA::ThreadpoolPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ThreadpoolPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ThreadpoolPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ThreadpoolPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ThreadpoolPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy::_duplicate (ThreadpoolPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::ThreadpoolPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ThreadpoolPolicy)::_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* RTCORBA::ThreadpoolPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/ThreadpoolPolicy:1.0";
}

int RTCORBA::ProtocolProperties::_tao_class_id = 0;

RTCORBA::ProtocolProperties_ptr
tao_RTCORBA_ProtocolProperties_duplicate (
    RTCORBA::ProtocolProperties_ptr p
  )
{
  return RTCORBA::ProtocolProperties::_duplicate (p);
}

void
tao_RTCORBA_ProtocolProperties_release (
    RTCORBA::ProtocolProperties_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::ProtocolProperties_ptr
tao_RTCORBA_ProtocolProperties_nil (
    void
  )
{
  return RTCORBA::ProtocolProperties::_nil ();
}

RTCORBA::ProtocolProperties_ptr
tao_RTCORBA_ProtocolProperties_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::ProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_ProtocolProperties_upcast (
    void *src
  )
{
  RTCORBA::ProtocolProperties **tmp =
    ACE_static_cast (RTCORBA::ProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ProtocolProperties_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::ProtocolProperties_var::ProtocolProperties_var (void) // default constructor
  : ptr_ (ProtocolProperties::_nil ())
{}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::ProtocolProperties_var::ProtocolProperties_var (const ::RTCORBA::ProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ProtocolProperties::_duplicate (p.ptr ()))
{}

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

RTCORBA::ProtocolProperties_var &
RTCORBA::ProtocolProperties_var::operator= (ProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::ProtocolProperties_var::operator const ::RTCORBA::ProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::ProtocolProperties_var::operator ::RTCORBA::ProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
  return val;
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::tao_duplicate (ProtocolProperties_ptr p)
{
  return ::RTCORBA::ProtocolProperties::_duplicate (p);
}

void
RTCORBA::ProtocolProperties_var::tao_release (ProtocolProperties_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::tao_nil (void)
{
  return ::RTCORBA::ProtocolProperties::_nil ();
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::ProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::ProtocolProperties_var::tao_upcast (void *src)
{
  ProtocolProperties **tmp =
    ACE_static_cast (ProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ProtocolProperties_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::ProtocolProperties_out::ProtocolProperties_out (ProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
}

RTCORBA::ProtocolProperties_out::ProtocolProperties_out (ProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ProtocolProperties::_nil ();
}

RTCORBA::ProtocolProperties_out::ProtocolProperties_out (const ::RTCORBA::ProtocolProperties_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ProtocolProperties_out &, p).ptr_)
{}

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

RTCORBA::ProtocolProperties_out &
RTCORBA::ProtocolProperties_out::operator= (const ::RTCORBA::ProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::ProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::ProtocolProperties_out &
RTCORBA::ProtocolProperties_out::operator= (ProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::ProtocolProperties_out::operator ::RTCORBA::ProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr &
RTCORBA::ProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::ProtocolProperties::ProtocolProperties (void)
{}

RTCORBA::ProtocolProperties::~ProtocolProperties (void)
{}

RTCORBA::ProtocolProperties_ptr RTCORBA::ProtocolProperties::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ProtocolProperties::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ProtocolProperties::_nil ();
  return
      ACE_reinterpret_cast
        (
          ProtocolProperties_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ProtocolProperties::_tao_class_id
                  )
              )
        );
}

RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties::_duplicate (ProtocolProperties_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::ProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_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* RTCORBA::ProtocolProperties::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/ProtocolProperties:1.0";
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CS_

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_allocate_buffer (CORBA::ULong length)
{
  RTCORBA::Protocol* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::allocbuf (length);

  if (this->buffer_ != 0)
  {
    RTCORBA::Protocol *old = ACE_reinterpret_cast (RTCORBA::Protocol *,this->buffer_);

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];

    if (this->release_)
      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::freebuf (old);

  }
  this->buffer_ = tmp;
}

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  RTCORBA::Protocol *tmp = ACE_reinterpret_cast (RTCORBA::Protocol *,this->buffer_);

  _TAO_Unbounded_Sequence_RTCORBA_ProtocolList::freebuf (tmp);
  this->buffer_ = 0;
}

RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_ProtocolList::~_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_PROTOCOLLIST_CS_)
#define _RTCORBA_PROTOCOLLIST_CS_

// *************************************************************
// RTCORBA::ProtocolList
// *************************************************************

RTCORBA::ProtocolList::ProtocolList (void)
{}
RTCORBA::ProtocolList::ProtocolList (CORBA::ULong max) // uses max size
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ProtocolList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::Protocol>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max)
{}
RTCORBA::ProtocolList::ProtocolList (CORBA::ULong max, CORBA::ULong length, RTCORBA::Protocol *buffer, CORBA::Boolean release)
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ProtocolList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::Protocol>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max, length, buffer, release)
{}
RTCORBA::ProtocolList::ProtocolList (const ProtocolList &seq) // copy ctor
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_ProtocolList
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::Protocol>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (seq)
{}
RTCORBA::ProtocolList::~ProtocolList (void) // dtor
{}
void RTCORBA::ProtocolList::_tao_any_destructor (void *_tao_void_pointer)
{
  ProtocolList *tmp = ACE_static_cast (ProtocolList*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, SERVER_PROTOCOL_POLICY_TYPE, 42U)
TAO_NAMESPACE_END
int RTCORBA::ServerProtocolPolicy::_tao_class_id = 0;

RTCORBA::ServerProtocolPolicy_ptr
tao_RTCORBA_ServerProtocolPolicy_duplicate (
    RTCORBA::ServerProtocolPolicy_ptr p
  )
{
  return RTCORBA::ServerProtocolPolicy::_duplicate (p);
}

void
tao_RTCORBA_ServerProtocolPolicy_release (
    RTCORBA::ServerProtocolPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::ServerProtocolPolicy_ptr
tao_RTCORBA_ServerProtocolPolicy_nil (
    void
  )
{
  return RTCORBA::ServerProtocolPolicy::_nil ();
}

RTCORBA::ServerProtocolPolicy_ptr
tao_RTCORBA_ServerProtocolPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::ServerProtocolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_ServerProtocolPolicy_upcast (
    void *src
  )
{
  RTCORBA::ServerProtocolPolicy **tmp =
    ACE_static_cast (RTCORBA::ServerProtocolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ServerProtocolPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::ServerProtocolPolicy_var::ServerProtocolPolicy_var (void) // default constructor
  : ptr_ (ServerProtocolPolicy::_nil ())
{}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::ServerProtocolPolicy_var::ServerProtocolPolicy_var (const ::RTCORBA::ServerProtocolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ServerProtocolPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::ServerProtocolPolicy_var &
RTCORBA::ServerProtocolPolicy_var::operator= (ServerProtocolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::ServerProtocolPolicy_var::operator const ::RTCORBA::ServerProtocolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::ServerProtocolPolicy_var::operator ::RTCORBA::ServerProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ServerProtocolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
  return val;
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::tao_duplicate (ServerProtocolPolicy_ptr p)
{
  return ::RTCORBA::ServerProtocolPolicy::_duplicate (p);
}

void
RTCORBA::ServerProtocolPolicy_var::tao_release (ServerProtocolPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::tao_nil (void)
{
  return ::RTCORBA::ServerProtocolPolicy::_nil ();
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::ServerProtocolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::ServerProtocolPolicy_var::tao_upcast (void *src)
{
  ServerProtocolPolicy **tmp =
    ACE_static_cast (ServerProtocolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ServerProtocolPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (ServerProtocolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
}

RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (ServerProtocolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_nil ();
}

RTCORBA::ServerProtocolPolicy_out::ServerProtocolPolicy_out (const ::RTCORBA::ServerProtocolPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ServerProtocolPolicy_out &, p).ptr_)
{}

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

RTCORBA::ServerProtocolPolicy_out &
RTCORBA::ServerProtocolPolicy_out::operator= (const ::RTCORBA::ServerProtocolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ServerProtocolPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::ServerProtocolPolicy_out &
RTCORBA::ServerProtocolPolicy_out::operator= (ServerProtocolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::ServerProtocolPolicy_out::operator ::RTCORBA::ServerProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr &
RTCORBA::ServerProtocolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::ServerProtocolPolicy::ServerProtocolPolicy (void)
{}

RTCORBA::ServerProtocolPolicy::~ServerProtocolPolicy (void)
{}

RTCORBA::ServerProtocolPolicy_ptr RTCORBA::ServerProtocolPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ServerProtocolPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ServerProtocolPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ServerProtocolPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ServerProtocolPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy::_duplicate (ServerProtocolPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::ServerProtocolPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ServerProtocolPolicy)::_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* RTCORBA::ServerProtocolPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/ServerProtocolPolicy:1.0";
}

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, CLIENT_PROTOCOL_POLICY_TYPE, 43U)
TAO_NAMESPACE_END
int RTCORBA::ClientProtocolPolicy::_tao_class_id = 0;

RTCORBA::ClientProtocolPolicy_ptr
tao_RTCORBA_ClientProtocolPolicy_duplicate (
    RTCORBA::ClientProtocolPolicy_ptr p
  )
{
  return RTCORBA::ClientProtocolPolicy::_duplicate (p);
}

void
tao_RTCORBA_ClientProtocolPolicy_release (
    RTCORBA::ClientProtocolPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::ClientProtocolPolicy_ptr
tao_RTCORBA_ClientProtocolPolicy_nil (
    void
  )
{
  return RTCORBA::ClientProtocolPolicy::_nil ();
}

RTCORBA::ClientProtocolPolicy_ptr
tao_RTCORBA_ClientProtocolPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::ClientProtocolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_ClientProtocolPolicy_upcast (
    void *src
  )
{
  RTCORBA::ClientProtocolPolicy **tmp =
    ACE_static_cast (RTCORBA::ClientProtocolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ClientProtocolPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::ClientProtocolPolicy_var::ClientProtocolPolicy_var (void) // default constructor
  : ptr_ (ClientProtocolPolicy::_nil ())
{}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::ClientProtocolPolicy_var::ClientProtocolPolicy_var (const ::RTCORBA::ClientProtocolPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (ClientProtocolPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::ClientProtocolPolicy_var &
RTCORBA::ClientProtocolPolicy_var::operator= (ClientProtocolPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::ClientProtocolPolicy_var::operator const ::RTCORBA::ClientProtocolPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::ClientProtocolPolicy_var::operator ::RTCORBA::ClientProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::ClientProtocolPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
  return val;
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::tao_duplicate (ClientProtocolPolicy_ptr p)
{
  return ::RTCORBA::ClientProtocolPolicy::_duplicate (p);
}

void
RTCORBA::ClientProtocolPolicy_var::tao_release (ClientProtocolPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::tao_nil (void)
{
  return ::RTCORBA::ClientProtocolPolicy::_nil ();
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::ClientProtocolPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::ClientProtocolPolicy_var::tao_upcast (void *src)
{
  ClientProtocolPolicy **tmp =
    ACE_static_cast (ClientProtocolPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::ClientProtocolPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (ClientProtocolPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
}

RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (ClientProtocolPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_nil ();
}

RTCORBA::ClientProtocolPolicy_out::ClientProtocolPolicy_out (const ::RTCORBA::ClientProtocolPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (ClientProtocolPolicy_out &, p).ptr_)
{}

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

RTCORBA::ClientProtocolPolicy_out &
RTCORBA::ClientProtocolPolicy_out::operator= (const ::RTCORBA::ClientProtocolPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::ClientProtocolPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::ClientProtocolPolicy_out &
RTCORBA::ClientProtocolPolicy_out::operator= (ClientProtocolPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::ClientProtocolPolicy_out::operator ::RTCORBA::ClientProtocolPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr &
RTCORBA::ClientProtocolPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::ClientProtocolPolicy::ClientProtocolPolicy (void)
{}

RTCORBA::ClientProtocolPolicy::~ClientProtocolPolicy (void)
{}

RTCORBA::ClientProtocolPolicy_ptr RTCORBA::ClientProtocolPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return ClientProtocolPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return ClientProtocolPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          ClientProtocolPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &ClientProtocolPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy::_duplicate (ClientProtocolPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::ClientProtocolPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ClientProtocolPolicy)::_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* RTCORBA::ClientProtocolPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/ClientProtocolPolicy:1.0";
}

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, PRIVATE_CONNECTION_POLICY_TYPE, 44U)
TAO_NAMESPACE_END
int RTCORBA::PrivateConnectionPolicy::_tao_class_id = 0;

RTCORBA::PrivateConnectionPolicy_ptr
tao_RTCORBA_PrivateConnectionPolicy_duplicate (
    RTCORBA::PrivateConnectionPolicy_ptr p
  )
{
  return RTCORBA::PrivateConnectionPolicy::_duplicate (p);
}

void
tao_RTCORBA_PrivateConnectionPolicy_release (
    RTCORBA::PrivateConnectionPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::PrivateConnectionPolicy_ptr
tao_RTCORBA_PrivateConnectionPolicy_nil (
    void
  )
{
  return RTCORBA::PrivateConnectionPolicy::_nil ();
}

RTCORBA::PrivateConnectionPolicy_ptr
tao_RTCORBA_PrivateConnectionPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::PrivateConnectionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_PrivateConnectionPolicy_upcast (
    void *src
  )
{
  RTCORBA::PrivateConnectionPolicy **tmp =
    ACE_static_cast (RTCORBA::PrivateConnectionPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PrivateConnectionPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::PrivateConnectionPolicy_var::PrivateConnectionPolicy_var (void) // default constructor
  : ptr_ (PrivateConnectionPolicy::_nil ())
{}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::PrivateConnectionPolicy_var::PrivateConnectionPolicy_var (const ::RTCORBA::PrivateConnectionPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PrivateConnectionPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::PrivateConnectionPolicy_var &
RTCORBA::PrivateConnectionPolicy_var::operator= (PrivateConnectionPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::PrivateConnectionPolicy_var::operator const ::RTCORBA::PrivateConnectionPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::PrivateConnectionPolicy_var::operator ::RTCORBA::PrivateConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PrivateConnectionPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
  return val;
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::tao_duplicate (PrivateConnectionPolicy_ptr p)
{
  return ::RTCORBA::PrivateConnectionPolicy::_duplicate (p);
}

void
RTCORBA::PrivateConnectionPolicy_var::tao_release (PrivateConnectionPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::tao_nil (void)
{
  return ::RTCORBA::PrivateConnectionPolicy::_nil ();
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::PrivateConnectionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::PrivateConnectionPolicy_var::tao_upcast (void *src)
{
  PrivateConnectionPolicy **tmp =
    ACE_static_cast (PrivateConnectionPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PrivateConnectionPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (PrivateConnectionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
}

RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (PrivateConnectionPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_nil ();
}

RTCORBA::PrivateConnectionPolicy_out::PrivateConnectionPolicy_out (const ::RTCORBA::PrivateConnectionPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (PrivateConnectionPolicy_out &, p).ptr_)
{}

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

RTCORBA::PrivateConnectionPolicy_out &
RTCORBA::PrivateConnectionPolicy_out::operator= (const ::RTCORBA::PrivateConnectionPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PrivateConnectionPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::PrivateConnectionPolicy_out &
RTCORBA::PrivateConnectionPolicy_out::operator= (PrivateConnectionPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::PrivateConnectionPolicy_out::operator ::RTCORBA::PrivateConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr &
RTCORBA::PrivateConnectionPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::PrivateConnectionPolicy::PrivateConnectionPolicy (void)
{}

RTCORBA::PrivateConnectionPolicy::~PrivateConnectionPolicy (void)
{}

RTCORBA::PrivateConnectionPolicy_ptr RTCORBA::PrivateConnectionPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return PrivateConnectionPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return PrivateConnectionPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          PrivateConnectionPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &PrivateConnectionPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy::_duplicate (PrivateConnectionPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::PrivateConnectionPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, PrivateConnectionPolicy)::_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* RTCORBA::PrivateConnectionPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/PrivateConnectionPolicy:1.0";
}

int RTCORBA::TCPProtocolProperties::_tao_class_id = 0;

RTCORBA::TCPProtocolProperties_ptr
tao_RTCORBA_TCPProtocolProperties_duplicate (
    RTCORBA::TCPProtocolProperties_ptr p
  )
{
  return RTCORBA::TCPProtocolProperties::_duplicate (p);
}

void
tao_RTCORBA_TCPProtocolProperties_release (
    RTCORBA::TCPProtocolProperties_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::TCPProtocolProperties_ptr
tao_RTCORBA_TCPProtocolProperties_nil (
    void
  )
{
  return RTCORBA::TCPProtocolProperties::_nil ();
}

RTCORBA::TCPProtocolProperties_ptr
tao_RTCORBA_TCPProtocolProperties_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::TCPProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_TCPProtocolProperties_upcast (
    void *src
  )
{
  RTCORBA::TCPProtocolProperties **tmp =
    ACE_static_cast (RTCORBA::TCPProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::TCPProtocolProperties_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::TCPProtocolProperties_var::TCPProtocolProperties_var (void) // default constructor
  : ptr_ (TCPProtocolProperties::_nil ())
{}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::TCPProtocolProperties_var::TCPProtocolProperties_var (const ::RTCORBA::TCPProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (TCPProtocolProperties::_duplicate (p.ptr ()))
{}

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

RTCORBA::TCPProtocolProperties_var &
RTCORBA::TCPProtocolProperties_var::operator= (TCPProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::TCPProtocolProperties_var::operator const ::RTCORBA::TCPProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::TCPProtocolProperties_var::operator ::RTCORBA::TCPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::TCPProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
  return val;
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::tao_duplicate (TCPProtocolProperties_ptr p)
{
  return ::RTCORBA::TCPProtocolProperties::_duplicate (p);
}

void
RTCORBA::TCPProtocolProperties_var::tao_release (TCPProtocolProperties_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::tao_nil (void)
{
  return ::RTCORBA::TCPProtocolProperties::_nil ();
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::TCPProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::TCPProtocolProperties_var::tao_upcast (void *src)
{
  TCPProtocolProperties **tmp =
    ACE_static_cast (TCPProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::TCPProtocolProperties_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (TCPProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
}

RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (TCPProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_nil ();
}

RTCORBA::TCPProtocolProperties_out::TCPProtocolProperties_out (const ::RTCORBA::TCPProtocolProperties_out &p) // copy constructor
  : ptr_ (ACE_const_cast (TCPProtocolProperties_out &, p).ptr_)
{}

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

RTCORBA::TCPProtocolProperties_out &
RTCORBA::TCPProtocolProperties_out::operator= (const ::RTCORBA::TCPProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::TCPProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::TCPProtocolProperties_out &
RTCORBA::TCPProtocolProperties_out::operator= (TCPProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::TCPProtocolProperties_out::operator ::RTCORBA::TCPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr &
RTCORBA::TCPProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}

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

RTCORBA::TCPProtocolProperties::TCPProtocolProperties (void)
{}

RTCORBA::TCPProtocolProperties::~TCPProtocolProperties (void)
{}

RTCORBA::TCPProtocolProperties_ptr RTCORBA::TCPProtocolProperties::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return TCPProtocolProperties::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return TCPProtocolProperties::_nil ();
  return
      ACE_reinterpret_cast
        (
          TCPProtocolProperties_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &TCPProtocolProperties::_tao_class_id
                  )
              )
        );
}

RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties::_duplicate (TCPProtocolProperties_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::TCPProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, TCPProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_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* RTCORBA::TCPProtocolProperties::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/TCPProtocolProperties:1.0";
}

int RTCORBA::GIOPProtocolProperties::_tao_class_id = 0;

RTCORBA::GIOPProtocolProperties_ptr
tao_RTCORBA_GIOPProtocolProperties_duplicate (
    RTCORBA::GIOPProtocolProperties_ptr p
  )
{
  return RTCORBA::GIOPProtocolProperties::_duplicate (p);
}

void
tao_RTCORBA_GIOPProtocolProperties_release (
    RTCORBA::GIOPProtocolProperties_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::GIOPProtocolProperties_ptr
tao_RTCORBA_GIOPProtocolProperties_nil (
    void
  )
{
  return RTCORBA::GIOPProtocolProperties::_nil ();
}

RTCORBA::GIOPProtocolProperties_ptr
tao_RTCORBA_GIOPProtocolProperties_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::GIOPProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_GIOPProtocolProperties_upcast (
    void *src
  )
{
  RTCORBA::GIOPProtocolProperties **tmp =
    ACE_static_cast (RTCORBA::GIOPProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::GIOPProtocolProperties_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::GIOPProtocolProperties_var::GIOPProtocolProperties_var (void) // default constructor
  : ptr_ (GIOPProtocolProperties::_nil ())
{}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::GIOPProtocolProperties_var::GIOPProtocolProperties_var (const ::RTCORBA::GIOPProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (GIOPProtocolProperties::_duplicate (p.ptr ()))
{}

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

RTCORBA::GIOPProtocolProperties_var &
RTCORBA::GIOPProtocolProperties_var::operator= (GIOPProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::GIOPProtocolProperties_var::operator const ::RTCORBA::GIOPProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::GIOPProtocolProperties_var::operator ::RTCORBA::GIOPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::GIOPProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
  return val;
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::tao_duplicate (GIOPProtocolProperties_ptr p)
{
  return ::RTCORBA::GIOPProtocolProperties::_duplicate (p);
}

void
RTCORBA::GIOPProtocolProperties_var::tao_release (GIOPProtocolProperties_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::tao_nil (void)
{
  return ::RTCORBA::GIOPProtocolProperties::_nil ();
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::GIOPProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::GIOPProtocolProperties_var::tao_upcast (void *src)
{
  GIOPProtocolProperties **tmp =
    ACE_static_cast (GIOPProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::GIOPProtocolProperties_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (GIOPProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
}

RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (GIOPProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_nil ();
}

RTCORBA::GIOPProtocolProperties_out::GIOPProtocolProperties_out (const ::RTCORBA::GIOPProtocolProperties_out &p) // copy constructor
  : ptr_ (ACE_const_cast (GIOPProtocolProperties_out &, p).ptr_)
{}

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

RTCORBA::GIOPProtocolProperties_out &
RTCORBA::GIOPProtocolProperties_out::operator= (const ::RTCORBA::GIOPProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::GIOPProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::GIOPProtocolProperties_out &
RTCORBA::GIOPProtocolProperties_out::operator= (GIOPProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::GIOPProtocolProperties_out::operator ::RTCORBA::GIOPProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr &
RTCORBA::GIOPProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::GIOPProtocolProperties::GIOPProtocolProperties (void)
{}

RTCORBA::GIOPProtocolProperties::~GIOPProtocolProperties (void)
{}

RTCORBA::GIOPProtocolProperties_ptr RTCORBA::GIOPProtocolProperties::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return GIOPProtocolProperties::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return GIOPProtocolProperties::_nil ();
  return
      ACE_reinterpret_cast
        (
          GIOPProtocolProperties_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &GIOPProtocolProperties::_tao_class_id
                  )
              )
        );
}

RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties::_duplicate (GIOPProtocolProperties_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::GIOPProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, GIOPProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_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* RTCORBA::GIOPProtocolProperties::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/GIOPProtocolProperties:1.0";
}

int RTCORBA::UnixDomainProtocolProperties::_tao_class_id = 0;

RTCORBA::UnixDomainProtocolProperties_ptr
tao_RTCORBA_UnixDomainProtocolProperties_duplicate (
    RTCORBA::UnixDomainProtocolProperties_ptr p
  )
{
  return RTCORBA::UnixDomainProtocolProperties::_duplicate (p);
}

void
tao_RTCORBA_UnixDomainProtocolProperties_release (
    RTCORBA::UnixDomainProtocolProperties_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::UnixDomainProtocolProperties_ptr
tao_RTCORBA_UnixDomainProtocolProperties_nil (
    void
  )
{
  return RTCORBA::UnixDomainProtocolProperties::_nil ();
}

RTCORBA::UnixDomainProtocolProperties_ptr
tao_RTCORBA_UnixDomainProtocolProperties_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::UnixDomainProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_UnixDomainProtocolProperties_upcast (
    void *src
  )
{
  RTCORBA::UnixDomainProtocolProperties **tmp =
    ACE_static_cast (RTCORBA::UnixDomainProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::UnixDomainProtocolProperties_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (void) // default constructor
  : ptr_ (UnixDomainProtocolProperties::_nil ())
{}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::UnixDomainProtocolProperties_var::UnixDomainProtocolProperties_var (const ::RTCORBA::UnixDomainProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (UnixDomainProtocolProperties::_duplicate (p.ptr ()))
{}

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

RTCORBA::UnixDomainProtocolProperties_var &
RTCORBA::UnixDomainProtocolProperties_var::operator= (UnixDomainProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::UnixDomainProtocolProperties_var::operator const ::RTCORBA::UnixDomainProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::UnixDomainProtocolProperties_var::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::UnixDomainProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
  return val;
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::tao_duplicate (UnixDomainProtocolProperties_ptr p)
{
  return ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p);
}

void
RTCORBA::UnixDomainProtocolProperties_var::tao_release (UnixDomainProtocolProperties_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::tao_nil (void)
{
  return ::RTCORBA::UnixDomainProtocolProperties::_nil ();
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::UnixDomainProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::UnixDomainProtocolProperties_var::tao_upcast (void *src)
{
  UnixDomainProtocolProperties **tmp =
    ACE_static_cast (UnixDomainProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::UnixDomainProtocolProperties_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
}

RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (UnixDomainProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_nil ();
}

RTCORBA::UnixDomainProtocolProperties_out::UnixDomainProtocolProperties_out (const ::RTCORBA::UnixDomainProtocolProperties_out &p) // copy constructor
  : ptr_ (ACE_const_cast (UnixDomainProtocolProperties_out &, p).ptr_)
{}

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

RTCORBA::UnixDomainProtocolProperties_out &
RTCORBA::UnixDomainProtocolProperties_out::operator= (const ::RTCORBA::UnixDomainProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::UnixDomainProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::UnixDomainProtocolProperties_out &
RTCORBA::UnixDomainProtocolProperties_out::operator= (UnixDomainProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::UnixDomainProtocolProperties_out::operator ::RTCORBA::UnixDomainProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr &
RTCORBA::UnixDomainProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::UnixDomainProtocolProperties::UnixDomainProtocolProperties (void)
{}

RTCORBA::UnixDomainProtocolProperties::~UnixDomainProtocolProperties (void)
{}

RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return UnixDomainProtocolProperties::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return UnixDomainProtocolProperties::_nil ();
  return
      ACE_reinterpret_cast
        (
          UnixDomainProtocolProperties_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &UnixDomainProtocolProperties::_tao_class_id
                  )
              )
        );
}

RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties::_duplicate (UnixDomainProtocolProperties_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::UnixDomainProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, UnixDomainProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_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* RTCORBA::UnixDomainProtocolProperties::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/UnixDomainProtocolProperties:1.0";
}

int RTCORBA::SharedMemoryProtocolProperties::_tao_class_id = 0;

RTCORBA::SharedMemoryProtocolProperties_ptr
tao_RTCORBA_SharedMemoryProtocolProperties_duplicate (
    RTCORBA::SharedMemoryProtocolProperties_ptr p
  )
{
  return RTCORBA::SharedMemoryProtocolProperties::_duplicate (p);
}

void
tao_RTCORBA_SharedMemoryProtocolProperties_release (
    RTCORBA::SharedMemoryProtocolProperties_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::SharedMemoryProtocolProperties_ptr
tao_RTCORBA_SharedMemoryProtocolProperties_nil (
    void
  )
{
  return RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

RTCORBA::SharedMemoryProtocolProperties_ptr
tao_RTCORBA_SharedMemoryProtocolProperties_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::SharedMemoryProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_SharedMemoryProtocolProperties_upcast (
    void *src
  )
{
  RTCORBA::SharedMemoryProtocolProperties **tmp =
    ACE_static_cast (RTCORBA::SharedMemoryProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::SharedMemoryProtocolProperties_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (void) // default constructor
  : ptr_ (SharedMemoryProtocolProperties::_nil ())
{}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::SharedMemoryProtocolProperties_var::SharedMemoryProtocolProperties_var (const ::RTCORBA::SharedMemoryProtocolProperties_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (SharedMemoryProtocolProperties::_duplicate (p.ptr ()))
{}

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

RTCORBA::SharedMemoryProtocolProperties_var &
RTCORBA::SharedMemoryProtocolProperties_var::operator= (SharedMemoryProtocolProperties_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::SharedMemoryProtocolProperties_var::operator const ::RTCORBA::SharedMemoryProtocolProperties_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::SharedMemoryProtocolProperties_var::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::SharedMemoryProtocolProperties_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
  return val;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::tao_duplicate (SharedMemoryProtocolProperties_ptr p)
{
  return ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p);
}

void
RTCORBA::SharedMemoryProtocolProperties_var::tao_release (SharedMemoryProtocolProperties_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::tao_nil (void)
{
  return ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::SharedMemoryProtocolProperties::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::SharedMemoryProtocolProperties_var::tao_upcast (void *src)
{
  SharedMemoryProtocolProperties **tmp =
    ACE_static_cast (SharedMemoryProtocolProperties **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::SharedMemoryProtocolProperties_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (SharedMemoryProtocolProperties_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

RTCORBA::SharedMemoryProtocolProperties_out::SharedMemoryProtocolProperties_out (const ::RTCORBA::SharedMemoryProtocolProperties_out &p) // copy constructor
  : ptr_ (ACE_const_cast (SharedMemoryProtocolProperties_out &, p).ptr_)
{}

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

RTCORBA::SharedMemoryProtocolProperties_out &
RTCORBA::SharedMemoryProtocolProperties_out::operator= (const ::RTCORBA::SharedMemoryProtocolProperties_var &p)
{
  this->ptr_ = ::RTCORBA::SharedMemoryProtocolProperties::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::SharedMemoryProtocolProperties_out &
RTCORBA::SharedMemoryProtocolProperties_out::operator= (SharedMemoryProtocolProperties_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::SharedMemoryProtocolProperties_out::operator ::RTCORBA::SharedMemoryProtocolProperties_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr &
RTCORBA::SharedMemoryProtocolProperties_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::SharedMemoryProtocolProperties::SharedMemoryProtocolProperties (void)
{}

RTCORBA::SharedMemoryProtocolProperties::~SharedMemoryProtocolProperties (void)
{}

RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return SharedMemoryProtocolProperties::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return SharedMemoryProtocolProperties::_nil ();
  return
      ACE_reinterpret_cast
        (
          SharedMemoryProtocolProperties_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &SharedMemoryProtocolProperties::_tao_class_id
                  )
              )
        );
}

RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties::_duplicate (SharedMemoryProtocolProperties_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::SharedMemoryProtocolProperties::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, SharedMemoryProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_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* RTCORBA::SharedMemoryProtocolProperties::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/SharedMemoryProtocolProperties:1.0";
}

static const CORBA::Long _oc_RTCORBA_PriorityBand[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x42616e64),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/PriorityBand:1.0
  13,
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x42616e64),
  ACE_NTOHL (0x0),  // name = PriorityBand
  2, // member count
  4,
  ACE_NTOHL (0x6c6f7700),  // name = low
  CORBA::tk_alias, // typecode kind for typedefs
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x5254434f),
    ACE_NTOHL (0x5242412f),
    ACE_NTOHL (0x5072696f),
    ACE_NTOHL (0x72697479),
    ACE_NTOHL (0x3a312e30),
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/Priority:1.0
    9,
    ACE_NTOHL (0x5072696f),
    ACE_NTOHL (0x72697479),
    ACE_NTOHL (0x0),  // name = Priority
    CORBA::tk_short,


  5,
  ACE_NTOHL (0x68696768),
  ACE_NTOHL (0x0),  // name = high
  0xffffffff, // indirection
  0xffffffa8, // negative offset (-88)
};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_PriorityBand (
    CORBA::tk_struct,
    sizeof (_oc_RTCORBA_PriorityBand),
    (char *) &_oc_RTCORBA_PriorityBand,
    0,
    sizeof (RTCORBA::PriorityBand)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PriorityBand, &_tc_TAO_tc_RTCORBA_PriorityBand)
TAO_NAMESPACE_END

void RTCORBA::PriorityBand::_tao_any_destructor (void *_tao_void_pointer)
{
  PriorityBand *tmp = ACE_static_cast (PriorityBand*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CS_

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_allocate_buffer (CORBA::ULong length)
{
  RTCORBA::PriorityBand* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::allocbuf (length);

  if (this->buffer_ != 0)
  {
    RTCORBA::PriorityBand *old = ACE_reinterpret_cast (RTCORBA::PriorityBand *,this->buffer_);

    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];

    if (this->release_)
      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::freebuf (old);

  }
  this->buffer_ = tmp;
}

void
RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;

  RTCORBA::PriorityBand *tmp = ACE_reinterpret_cast (RTCORBA::PriorityBand *,this->buffer_);

  _TAO_Unbounded_Sequence_RTCORBA_PriorityBands::freebuf (tmp);
  this->buffer_ = 0;
}

RTCORBA::_TAO_Unbounded_Sequence_RTCORBA_PriorityBands::~_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_RTCORBA_PRIORITYBANDS_CS_)
#define _RTCORBA_PRIORITYBANDS_CS_

// *************************************************************
// RTCORBA::PriorityBands
// *************************************************************

RTCORBA::PriorityBands::PriorityBands (void)
{}
RTCORBA::PriorityBands::PriorityBands (CORBA::ULong max) // uses max size
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_PriorityBands
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::PriorityBand>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max)
{}
RTCORBA::PriorityBands::PriorityBands (CORBA::ULong max, CORBA::ULong length, RTCORBA::PriorityBand *buffer, CORBA::Boolean release)
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_PriorityBands
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::PriorityBand>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max, length, buffer, release)
{}
RTCORBA::PriorityBands::PriorityBands (const PriorityBands &seq) // copy ctor
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_RTCORBA_PriorityBands
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<RTCORBA::PriorityBand>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (seq)
{}
RTCORBA::PriorityBands::~PriorityBands (void) // dtor
{}
void RTCORBA::PriorityBands::_tao_any_destructor (void *_tao_void_pointer)
{
  PriorityBands *tmp = ACE_static_cast (PriorityBands*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_RTCORBA_PriorityBands[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x5254434f),
  ACE_NTOHL (0x5242412f),
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x42616e64),
  ACE_NTOHL (0x733a312e),
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/RTCORBA/PriorityBands:1.0
  14,
  ACE_NTOHL (0x5072696f),
  ACE_NTOHL (0x72697479),
  ACE_NTOHL (0x42616e64),
  ACE_NTOHL (0x73000000),  // name = PriorityBands
  CORBA::tk_sequence, // typecode kind
  188, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    172, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      37,
      ACE_NTOHL (0x49444c3a),
      ACE_NTOHL (0x6f6d672e),
      ACE_NTOHL (0x6f72672f),
      ACE_NTOHL (0x5254434f),
      ACE_NTOHL (0x5242412f),
      ACE_NTOHL (0x5072696f),
      ACE_NTOHL (0x72697479),
      ACE_NTOHL (0x42616e64),
      ACE_NTOHL (0x3a312e30),
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/PriorityBand:1.0
      13,
      ACE_NTOHL (0x5072696f),
      ACE_NTOHL (0x72697479),
      ACE_NTOHL (0x42616e64),
      ACE_NTOHL (0x0),  // name = PriorityBand
      2, // member count
      4,
      ACE_NTOHL (0x6c6f7700),  // name = low
      CORBA::tk_alias, // typecode kind for typedefs
      64, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        33,
        ACE_NTOHL (0x49444c3a),
        ACE_NTOHL (0x6f6d672e),
        ACE_NTOHL (0x6f72672f),
        ACE_NTOHL (0x5254434f),
        ACE_NTOHL (0x5242412f),
        ACE_NTOHL (0x5072696f),
        ACE_NTOHL (0x72697479),
        ACE_NTOHL (0x3a312e30),
        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/RTCORBA/Priority:1.0
        9,
        ACE_NTOHL (0x5072696f),
        ACE_NTOHL (0x72697479),
        ACE_NTOHL (0x0),  // name = Priority
        CORBA::tk_short,


      5,
      ACE_NTOHL (0x68696768),
      ACE_NTOHL (0x0),  // name = high
      0xffffffff, // indirection
      0xffffffa8, // negative offset (-88)

    0U,

};

static CORBA::TypeCode _tc_TAO_tc_RTCORBA_PriorityBands (
    CORBA::tk_alias,
    sizeof (_oc_RTCORBA_PriorityBands),
    (char *) &_oc_RTCORBA_PriorityBands,
    0,
    sizeof (RTCORBA::PriorityBands)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PriorityBands, &_tc_TAO_tc_RTCORBA_PriorityBands)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::ULong)
TAO_NAMESPACE_BEGIN (RTCORBA)
TAO_NAMESPACE_DEFINE (const CORBA::ULong, PRIORITY_BANDED_CONNECTION_POLICY_TYPE, 45U)
TAO_NAMESPACE_END
int RTCORBA::PriorityBandedConnectionPolicy::_tao_class_id = 0;

RTCORBA::PriorityBandedConnectionPolicy_ptr
tao_RTCORBA_PriorityBandedConnectionPolicy_duplicate (
    RTCORBA::PriorityBandedConnectionPolicy_ptr p
  )
{
  return RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p);
}

void
tao_RTCORBA_PriorityBandedConnectionPolicy_release (
    RTCORBA::PriorityBandedConnectionPolicy_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
tao_RTCORBA_PriorityBandedConnectionPolicy_nil (
    void
  )
{
  return RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
tao_RTCORBA_PriorityBandedConnectionPolicy_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::PriorityBandedConnectionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_PriorityBandedConnectionPolicy_upcast (
    void *src
  )
{
  RTCORBA::PriorityBandedConnectionPolicy **tmp =
    ACE_static_cast (RTCORBA::PriorityBandedConnectionPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PriorityBandedConnectionPolicy_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::PriorityBandedConnectionPolicy_var::PriorityBandedConnectionPolicy_var (void) // default constructor
  : ptr_ (PriorityBandedConnectionPolicy::_nil ())
{}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::PriorityBandedConnectionPolicy_var::PriorityBandedConnectionPolicy_var (const ::RTCORBA::PriorityBandedConnectionPolicy_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (PriorityBandedConnectionPolicy::_duplicate (p.ptr ()))
{}

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

RTCORBA::PriorityBandedConnectionPolicy_var &
RTCORBA::PriorityBandedConnectionPolicy_var::operator= (PriorityBandedConnectionPolicy_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::PriorityBandedConnectionPolicy_var::operator const ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::PriorityBandedConnectionPolicy_var::operator ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::PriorityBandedConnectionPolicy_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
  return val;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::tao_duplicate (PriorityBandedConnectionPolicy_ptr p)
{
  return ::RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p);
}

void
RTCORBA::PriorityBandedConnectionPolicy_var::tao_release (PriorityBandedConnectionPolicy_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::tao_nil (void)
{
  return ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::PriorityBandedConnectionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::PriorityBandedConnectionPolicy_var::tao_upcast (void *src)
{
  PriorityBandedConnectionPolicy **tmp =
    ACE_static_cast (PriorityBandedConnectionPolicy **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::PriorityBandedConnectionPolicy_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

RTCORBA::PriorityBandedConnectionPolicy_out::PriorityBandedConnectionPolicy_out (const ::RTCORBA::PriorityBandedConnectionPolicy_out &p) // copy constructor
  : ptr_ (ACE_const_cast (PriorityBandedConnectionPolicy_out &, p).ptr_)
{}

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

RTCORBA::PriorityBandedConnectionPolicy_out &
RTCORBA::PriorityBandedConnectionPolicy_out::operator= (const ::RTCORBA::PriorityBandedConnectionPolicy_var &p)
{
  this->ptr_ = ::RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::PriorityBandedConnectionPolicy_out &
RTCORBA::PriorityBandedConnectionPolicy_out::operator= (PriorityBandedConnectionPolicy_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::PriorityBandedConnectionPolicy_out::operator ::RTCORBA::PriorityBandedConnectionPolicy_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr &
RTCORBA::PriorityBandedConnectionPolicy_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::PriorityBandedConnectionPolicy::PriorityBandedConnectionPolicy (void)
{}

RTCORBA::PriorityBandedConnectionPolicy::~PriorityBandedConnectionPolicy (void)
{}

RTCORBA::PriorityBandedConnectionPolicy_ptr RTCORBA::PriorityBandedConnectionPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return PriorityBandedConnectionPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return PriorityBandedConnectionPolicy::_nil ();
  return
      ACE_reinterpret_cast
        (
          PriorityBandedConnectionPolicy_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &PriorityBandedConnectionPolicy::_tao_class_id
                  )
              )
        );
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy::_duplicate (PriorityBandedConnectionPolicy_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::PriorityBandedConnectionPolicy::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, PriorityBandedConnectionPolicy)::_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* RTCORBA::PriorityBandedConnectionPolicy::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/PriorityBandedConnectionPolicy:1.0";
}

int RTCORBA::Current::_tao_class_id = 0;

RTCORBA::Current_ptr
tao_RTCORBA_Current_duplicate (
    RTCORBA::Current_ptr p
  )
{
  return RTCORBA::Current::_duplicate (p);
}

void
tao_RTCORBA_Current_release (
    RTCORBA::Current_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::Current_ptr
tao_RTCORBA_Current_nil (
    void
  )
{
  return RTCORBA::Current::_nil ();
}

RTCORBA::Current_ptr
tao_RTCORBA_Current_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_Current_upcast (
    void *src
  )
{
  RTCORBA::Current **tmp =
    ACE_static_cast (RTCORBA::Current **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::Current_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::Current_var::Current_var (void) // default constructor
  : ptr_ (Current::_nil ())
{}

::RTCORBA::Current_ptr
RTCORBA::Current_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::Current_var::Current_var (const ::RTCORBA::Current_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Current::_duplicate (p.ptr ()))
{}

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

RTCORBA::Current_var &
RTCORBA::Current_var::operator= (Current_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::Current_var::operator const ::RTCORBA::Current_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::Current_var::operator ::RTCORBA::Current_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::Current_ptr &
RTCORBA::Current_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::Current_ptr &
RTCORBA::Current_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Current::_nil ();
  return this->ptr_;
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::Current_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::Current::_nil ();
  return val;
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::tao_duplicate (Current_ptr p)
{
  return ::RTCORBA::Current::_duplicate (p);
}

void
RTCORBA::Current_var::tao_release (Current_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::tao_nil (void)
{
  return ::RTCORBA::Current::_nil ();
}

::RTCORBA::Current_ptr
RTCORBA::Current_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::Current::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::Current_var::tao_upcast (void *src)
{
  Current **tmp =
    ACE_static_cast (Current **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::Current_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::Current_out::Current_out (Current_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::Current::_nil ();
}

RTCORBA::Current_out::Current_out (Current_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Current::_nil ();
}

RTCORBA::Current_out::Current_out (const ::RTCORBA::Current_out &p) // copy constructor
  : ptr_ (ACE_const_cast (Current_out &, p).ptr_)
{}

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

RTCORBA::Current_out &
RTCORBA::Current_out::operator= (const ::RTCORBA::Current_var &p)
{
  this->ptr_ = ::RTCORBA::Current::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::Current_out &
RTCORBA::Current_out::operator= (Current_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::Current_out::operator ::RTCORBA::Current_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::Current_ptr &
RTCORBA::Current_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::Current_ptr
RTCORBA::Current_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::Current::Current (void)
{}

RTCORBA::Current::~Current (void)
{}

RTCORBA::Current_ptr RTCORBA::Current::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return Current::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::Current_ptr
RTCORBA::Current::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return Current::_nil ();
  return
      ACE_reinterpret_cast
        (
          Current_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &Current::_tao_class_id
                  )
              )
        );
}

RTCORBA::Current_ptr
RTCORBA::Current::_duplicate (Current_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::Current::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, Current)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Current::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Current_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* RTCORBA::Current::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/Current:1.0";
}

int RTCORBA::Mutex::_tao_class_id = 0;

RTCORBA::Mutex_ptr
tao_RTCORBA_Mutex_duplicate (
    RTCORBA::Mutex_ptr p
  )
{
  return RTCORBA::Mutex::_duplicate (p);
}

void
tao_RTCORBA_Mutex_release (
    RTCORBA::Mutex_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::Mutex_ptr
tao_RTCORBA_Mutex_nil (
    void
  )
{
  return RTCORBA::Mutex::_nil ();
}

RTCORBA::Mutex_ptr
tao_RTCORBA_Mutex_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::Mutex::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_Mutex_upcast (
    void *src
  )
{
  RTCORBA::Mutex **tmp =
    ACE_static_cast (RTCORBA::Mutex **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::Mutex_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::Mutex_var::Mutex_var (void) // default constructor
  : ptr_ (Mutex::_nil ())
{}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::Mutex_var::Mutex_var (const ::RTCORBA::Mutex_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (Mutex::_duplicate (p.ptr ()))
{}

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

RTCORBA::Mutex_var &
RTCORBA::Mutex_var::operator= (Mutex_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::Mutex_var::operator const ::RTCORBA::Mutex_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::Mutex_var::operator ::RTCORBA::Mutex_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
  return this->ptr_;
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::Mutex_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
  return val;
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::tao_duplicate (Mutex_ptr p)
{
  return ::RTCORBA::Mutex::_duplicate (p);
}

void
RTCORBA::Mutex_var::tao_release (Mutex_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::tao_nil (void)
{
  return ::RTCORBA::Mutex::_nil ();
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::Mutex::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::Mutex_var::tao_upcast (void *src)
{
  Mutex **tmp =
    ACE_static_cast (Mutex **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::Mutex_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::Mutex_out::Mutex_out (Mutex_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
}

RTCORBA::Mutex_out::Mutex_out (Mutex_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::Mutex::_nil ();
}

RTCORBA::Mutex_out::Mutex_out (const ::RTCORBA::Mutex_out &p) // copy constructor
  : ptr_ (ACE_const_cast (Mutex_out &, p).ptr_)
{}

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

RTCORBA::Mutex_out &
RTCORBA::Mutex_out::operator= (const ::RTCORBA::Mutex_var &p)
{
  this->ptr_ = ::RTCORBA::Mutex::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::Mutex_out &
RTCORBA::Mutex_out::operator= (Mutex_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::Mutex_out::operator ::RTCORBA::Mutex_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr &
RTCORBA::Mutex_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::Mutex_ptr
RTCORBA::Mutex_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::Mutex::Mutex (void)
{}

RTCORBA::Mutex::~Mutex (void)
{}

RTCORBA::Mutex_ptr RTCORBA::Mutex::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return Mutex::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::Mutex_ptr
RTCORBA::Mutex::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return Mutex::_nil ();
  return
      ACE_reinterpret_cast
        (
          Mutex_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &Mutex::_tao_class_id
                  )
              )
        );
}

RTCORBA::Mutex_ptr
RTCORBA::Mutex::_duplicate (Mutex_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::Mutex::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, Mutex)::_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* RTCORBA::Mutex::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/Mutex:1.0";
}

int RTCORBA::RTORB::_tao_class_id = 0;

RTCORBA::RTORB_ptr
tao_RTCORBA_RTORB_duplicate (
    RTCORBA::RTORB_ptr p
  )
{
  return RTCORBA::RTORB::_duplicate (p);
}

void
tao_RTCORBA_RTORB_release (
    RTCORBA::RTORB_ptr p
  )
{
  CORBA::release (p);
}

RTCORBA::RTORB_ptr
tao_RTCORBA_RTORB_nil (
    void
  )
{
  return RTCORBA::RTORB::_nil ();
}

RTCORBA::RTORB_ptr
tao_RTCORBA_RTORB_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return RTCORBA::RTORB::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_RTCORBA_RTORB_upcast (
    void *src
  )
{
  RTCORBA::RTORB **tmp =
    ACE_static_cast (RTCORBA::RTORB **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::RTORB_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

RTCORBA::RTORB_var::RTORB_var (void) // default constructor
  : ptr_ (RTORB::_nil ())
{}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::ptr (void) const
{
  return this->ptr_;
}

RTCORBA::RTORB_var::RTORB_var (const ::RTCORBA::RTORB_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (RTORB::_duplicate (p.ptr ()))
{}

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

RTCORBA::RTORB_var &
RTCORBA::RTORB_var::operator= (RTORB_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

RTCORBA::RTORB_var::operator const ::RTCORBA::RTORB_ptr &() const // cast
{
  return this->ptr_;
}

RTCORBA::RTORB_var::operator ::RTCORBA::RTORB_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::operator-> (void) const
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::in (void) const
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_var::inout (void)
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
  return this->ptr_;
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::RTCORBA::RTORB_ptr val = this->ptr_;
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
  return val;
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::tao_duplicate (RTORB_ptr p)
{
  return ::RTCORBA::RTORB::_duplicate (p);
}

void
RTCORBA::RTORB_var::tao_release (RTORB_ptr p)
{
  CORBA::release (p);
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::tao_nil (void)
{
  return ::RTCORBA::RTORB::_nil ();
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::RTCORBA::RTORB::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
RTCORBA::RTORB_var::tao_upcast (void *src)
{
  RTORB **tmp =
    ACE_static_cast (RTORB **, src);
  return *tmp;
}

// *************************************************************
// RTCORBA::RTORB_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

RTCORBA::RTORB_out::RTORB_out (RTORB_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
}

RTCORBA::RTORB_out::RTORB_out (RTORB_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::RTCORBA::RTORB::_nil ();
}

RTCORBA::RTORB_out::RTORB_out (const ::RTCORBA::RTORB_out &p) // copy constructor
  : ptr_ (ACE_const_cast (RTORB_out &, p).ptr_)
{}

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

RTCORBA::RTORB_out &
RTCORBA::RTORB_out::operator= (const ::RTCORBA::RTORB_var &p)
{
  this->ptr_ = ::RTCORBA::RTORB::_duplicate (p.ptr ());
  return *this;
}

RTCORBA::RTORB_out &
RTCORBA::RTORB_out::operator= (RTORB_ptr p)
{
  this->ptr_ = p;
  return *this;
}

RTCORBA::RTORB_out::operator ::RTCORBA::RTORB_ptr &() // cast
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr &
RTCORBA::RTORB_out::ptr (void) // ptr
{
  return this->ptr_;
}

::RTCORBA::RTORB_ptr
RTCORBA::RTORB_out::operator-> (void)
{
  return this->ptr_;
}


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

RTCORBA::RTORB::RTORB (void)
{}

RTCORBA::RTORB::~RTORB (void)
{}

RTCORBA::RTORB_ptr RTCORBA::RTORB::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return RTORB::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

RTCORBA::RTORB_ptr
RTCORBA::RTORB::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return RTORB::_nil ();
  return
      ACE_reinterpret_cast
        (
          RTORB_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &RTORB::_tao_class_id
                  )
              )
        );
}

RTCORBA::RTORB_ptr
RTCORBA::RTORB::_duplicate (RTORB_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *RTCORBA::RTORB::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, RTORB)::_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* RTCORBA::RTORB::_interface_repository_id (void) const
{
  return "IDL:omg.org/RTCORBA/RTORB:1.0";
}

// Default constructor.
RTCORBA::RTORB::MutexNotFound::MutexNotFound (void)
  : CORBA_UserException ("IDL:omg.org/RTCORBA/RTORB/MutexNotFound:1.0")
{
}

// Destructor - all members are of self managing types.
RTCORBA::RTORB::MutexNotFound::~MutexNotFound (void)
{
}

// Copy constructor.
RTCORBA::RTORB::MutexNotFound::MutexNotFound (const ::RTCORBA::RTORB::MutexNotFound &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
}

// Assignment operator.
RTCORBA::RTORB::MutexNotFound&
RTCORBA::RTORB::MutexNotFound::operator= (const ::RTCORBA::RTORB::MutexNotFound &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

RTCORBA::RTORB::MutexNotFound *
RTCORBA::RTORB::MutexNotFound::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/RTCORBA/RTORB/MutexNotFound:1.0", exc->_id ()))
    {
      return ACE_dynamic_cast (MutexNotFound *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *RTCORBA::RTORB::MutexNotFound::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::RTCORBA::RTORB::MutexNotFound, 0);
  return retval;
}

CORBA::Exception *
RTCORBA::RTORB::MutexNotFound::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      RTCORBA::RTORB::MutexNotFound (*this),
      0
    );
  return result;
}

void RTCORBA::RTORB::MutexNotFound::_raise ()
{
  TAO_RAISE (*this);
}

void RTCORBA::RTORB::MutexNotFound::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void RTCORBA::RTORB::MutexNotFound::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

// Default constructor.
RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (void)
  : CORBA_UserException ("IDL:omg.org/RTCORBA/RTORB/InvalidThreadpool:1.0")
{
}

// Destructor - all members are of self managing types.
RTCORBA::RTORB::InvalidThreadpool::~InvalidThreadpool (void)
{
}

// Copy constructor.
RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (const ::RTCORBA::RTORB::InvalidThreadpool &_tao_excp)
  : CORBA_UserException (_tao_excp._id ())
{
}

// Assignment operator.
RTCORBA::RTORB::InvalidThreadpool&
RTCORBA::RTORB::InvalidThreadpool::operator= (const ::RTCORBA::RTORB::InvalidThreadpool &_tao_excp)
{
  this->CORBA_UserException::operator= (_tao_excp);
  return *this;
}

RTCORBA::RTORB::InvalidThreadpool *
RTCORBA::RTORB::InvalidThreadpool::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/RTCORBA/RTORB/InvalidThreadpool:1.0", exc->_id ()))
    {
      return ACE_dynamic_cast (InvalidThreadpool *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *RTCORBA::RTORB::InvalidThreadpool::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::RTCORBA::RTORB::InvalidThreadpool, 0);
  return retval;
}

CORBA::Exception *
RTCORBA::RTORB::InvalidThreadpool::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      RTCORBA::RTORB::InvalidThreadpool (*this),
      0
    );
  return result;
}

void RTCORBA::RTORB::InvalidThreadpool::_raise ()
{
  TAO_RAISE (*this);
}

void RTCORBA::RTORB::InvalidThreadpool::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void RTCORBA::RTORB::InvalidThreadpool::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

void operator<<= (CORBA::Any &_tao_any, const RTCORBA::ThreadpoolLane &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_ThreadpoolLane,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, RTCORBA::ThreadpoolLane *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_ThreadpoolLane,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      RTCORBA::ThreadpoolLane::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, RTCORBA::ThreadpoolLane *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const RTCORBA::ThreadpoolLane*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const RTCORBA::ThreadpoolLane *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (RTCORBA::_tc_ThreadpoolLane ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const RTCORBA::ThreadpoolLane*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      RTCORBA::ThreadpoolLane *tmp;
      ACE_NEW_RETURN (tmp, RTCORBA::ThreadpoolLane, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            RTCORBA::_tc_ThreadpoolLane,
            1,
            ACE_static_cast (void *, tmp),
            RTCORBA::ThreadpoolLane::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (
    CORBA::Any &_tao_any,
    const RTCORBA::ThreadpoolLanes &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        RTCORBA::_tc_ThreadpoolLanes,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, RTCORBA::ThreadpoolLanes *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_ThreadpoolLanes,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      RTCORBA::ThreadpoolLanes::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, RTCORBA::ThreadpoolLanes *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const RTCORBA::ThreadpoolLanes*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const RTCORBA::ThreadpoolLanes *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (RTCORBA::_tc_ThreadpoolLanes ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const RTCORBA::ThreadpoolLanes*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      RTCORBA::ThreadpoolLanes *tmp;
      ACE_NEW_RETURN (tmp, RTCORBA::ThreadpoolLanes, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            RTCORBA::_tc_ThreadpoolLanes,
            1,
            ACE_static_cast (void *, tmp),
            RTCORBA::ThreadpoolLanes::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (CORBA::Any &_tao_any, RTCORBA::PriorityModel _tao_elem)
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_PriorityModel,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, RTCORBA::PriorityModel &_tao_elem)
{
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (RTCORBA::_tc_PriorityModel 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)
    {
      return 1;
    }
  }
  ACE_CATCHANY
  {
    return 0;
  }
  ACE_ENDTRY;
  return 0;
}

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

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

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

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

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

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

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

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

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

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

void operator<<= (CORBA::Any &_tao_any, const RTCORBA::PriorityBand &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_PriorityBand,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, RTCORBA::PriorityBand *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_PriorityBand,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      RTCORBA::PriorityBand::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, RTCORBA::PriorityBand *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const RTCORBA::PriorityBand*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const RTCORBA::PriorityBand *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (RTCORBA::_tc_PriorityBand ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const RTCORBA::PriorityBand*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      RTCORBA::PriorityBand *tmp;
      ACE_NEW_RETURN (tmp, RTCORBA::PriorityBand, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            RTCORBA::_tc_PriorityBand,
            1,
            ACE_static_cast (void *, tmp),
            RTCORBA::PriorityBand::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (
    CORBA::Any &_tao_any,
    const RTCORBA::PriorityBands &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        RTCORBA::_tc_PriorityBands,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, RTCORBA::PriorityBands *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      RTCORBA::_tc_PriorityBands,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      RTCORBA::PriorityBands::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, RTCORBA::PriorityBands *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const RTCORBA::PriorityBands*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const RTCORBA::PriorityBands *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();

    CORBA::Boolean result = type->equivalent (RTCORBA::_tc_PriorityBands ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;

    if (!result)
      return 0; // not equivalent

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const RTCORBA::PriorityBands*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      RTCORBA::PriorityBands *tmp;
      ACE_NEW_RETURN (tmp, RTCORBA::PriorityBands, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            RTCORBA::_tc_PriorityBands,
            1,
            ACE_static_cast (void *, tmp),
            RTCORBA::PriorityBands::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

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

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

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

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

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::ThreadpoolLanes &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm << _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::ThreadpoolLanes &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    // set the length of the sequence
    _tao_sequence.length (_tao_seq_len);
    // If length is 0 we return true.
    if (0 >= _tao_seq_len)
      return 1;
    // Add a check to the length of the sequence
    // to make sure it does not exceed the length
    // of the stream. (See bug 58.)
    if (_tao_seq_len > strm.length())
      return 0;
    // retrieve all the elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm >> _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::PriorityBands &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm << _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::PriorityBands &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    // set the length of the sequence
    _tao_sequence.length (_tao_seq_len);
    // If length is 0 we return true.
    if (0 >= _tao_seq_len)
      return 1;
    // Add a check to the length of the sequence
    // to make sure it does not exceed the length
    // of the stream. (See bug 58.)
    if (_tao_seq_len > strm.length())
      return 0;
    // retrieve all the elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm >> _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}
