// -*- 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 "miopC.h"

#include "tao/Stub.h"
#include "tao/Invocation.h"
#include "tao/ClientRequestInfo.h"
#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

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

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


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_BOUNDED_SEQUENCE_MIOP_UNIQUEID_252_CS_)
#define __TAO_BOUNDED_SEQUENCE_MIOP_UNIQUEID_252_CS_

  void
  MIOP::_TAO_Bounded_Sequence_MIOP_UniqueId_252::_allocate_buffer (CORBA::ULong /* length */)
  // allocate a buffer of the requested length. The buffer is allocated for the
  // right type
  {
    this->buffer_ = _TAO_Bounded_Sequence_MIOP_UniqueId_252::allocbuf (252U);
  }

  void
  MIOP::_TAO_Bounded_Sequence_MIOP_UniqueId_252::_deallocate_buffer (void)
  // deallocate the buffer
  {
    if (this->buffer_ == 0 || this->release_ == 0)
      return;
    CORBA::Octet *tmp = ACE_reinterpret_cast (CORBA::Octet *, this->buffer_);
    _TAO_Bounded_Sequence_MIOP_UniqueId_252::freebuf (tmp);
    this->buffer_ = 0;
  }

  MIOP::_TAO_Bounded_Sequence_MIOP_UniqueId_252::~_TAO_Bounded_Sequence_MIOP_UniqueId_252 (void) // Dtor.
  {
    this->_deallocate_buffer ();
  }


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_MIOP_UNIQUEID_CS_)
#define _MIOP_UNIQUEID_CS_

// *************************************************************
// MIOP::UniqueId
// *************************************************************

MIOP::UniqueId::UniqueId (void)
{}
MIOP::UniqueId::UniqueId (CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release)
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  _TAO_Bounded_Sequence_MIOP_UniqueId_252
#else /* TAO_USE_SEQUENCE_TEMPLATES */
  TAO_Bounded_Sequence<CORBA::Octet, 252U>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (length, buffer, release)
{}
MIOP::UniqueId::UniqueId (const UniqueId &seq) // copy ctor
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  _TAO_Bounded_Sequence_MIOP_UniqueId_252
#else /* TAO_USE_SEQUENCE_TEMPLATES */
  TAO_Bounded_Sequence<CORBA::Octet, 252U>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (seq)
{}
MIOP::UniqueId::~UniqueId (void) // dtor
{}
void MIOP::UniqueId::_tao_any_destructor (void *x)
{
  UniqueId *tmp = ACE_static_cast (UniqueId*,x);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_MIOP_UniqueId[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  30,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f556e69),
  ACE_NTOHL (0x71756549),
  ACE_NTOHL (0x643a312e),
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/MIOP/UniqueId:1.0
  9,
  ACE_NTOHL (0x556e6971),
  ACE_NTOHL (0x75654964),
  ACE_NTOHL (0x0),  // name = UniqueId
  CORBA::tk_sequence, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_octet,

    252U,

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_UniqueId (
    CORBA::tk_alias,
    sizeof (_oc_MIOP_UniqueId),
    (char *) &_oc_MIOP_UniqueId,
    0,
    sizeof (MIOP::UniqueId)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UniqueId, &_tc_TAO_tc_MIOP_UniqueId)
TAO_NAMESPACE_END

static const CORBA::Long _oc_MIOP_PacketHeader_1_0[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f506163),
  ACE_NTOHL (0x6b657448),
  ACE_NTOHL (0x65616465),
  ACE_NTOHL (0x725f315f),
  ACE_NTOHL (0x303a312e),
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/MIOP/PacketHeader_1_0:1.0
  17,
  ACE_NTOHL (0x5061636b),
  ACE_NTOHL (0x65744865),
  ACE_NTOHL (0x61646572),
  ACE_NTOHL (0x5f315f30),
  ACE_NTOHL (0x0),  // name = PacketHeader_1_0
  7, // member count
  6,
  ACE_NTOHL (0x6d616769),
  ACE_NTOHL (0x63000000),  // name = magic
  CORBA::tk_array, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_char,

    4U,

  12,
  ACE_NTOHL (0x6864725f),
  ACE_NTOHL (0x76657273),
  ACE_NTOHL (0x696f6e00),  // name = hdr_version
  CORBA::tk_octet,

  6,
  ACE_NTOHL (0x666c6167),
  ACE_NTOHL (0x73000000),  // name = flags
  CORBA::tk_octet,

  14,
  ACE_NTOHL (0x7061636b),
  ACE_NTOHL (0x65745f6c),
  ACE_NTOHL (0x656e6774),
  ACE_NTOHL (0x68000000),  // name = packet_length
  CORBA::tk_ushort,

  14,
  ACE_NTOHL (0x7061636b),
  ACE_NTOHL (0x65745f6e),
  ACE_NTOHL (0x756d6265),
  ACE_NTOHL (0x72000000),  // name = packet_number
  CORBA::tk_ulong,

  18,
  ACE_NTOHL (0x6e756d62),
  ACE_NTOHL (0x65725f6f),
  ACE_NTOHL (0x665f7061),
  ACE_NTOHL (0x636b6574),
  ACE_NTOHL (0x73000000),  // name = number_of_packets
  CORBA::tk_ulong,

  3,
  ACE_NTOHL (0x49640000),  // name = Id
  CORBA::tk_alias, // typecode kind for typedefs
  76, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    30,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x4d494f50),
    ACE_NTOHL (0x2f556e69),
    ACE_NTOHL (0x71756549),
    ACE_NTOHL (0x643a312e),
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/MIOP/UniqueId:1.0
    9,
    ACE_NTOHL (0x556e6971),
    ACE_NTOHL (0x75654964),
    ACE_NTOHL (0x0),  // name = UniqueId
    CORBA::tk_sequence, // typecode kind
    12, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_octet,

      252U,


};

static CORBA::TypeCode _tc_TAO_tc_MIOP_PacketHeader_1_0 (
    CORBA::tk_struct,
    sizeof (_oc_MIOP_PacketHeader_1_0),
    (char *) &_oc_MIOP_PacketHeader_1_0,
    0,
    sizeof (MIOP::PacketHeader_1_0)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PacketHeader_1_0, &_tc_TAO_tc_MIOP_PacketHeader_1_0)
TAO_NAMESPACE_END

void MIOP::PacketHeader_1_0::_tao_any_destructor (void *x)
{
  PacketHeader_1_0 *tmp = ACE_static_cast (PacketHeader_1_0*,x);
  delete tmp;
}

void MIOP::PacketHeader_1_0::_magic_forany::_tao_any_destructor (void *x)
{
  _magic_slice *tmp = ACE_static_cast (_magic_slice*,x);
  _magic_free (tmp);
}

MIOP::PacketHeader_1_0::_magic_slice *
MIOP::PacketHeader_1_0::_magic_dup (const MIOP::PacketHeader_1_0::_magic_slice *_tao_src_array)
{
  MIOP::PacketHeader_1_0::_magic_slice *_tao_dup_array = MIOP::PacketHeader_1_0::_magic_alloc ();
  if (!_tao_dup_array) return (MIOP::PacketHeader_1_0::_magic_slice *)0;
  MIOP::PacketHeader_1_0::_magic_copy (_tao_dup_array, _tao_src_array);
  return _tao_dup_array;
}

MIOP::PacketHeader_1_0::_magic_slice *
MIOP::PacketHeader_1_0::_magic_alloc (void)
{
  MIOP::PacketHeader_1_0::_magic_slice *retval = 0;
  ACE_NEW_RETURN (retval, CORBA::Char[4], 0);
  return retval;
}

void
MIOP::PacketHeader_1_0::_magic_free (MIOP::PacketHeader_1_0::_magic_slice *_tao_slice)
{
  delete [] _tao_slice;
}

void
MIOP::PacketHeader_1_0::_magic_copy (MIOP::PacketHeader_1_0::_magic_slice * _tao_to, const MIOP::PacketHeader_1_0::_magic_slice *_tao_from)
{
  // copy each individual element
  for (CORBA::ULong i0 = 0; i0 < 4; i0++)
    _tao_to[i0] = _tao_from[i0];
}

static const CORBA::Long _oc_MIOP_Version[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  29,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f566572),
  ACE_NTOHL (0x73696f6e),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/MIOP/Version:1.0
  8,
  ACE_NTOHL (0x56657273),
  ACE_NTOHL (0x696f6e00),  // name = Version
  2, // member count
  6,
  ACE_NTOHL (0x6d616a6f),
  ACE_NTOHL (0x72000000),  // name = major
  CORBA::tk_octet,

  6,
  ACE_NTOHL (0x6d696e6f),
  ACE_NTOHL (0x72000000),  // name = minor
  CORBA::tk_octet,

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_Version (
    CORBA::tk_struct,
    sizeof (_oc_MIOP_Version),
    (char *) &_oc_MIOP_Version,
    0,
    sizeof (MIOP::Version)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Version, &_tc_TAO_tc_MIOP_Version)
TAO_NAMESPACE_END

void MIOP::Version::_tao_any_destructor (void *x)
{
  Version *tmp = ACE_static_cast (Version*,x);
  delete tmp;
}

static const CORBA::Long _oc_MIOP_IPVersion[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f495056),
  ACE_NTOHL (0x65727369),
  ACE_NTOHL (0x6f6e3a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/IPVersion:1.0
  10,
  ACE_NTOHL (0x49505665),
  ACE_NTOHL (0x7273696f),
  ACE_NTOHL (0x6e000000),  // name = IPVersion
  CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_IPVersion (
    CORBA::tk_alias,
    sizeof (_oc_MIOP_IPVersion),
    (char *) &_oc_MIOP_IPVersion,
    0,
    sizeof (MIOP::IPVersion)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IPVersion, &_tc_TAO_tc_MIOP_IPVersion)
TAO_NAMESPACE_END

TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (const CORBA::Short, IPv4, 0)
TAO_NAMESPACE_END
TAO_NAMESPACE_TYPE (const CORBA::Short)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (const CORBA::Short, IPv6, 1)
TAO_NAMESPACE_END
static const CORBA::Long _oc_MIOP_UsingIpv4[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f557369),
  ACE_NTOHL (0x6e674970),
  ACE_NTOHL (0x76343a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv4:1.0
  10,
  ACE_NTOHL (0x5573696e),
  ACE_NTOHL (0x67497076),
  ACE_NTOHL (0x34000000),  // name = UsingIpv4
  2, // member count
  5,
  ACE_NTOHL (0x706f7274),
  ACE_NTOHL (0x0),  // name = port
  CORBA::tk_ushort,

  16,
  ACE_NTOHL (0x636c6173),
  ACE_NTOHL (0x735f645f),
  ACE_NTOHL (0x61646472),
  ACE_NTOHL (0x65737300),  // name = class_d_address
  CORBA::tk_array, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_octet,

    4U,

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_UsingIpv4 (
    CORBA::tk_struct,
    sizeof (_oc_MIOP_UsingIpv4),
    (char *) &_oc_MIOP_UsingIpv4,
    0,
    sizeof (MIOP::UsingIpv4)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsingIpv4, &_tc_TAO_tc_MIOP_UsingIpv4)
TAO_NAMESPACE_END

void MIOP::UsingIpv4::_tao_any_destructor (void *x)
{
  UsingIpv4 *tmp = ACE_static_cast (UsingIpv4*,x);
  delete tmp;
}

void MIOP::UsingIpv4::_class_d_address_forany::_tao_any_destructor (void *x)
{
  _class_d_address_slice *tmp = ACE_static_cast (_class_d_address_slice*,x);
  _class_d_address_free (tmp);
}

MIOP::UsingIpv4::_class_d_address_slice *
MIOP::UsingIpv4::_class_d_address_dup (const MIOP::UsingIpv4::_class_d_address_slice *_tao_src_array)
{
  MIOP::UsingIpv4::_class_d_address_slice *_tao_dup_array = MIOP::UsingIpv4::_class_d_address_alloc ();
  if (!_tao_dup_array) return (MIOP::UsingIpv4::_class_d_address_slice *)0;
  MIOP::UsingIpv4::_class_d_address_copy (_tao_dup_array, _tao_src_array);
  return _tao_dup_array;
}

MIOP::UsingIpv4::_class_d_address_slice *
MIOP::UsingIpv4::_class_d_address_alloc (void)
{
  MIOP::UsingIpv4::_class_d_address_slice *retval = 0;
  ACE_NEW_RETURN (retval, CORBA::Octet[4], 0);
  return retval;
}

void
MIOP::UsingIpv4::_class_d_address_free (MIOP::UsingIpv4::_class_d_address_slice *_tao_slice)
{
  delete [] _tao_slice;
}

void
MIOP::UsingIpv4::_class_d_address_copy (MIOP::UsingIpv4::_class_d_address_slice * _tao_to, const MIOP::UsingIpv4::_class_d_address_slice *_tao_from)
{
  // copy each individual element
  for (CORBA::ULong i0 = 0; i0 < 4; i0++)
    _tao_to[i0] = _tao_from[i0];
}

static const CORBA::Long _oc_MIOP_UsingIpv6[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f557369),
  ACE_NTOHL (0x6e674970),
  ACE_NTOHL (0x76363a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv6:1.0
  10,
  ACE_NTOHL (0x5573696e),
  ACE_NTOHL (0x67497076),
  ACE_NTOHL (0x36000000),  // name = UsingIpv6
  2, // member count
  5,
  ACE_NTOHL (0x706f7274),
  ACE_NTOHL (0x0),  // name = port
  CORBA::tk_ulong,

  8,
  ACE_NTOHL (0x61646472),
  ACE_NTOHL (0x65737300),  // name = address
  CORBA::tk_string,
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_MIOP_UsingIpv6 (
    CORBA::tk_struct,
    sizeof (_oc_MIOP_UsingIpv6),
    (char *) &_oc_MIOP_UsingIpv6,
    0,
    sizeof (MIOP::UsingIpv6)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsingIpv6, &_tc_TAO_tc_MIOP_UsingIpv6)
TAO_NAMESPACE_END

void MIOP::UsingIpv6::_tao_any_destructor (void *x)
{
  UsingIpv6 *tmp = ACE_static_cast (UsingIpv6*,x);
  delete tmp;
}

// *************************************************************
// Operations for union MIOP::IPEndpoints
// *************************************************************

// default constructor
MIOP::IPEndpoints::IPEndpoints (void)
{
  ACE_OS::memset (&this->disc_, 0, sizeof (this->disc_));
  ACE_OS::memset (&this->u_, 0, sizeof (this->u_));
  this->disc_ = 0;
}

// copy constructor
MIOP::IPEndpoints::IPEndpoints (const ::MIOP::IPEndpoints &u)
{
  this->disc_ = u.disc_;
  switch (this->disc_)
  {
case 0:
    {
      this->u_.ipv4_endpoints_ = u.u_.ipv4_endpoints_;
    }
    break;
    case 1:
    {
      if (u.u_.ipv6_endpoints_ == 0)
        {
          this->u_.ipv6_endpoints_ = 0;
        }
      else
        {
          ACE_NEW (
              this->u_.ipv6_endpoints_,
              MIOP::UsingIpv6 (*u.u_.ipv6_endpoints_)
            );
        }
    }
    break;
        default:
    break;
  }
}

// destructor
MIOP::IPEndpoints::~IPEndpoints (void)
{
  // finalize
  this->_reset (this->disc_, 1);
}

void MIOP::IPEndpoints::_tao_any_destructor (void *x)
{
  IPEndpoints *tmp = ACE_static_cast (IPEndpoints*,x);
  delete tmp;
}

// assignment operator
MIOP::IPEndpoints &
MIOP::IPEndpoints::operator= (const ::MIOP::IPEndpoints &u)
{
  if (&u == this)
    {
      return *this;
    }

  this->_reset (u.disc_, 0);
  this->disc_ = u.disc_;

  switch (this->disc_)
  {
    case 0:
    {
      this->u_.ipv4_endpoints_ = u.u_.ipv4_endpoints_;
    }
    break;
    case 1:
    {
      if (u.u_.ipv6_endpoints_ == 0)
        {
          this->u_.ipv6_endpoints_ = 0;
        }
      else
        {
          ACE_NEW_RETURN (
              this->u_.ipv6_endpoints_,
              MIOP::UsingIpv6 (*u.u_.ipv6_endpoints_),
              *this
            );
        }
    }
    break;
    default:
    break;
  }

  return *this;
}

// reset method to reset old values of a union
void MIOP::IPEndpoints::_reset (CORBA::Short, CORBA::Boolean /*finalize*/)
{
  switch (this->disc_)
  {
    case 0:
      break;
    case 1:
      delete this->u_.ipv6_endpoints_;
      this->u_.ipv6_endpoints_ = 0;
      break;
    default:
      break;
  }
}

static const CORBA::Long _oc_MIOP_IPEndpoints[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  33,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f495045),
  ACE_NTOHL (0x6e64706f),
  ACE_NTOHL (0x696e7473),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/MIOP/IPEndpoints:1.0
  12,
  ACE_NTOHL (0x4950456e),
  ACE_NTOHL (0x64706f69),
  ACE_NTOHL (0x6e747300),  // name = IPEndpoints
  CORBA::tk_short,

  -1, // default used index
  2, // member count
  ACE_IDL_NSTOHL (0x0000), // union case label (evaluated value)
  15,
  ACE_NTOHL (0x69707634),
  ACE_NTOHL (0x5f656e64),
  ACE_NTOHL (0x706f696e),
  ACE_NTOHL (0x74730000),  // name = ipv4_endpoints
  CORBA::tk_struct, // typecode kind
  116, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    31,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x4d494f50),
    ACE_NTOHL (0x2f557369),
    ACE_NTOHL (0x6e674970),
    ACE_NTOHL (0x76343a31),
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv4:1.0
    10,
    ACE_NTOHL (0x5573696e),
    ACE_NTOHL (0x67497076),
    ACE_NTOHL (0x34000000),  // name = UsingIpv4
    2, // member count
    5,
    ACE_NTOHL (0x706f7274),
    ACE_NTOHL (0x0),  // name = port
    CORBA::tk_ushort,

    16,
    ACE_NTOHL (0x636c6173),
    ACE_NTOHL (0x735f645f),
    ACE_NTOHL (0x61646472),
    ACE_NTOHL (0x65737300),  // name = class_d_address
    CORBA::tk_array, // typecode kind
    12, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_octet,

      4U,


  ACE_IDL_NSTOHL (0x0001), // union case label (evaluated value)
  15,
  ACE_NTOHL (0x69707636),
  ACE_NTOHL (0x5f656e64),
  ACE_NTOHL (0x706f696e),
  ACE_NTOHL (0x74730000),  // name = ipv6_endpoints
  CORBA::tk_struct, // typecode kind
  96, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    31,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x4d494f50),
    ACE_NTOHL (0x2f557369),
    ACE_NTOHL (0x6e674970),
    ACE_NTOHL (0x76363a31),
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv6:1.0
    10,
    ACE_NTOHL (0x5573696e),
    ACE_NTOHL (0x67497076),
    ACE_NTOHL (0x36000000),  // name = UsingIpv6
    2, // member count
    5,
    ACE_NTOHL (0x706f7274),
    ACE_NTOHL (0x0),  // name = port
    CORBA::tk_ulong,

    8,
    ACE_NTOHL (0x61646472),
    ACE_NTOHL (0x65737300),  // name = address
    CORBA::tk_string,
    0U, // string length

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_IPEndpoints (
    CORBA::tk_union,
    sizeof (_oc_MIOP_IPEndpoints),
    (char *) &_oc_MIOP_IPEndpoints,
    0,
    sizeof (MIOP::IPEndpoints)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IPEndpoints, &_tc_TAO_tc_MIOP_IPEndpoints)
TAO_NAMESPACE_END

static const CORBA::Long _oc_MIOP_UIPMC_ProfileBody[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x4d494f50),
  ACE_NTOHL (0x2f554950),
  ACE_NTOHL (0x4d435f50),
  ACE_NTOHL (0x726f6669),
  ACE_NTOHL (0x6c65426f),
  ACE_NTOHL (0x64793a31),
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UIPMC_ProfileBody:1.0
  18,
  ACE_NTOHL (0x5549504d),
  ACE_NTOHL (0x435f5072),
  ACE_NTOHL (0x6f66696c),
  ACE_NTOHL (0x65426f64),
  ACE_NTOHL (0x79000000),  // name = UIPMC_ProfileBody
  3, // member count
  13,
  ACE_NTOHL (0x6d696f70),
  ACE_NTOHL (0x5f766572),
  ACE_NTOHL (0x73696f6e),
  ACE_NTOHL (0x0),  // name = miop_version
  CORBA::tk_struct, // typecode kind
  88, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    29,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x4d494f50),
    ACE_NTOHL (0x2f566572),
    ACE_NTOHL (0x73696f6e),
    ACE_NTOHL (0x3a312e30),
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/MIOP/Version:1.0
    8,
    ACE_NTOHL (0x56657273),
    ACE_NTOHL (0x696f6e00),  // name = Version
    2, // member count
    6,
    ACE_NTOHL (0x6d616a6f),
    ACE_NTOHL (0x72000000),  // name = major
    CORBA::tk_octet,

    6,
    ACE_NTOHL (0x6d696e6f),
    ACE_NTOHL (0x72000000),  // name = minor
    CORBA::tk_octet,


  10,
  ACE_NTOHL (0x656e6470),
  ACE_NTOHL (0x6f696e74),
  ACE_NTOHL (0x73000000),  // name = endpoints
  CORBA::tk_union, // typecode kind
  348, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x4d494f50),
    ACE_NTOHL (0x2f495045),
    ACE_NTOHL (0x6e64706f),
    ACE_NTOHL (0x696e7473),
    ACE_NTOHL (0x3a312e30),
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/MIOP/IPEndpoints:1.0
    12,
    ACE_NTOHL (0x4950456e),
    ACE_NTOHL (0x64706f69),
    ACE_NTOHL (0x6e747300),  // name = IPEndpoints
    CORBA::tk_short,

    -1, // default used index
    2, // member count
    ACE_IDL_NSTOHL (0x0000), // union case label (evaluated value)
    15,
    ACE_NTOHL (0x69707634),
    ACE_NTOHL (0x5f656e64),
    ACE_NTOHL (0x706f696e),
    ACE_NTOHL (0x74730000),  // name = ipv4_endpoints
    CORBA::tk_struct, // typecode kind
    116, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a),
      ACE_NTOHL (0x6f6d672e),
      ACE_NTOHL (0x6f72672f),
      ACE_NTOHL (0x4d494f50),
      ACE_NTOHL (0x2f557369),
      ACE_NTOHL (0x6e674970),
      ACE_NTOHL (0x76343a31),
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv4:1.0
      10,
      ACE_NTOHL (0x5573696e),
      ACE_NTOHL (0x67497076),
      ACE_NTOHL (0x34000000),  // name = UsingIpv4
      2, // member count
      5,
      ACE_NTOHL (0x706f7274),
      ACE_NTOHL (0x0),  // name = port
      CORBA::tk_ushort,

      16,
      ACE_NTOHL (0x636c6173),
      ACE_NTOHL (0x735f645f),
      ACE_NTOHL (0x61646472),
      ACE_NTOHL (0x65737300),  // name = class_d_address
      CORBA::tk_array, // typecode kind
      12, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        CORBA::tk_octet,

        4U,


    ACE_IDL_NSTOHL (0x0001), // union case label (evaluated value)
    15,
    ACE_NTOHL (0x69707636),
    ACE_NTOHL (0x5f656e64),
    ACE_NTOHL (0x706f696e),
    ACE_NTOHL (0x74730000),  // name = ipv6_endpoints
    CORBA::tk_struct, // typecode kind
    96, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a),
      ACE_NTOHL (0x6f6d672e),
      ACE_NTOHL (0x6f72672f),
      ACE_NTOHL (0x4d494f50),
      ACE_NTOHL (0x2f557369),
      ACE_NTOHL (0x6e674970),
      ACE_NTOHL (0x76363a31),
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/MIOP/UsingIpv6:1.0
      10,
      ACE_NTOHL (0x5573696e),
      ACE_NTOHL (0x67497076),
      ACE_NTOHL (0x36000000),  // name = UsingIpv6
      2, // member count
      5,
      ACE_NTOHL (0x706f7274),
      ACE_NTOHL (0x0),  // name = port
      CORBA::tk_ulong,

      8,
      ACE_NTOHL (0x61646472),
      ACE_NTOHL (0x65737300),  // name = address
      CORBA::tk_string,
      0U, // string length


  11,
  ACE_NTOHL (0x636f6d70),
  ACE_NTOHL (0x6f6e656e),
  ACE_NTOHL (0x74730000),  // name = components
  CORBA::tk_sequence, // typecode kind
  200, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    184, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      36,
      ACE_NTOHL (0x49444c3a),
      ACE_NTOHL (0x6f6d672e),
      ACE_NTOHL (0x6f72672f),
      ACE_NTOHL (0x494f502f),
      ACE_NTOHL (0x54616767),
      ACE_NTOHL (0x6564436f),
      ACE_NTOHL (0x6d706f6e),
      ACE_NTOHL (0x656e743a),
      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IOP/TaggedComponent:1.0
      16,
      ACE_NTOHL (0x54616767),
      ACE_NTOHL (0x6564436f),
      ACE_NTOHL (0x6d706f6e),
      ACE_NTOHL (0x656e7400),  // name = TaggedComponent
      2, // member count
      4,
      ACE_NTOHL (0x74616700),  // name = tag
      CORBA::tk_alias, // typecode kind for typedefs
      60, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        32,
        ACE_NTOHL (0x49444c3a),
        ACE_NTOHL (0x6f6d672e),
        ACE_NTOHL (0x6f72672f),
        ACE_NTOHL (0x494f502f),
        ACE_NTOHL (0x436f6d70),
        ACE_NTOHL (0x6f6e656e),
        ACE_NTOHL (0x7449643a),
        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IOP/ComponentId:1.0
        12,
        ACE_NTOHL (0x436f6d70),
        ACE_NTOHL (0x6f6e656e),
        ACE_NTOHL (0x74496400),  // name = ComponentId
        CORBA::tk_ulong,


      15,
      ACE_NTOHL (0x636f6d70),
      ACE_NTOHL (0x6f6e656e),
      ACE_NTOHL (0x745f6461),
      ACE_NTOHL (0x74610000),  // name = component_data
      CORBA::tk_sequence, // typecode kind
      12, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        CORBA::tk_octet,

        0U,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_MIOP_UIPMC_ProfileBody (
    CORBA::tk_struct,
    sizeof (_oc_MIOP_UIPMC_ProfileBody),
    (char *) &_oc_MIOP_UIPMC_ProfileBody,
    0,
    sizeof (MIOP::UIPMC_ProfileBody)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (MIOP)
TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UIPMC_ProfileBody, &_tc_TAO_tc_MIOP_UIPMC_ProfileBody)
TAO_NAMESPACE_END

void MIOP::UIPMC_ProfileBody::_tao_any_destructor (void *x)
{
  UIPMC_ProfileBody *tmp = ACE_static_cast (UIPMC_ProfileBody*,x);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_MIOP_UIPMC_PROFILEBODY__TAO_SEQ_TAGGEDCOMPONENT_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_MIOP_UIPMC_PROFILEBODY__TAO_SEQ_TAGGEDCOMPONENT_CS_

  void
  MIOP::UIPMC_ProfileBody::_TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent::_allocate_buffer (CORBA::ULong length)
  {
    IOP::TaggedComponent* tmp = 0;
    tmp = _TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent::allocbuf (length);

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

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

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

    }
    this->buffer_ = tmp;
  }

  void
  MIOP::UIPMC_ProfileBody::_TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent::_deallocate_buffer (void)
  {
    if (this->buffer_ == 0 || this->release_ == 0)
      return;

    IOP::TaggedComponent *tmp = ACE_reinterpret_cast (IOP::TaggedComponent *,this->buffer_);

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

  MIOP::UIPMC_ProfileBody::_TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent::~_TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent (void) // Dtor.
  {
    this->_deallocate_buffer ();
  }


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */

#if !defined (_MIOP_UIPMC_PROFILEBODY__TAO_SEQ_TAGGEDCOMPONENT_CS_)
#define _MIOP_UIPMC_PROFILEBODY__TAO_SEQ_TAGGEDCOMPONENT_CS_

// *************************************************************
// MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent
// *************************************************************

MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::_tao_seq_TaggedComponent (void)
{}
MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::_tao_seq_TaggedComponent (CORBA::ULong max) // uses max size
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  _TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent
#else /* TAO_USE_SEQUENCE_TEMPLATES */
  TAO_Unbounded_Sequence<IOP::TaggedComponent>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max)
{}
MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::_tao_seq_TaggedComponent (CORBA::ULong max, CORBA::ULong length, IOP::TaggedComponent *buffer, CORBA::Boolean release)
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  _TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent
#else /* TAO_USE_SEQUENCE_TEMPLATES */
  TAO_Unbounded_Sequence<IOP::TaggedComponent>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (max, length, buffer, release)
{}
MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::_tao_seq_TaggedComponent (const _tao_seq_TaggedComponent &seq) // copy ctor
  :
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
  _TAO_Unbounded_Sequence_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent
#else /* TAO_USE_SEQUENCE_TEMPLATES */
  TAO_Unbounded_Sequence<IOP::TaggedComponent>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 (seq)
{}
MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::~_tao_seq_TaggedComponent (void) // dtor
{}
void MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent::_tao_any_destructor (void *x)
{
  _tao_seq_TaggedComponent *tmp = ACE_static_cast (_tao_seq_TaggedComponent*,x);
  delete tmp;
}


#endif /* end #if !defined */

MIOP::MulticastObjectGroupFactory_ptr
tao_MIOP_MulticastObjectGroupFactory_duplicate (
    MIOP::MulticastObjectGroupFactory_ptr p
  )
{
  return MIOP::MulticastObjectGroupFactory::_duplicate (p);
}

void
tao_MIOP_MulticastObjectGroupFactory_release (
    MIOP::MulticastObjectGroupFactory_ptr p
  )
{
  CORBA::release (p);
}

MIOP::MulticastObjectGroupFactory_ptr
tao_MIOP_MulticastObjectGroupFactory_nil (
    void
  )
{
  return MIOP::MulticastObjectGroupFactory::_nil ();
}

MIOP::MulticastObjectGroupFactory_ptr
tao_MIOP_MulticastObjectGroupFactory_narrow (
    CORBA::Object *p,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return MIOP::MulticastObjectGroupFactory::_narrow (p, ACE_TRY_ENV);
}

CORBA::Object *
tao_MIOP_MulticastObjectGroupFactory_upcast (
    void *src
  )
{
  MIOP::MulticastObjectGroupFactory **tmp =
    ACE_static_cast (MIOP::MulticastObjectGroupFactory **, src);
  return *tmp;
}

// *************************************************************
// Operations for class MIOP::MulticastObjectGroupFactory_var
// *************************************************************

MIOP::MulticastObjectGroupFactory_var::MulticastObjectGroupFactory_var (void) // default constructor
  : ptr_ (MulticastObjectGroupFactory::_nil ())
{}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::ptr (void) const
{
  return this->ptr_;
}

MIOP::MulticastObjectGroupFactory_var::MulticastObjectGroupFactory_var (const ::MIOP::MulticastObjectGroupFactory_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (MulticastObjectGroupFactory::_duplicate (p.ptr ()))
{}

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

MIOP::MulticastObjectGroupFactory_var &
MIOP::MulticastObjectGroupFactory_var::operator= (MulticastObjectGroupFactory_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

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

MIOP::MulticastObjectGroupFactory_var::operator const ::MIOP::MulticastObjectGroupFactory_ptr &() const // cast
{
  return this->ptr_;
}

MIOP::MulticastObjectGroupFactory_var::operator ::MIOP::MulticastObjectGroupFactory_ptr &() // cast
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::operator-> (void) const
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::in (void) const
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr &
MIOP::MulticastObjectGroupFactory_var::inout (void)
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr &
MIOP::MulticastObjectGroupFactory_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::MIOP::MulticastObjectGroupFactory::_nil ();
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::MIOP::MulticastObjectGroupFactory_ptr val = this->ptr_;
  this->ptr_ = ::MIOP::MulticastObjectGroupFactory::_nil ();
  return val;
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::duplicate (MulticastObjectGroupFactory_ptr p)
{
  return ::MIOP::MulticastObjectGroupFactory::_duplicate (p);
}

void
MIOP::MulticastObjectGroupFactory_var::release (MulticastObjectGroupFactory_ptr p)
{
  CORBA::release (p);
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::nil (void)
{
  return ::MIOP::MulticastObjectGroupFactory::_nil ();
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_var::narrow (
    CORBA::Object *p,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return ::MIOP::MulticastObjectGroupFactory::_narrow (p, ACE_TRY_ENV);
}

CORBA::Object *
MIOP::MulticastObjectGroupFactory_var::upcast (void *src)
{
  MulticastObjectGroupFactory **tmp =
    ACE_static_cast (MulticastObjectGroupFactory **, src);
  return *tmp;
}

// *************************************************************
// Operations for class MIOP::MulticastObjectGroupFactory_out
// *************************************************************

MIOP::MulticastObjectGroupFactory_out::MulticastObjectGroupFactory_out (MulticastObjectGroupFactory_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::MIOP::MulticastObjectGroupFactory::_nil ();
}

MIOP::MulticastObjectGroupFactory_out::MulticastObjectGroupFactory_out (MulticastObjectGroupFactory_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::MIOP::MulticastObjectGroupFactory::_nil ();
}

MIOP::MulticastObjectGroupFactory_out::MulticastObjectGroupFactory_out (const ::MIOP::MulticastObjectGroupFactory_out &p) // copy constructor
  : ptr_ (ACE_const_cast (MulticastObjectGroupFactory_out &, p).ptr_)
{}

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

MIOP::MulticastObjectGroupFactory_out &
MIOP::MulticastObjectGroupFactory_out::operator= (const ::MIOP::MulticastObjectGroupFactory_var &p)
{
  this->ptr_ = ::MIOP::MulticastObjectGroupFactory::_duplicate (p.ptr ());
  return *this;
}

MIOP::MulticastObjectGroupFactory_out &
MIOP::MulticastObjectGroupFactory_out::operator= (MulticastObjectGroupFactory_ptr p)
{
  this->ptr_ = p;
  return *this;
}

MIOP::MulticastObjectGroupFactory_out::operator ::MIOP::MulticastObjectGroupFactory_ptr &() // cast
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr &
MIOP::MulticastObjectGroupFactory_out::ptr (void) // ptr
{
  return this->ptr_;
}

::MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory_out::operator-> (void)
{
  return this->ptr_;
}


// default constructor
MIOP::MulticastObjectGroupFactory::MulticastObjectGroupFactory ()
{
  }

// destructor
MIOP::MulticastObjectGroupFactory::~MulticastObjectGroupFactory (void)
{}

MIOP::MulticastObjectGroupFactory_ptr MIOP::MulticastObjectGroupFactory::_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &ACE_TRY_ENV
  )
{
  return MulticastObjectGroupFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
}

MIOP::MulticastObjectGroupFactory_ptr MIOP::MulticastObjectGroupFactory::_unchecked_narrow (
    CORBA::Object_ptr obj,
    CORBA::Environment &
  )
{
  if (CORBA::is_nil (obj))
    return MulticastObjectGroupFactory::_nil ();
  return
      ACE_reinterpret_cast
        (
          MulticastObjectGroupFactory_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &MulticastObjectGroupFactory::_narrow
                  )
              )
        );
}

MIOP::MulticastObjectGroupFactory_ptr
MIOP::MulticastObjectGroupFactory::_duplicate (MulticastObjectGroupFactory_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

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

void MIOP::MulticastObjectGroupFactory::ipaddr_forany::_tao_any_destructor (void *x)
{
  ipaddr_slice *tmp = ACE_static_cast (ipaddr_slice*,x);
  ipaddr_free (tmp);
}

MIOP::MulticastObjectGroupFactory::ipaddr_slice *
MIOP::MulticastObjectGroupFactory::ipaddr_dup (const MIOP::MulticastObjectGroupFactory::ipaddr_slice *_tao_src_array)
{
  MIOP::MulticastObjectGroupFactory::ipaddr_slice *_tao_dup_array = MIOP::MulticastObjectGroupFactory::ipaddr_alloc ();
  if (!_tao_dup_array) return (MIOP::MulticastObjectGroupFactory::ipaddr_slice *)0;
  MIOP::MulticastObjectGroupFactory::ipaddr_copy (_tao_dup_array, _tao_src_array);
  return _tao_dup_array;
}

MIOP::MulticastObjectGroupFactory::ipaddr_slice *
MIOP::MulticastObjectGroupFactory::ipaddr_alloc (void)
{
  MIOP::MulticastObjectGroupFactory::ipaddr_slice *retval = 0;
  ACE_NEW_RETURN (retval, CORBA::Octet[4], 0);
  return retval;
}

void
MIOP::MulticastObjectGroupFactory::ipaddr_free (MIOP::MulticastObjectGroupFactory::ipaddr_slice *_tao_slice)
{
  delete [] _tao_slice;
}

void
MIOP::MulticastObjectGroupFactory::ipaddr_copy (MIOP::MulticastObjectGroupFactory::ipaddr_slice * _tao_to, const MIOP::MulticastObjectGroupFactory::ipaddr_slice *_tao_from)
{
  // copy each individual element
  for (CORBA::ULong i0 = 0; i0 < 4; i0++)
    _tao_to[i0] = _tao_from[i0];
}

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_UniqueId, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

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

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_PacketHeader_1_0, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

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

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_Version, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

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

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_UsingIpv4, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

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

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_UsingIpv6, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

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

void operator<<= (
    CORBA::Any &_tao_any,
    const MIOP::IPEndpoints &_tao_elem
  )
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        MIOP::_tc_IPEndpoints,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (
    CORBA::Any &_tao_any,
    MIOP::IPEndpoints *_tao_elem
  )
{
  TAO_OutputCDR stream;
  if (stream << *_tao_elem)
  {
    _tao_any._tao_replace (
        MIOP::_tc_IPEndpoints,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin (),
        1,
        _tao_elem,
        MIOP::IPEndpoints::_tao_any_destructor
      );
  }
}

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_IPEndpoints, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const MIOP::IPEndpoints*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      MIOP::IPEndpoints *tmp;
      ACE_NEW_RETURN (tmp, MIOP::IPEndpoints, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );

      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            MIOP::_tc_IPEndpoints,
            1,
            ACE_static_cast (void *, tmp),
            MIOP::IPEndpoints::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete  tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

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

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

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

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

    CORBA::Boolean result = type->equivalent (MIOP::_tc_UIPMC_ProfileBody, ACE_TRY_ENV);
    ACE_TRY_CHECK;

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

    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const MIOP::UIPMC_ProfileBody*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      MIOP::UIPMC_ProfileBody *tmp;
      ACE_NEW_RETURN (tmp, MIOP::UIPMC_ProfileBody, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            MIOP::_tc_UIPMC_ProfileBody,
            1,
            ACE_static_cast (void *, tmp),
            MIOP::UIPMC_ProfileBody::_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<MIOP::MulticastObjectGroupFactory,MIOP::MulticastObjectGroupFactory_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<MIOP::MulticastObjectGroupFactory,MIOP::MulticastObjectGroupFactory_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const MIOP::UniqueId &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    return strm.write_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
  }
  return 0; // error
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    MIOP::UniqueId &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  if (strm >> _tao_seq_len)
  {
    if (_tao_seq_len <= _tao_sequence.maximum ())
    {
      // 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
      return strm.read_octet_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }
  }
  return 0; // error
}


#if !defined _TAO_CDR_OP_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent_CPP_
#define _TAO_CDR_OP_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent &_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,
    MIOP::UIPMC_ProfileBody::_tao_seq_TaggedComponent &_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
}

#endif /* _TAO_CDR_OP_MIOP_UIPMC_ProfileBody__tao_seq_TaggedComponent_CPP_ */