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

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

#include "RTCORBAC.h"

#if (TAO_HAS_RT_CORBA == 1)

#include "tao/Typecode.h"

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

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

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 *x)
{
  ThreadpoolLane *tmp = ACE_static_cast (ThreadpoolLane*,x);
  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 *x)
{
  ThreadpoolLanes *tmp = ACE_static_cast (ThreadpoolLanes*,x);
  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

// default constructor
RTCORBA::PriorityModelPolicy::PriorityModelPolicy ()
{
  }

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

RTCORBA::PriorityModelPolicy_ptr RTCORBA::PriorityModelPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return PriorityModelPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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

// default constructor
RTCORBA::ThreadpoolPolicy::ThreadpoolPolicy ()
{
  }

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

RTCORBA::ThreadpoolPolicy_ptr RTCORBA::ThreadpoolPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ThreadpoolPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::ProtocolProperties::ProtocolProperties ()
{
  }

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

RTCORBA::ProtocolProperties_ptr RTCORBA::ProtocolProperties::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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 *x)
{
  ProtocolList *tmp = ACE_static_cast (ProtocolList*,x);
  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

// default constructor
RTCORBA::ServerProtocolPolicy::ServerProtocolPolicy ()
{
  }

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

RTCORBA::ServerProtocolPolicy_ptr RTCORBA::ServerProtocolPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ServerProtocolPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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

// default constructor
RTCORBA::ClientProtocolPolicy::ClientProtocolPolicy ()
{
  }

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

RTCORBA::ClientProtocolPolicy_ptr RTCORBA::ClientProtocolPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ClientProtocolPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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

// default constructor
RTCORBA::PrivateConnectionPolicy::PrivateConnectionPolicy ()
{
  }

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

RTCORBA::PrivateConnectionPolicy_ptr RTCORBA::PrivateConnectionPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return PrivateConnectionPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}

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

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

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

// default constructor
RTCORBA::TCPProtocolProperties::TCPProtocolProperties ()
{
  }

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

RTCORBA::TCPProtocolProperties_ptr RTCORBA::TCPProtocolProperties::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return TCPProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::GIOPProtocolProperties::GIOPProtocolProperties ()
{
  }

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

RTCORBA::GIOPProtocolProperties_ptr RTCORBA::GIOPProtocolProperties::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return GIOPProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::UnixDomainProtocolProperties::UnixDomainProtocolProperties ()
{
  }

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

RTCORBA::UnixDomainProtocolProperties_ptr RTCORBA::UnixDomainProtocolProperties::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return UnixDomainProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::SharedMemoryProtocolProperties::SharedMemoryProtocolProperties ()
{
  }

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

RTCORBA::SharedMemoryProtocolProperties_ptr RTCORBA::SharedMemoryProtocolProperties::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return SharedMemoryProtocolProperties::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::RTCORBA, ProtocolProperties)::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            RTCORBA::ProtocolProperties_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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
  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,


};
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 *x)
{
  PriorityBand *tmp = ACE_static_cast (PriorityBand*,x);
  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 *x)
{
  PriorityBands *tmp = ACE_static_cast (PriorityBands*,x);
  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
  252, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    236, // 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
      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,



    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

// default constructor
RTCORBA::PriorityBandedConnectionPolicy::PriorityBandedConnectionPolicy ()
{
  }

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

RTCORBA::PriorityBandedConnectionPolicy_ptr RTCORBA::PriorityBandedConnectionPolicy::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return PriorityBandedConnectionPolicy::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Policy::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Policy_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::Current::Current ()
{
  }

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

RTCORBA::Current_ptr RTCORBA::Current::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return Current::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &::CORBA::Current::_narrow))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            CORBA::Current_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::Mutex::Mutex ()
{
  }

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

RTCORBA::Mutex_ptr RTCORBA::Mutex::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return Mutex::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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";
}


// default constructor
RTCORBA::RTORB::RTORB ()
{
  }

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

RTCORBA::RTORB_ptr RTCORBA::RTORB::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return RTORB::_unchecked_narrow (obj, ACE_TRY_ENV);
}

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

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)::_narrow))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow))
    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;
}

// Narrow.
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;
    }
}

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

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

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

// TAO extension - the _alloc method.
CORBA::Exception *RTCORBA::RTORB::MutexNotFound::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::RTCORBA::RTORB::MutexNotFound, 0);
  return retval;
}

// 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;
}

// Narrow.
RTCORBA::RTORB::InvalidThreadpool *
RTCORBA::RTORB::InvalidThreadpool::_narrow (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;
    }
}

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

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

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

// TAO extension - the _alloc method.
CORBA::Exception *RTCORBA::RTORB::InvalidThreadpool::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::RTCORBA::RTORB::InvalidThreadpool, 0);
  return retval;
}

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 ();
    if (!type->equivalent (RTCORBA::_tc_ThreadpoolLane, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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 ();
    if (!type->equivalent (RTCORBA::_tc_ThreadpoolLanes, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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 ();
    if (!type->equivalent (RTCORBA::_tc_PriorityModel, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    TAO_InputCDR stream (
        _tao_any._tao_get_cdr (),
        _tao_any._tao_byte_order ()
      );
    if (stream >> _tao_elem)
    {
      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 ();
    if (!type->equivalent (RTCORBA::_tc_PriorityBand, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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 ();
    if (!type->equivalent (RTCORBA::_tc_PriorityBands, ACE_TRY_ENV)) // not equal
      {
        return 0;
      }
    ACE_TRY_CHECK;
    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;
    // 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;
    // 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
}

#endif /* TAO_HAS_RT_CORBA == 1 */