RTCORBAC.cpp

Go to the documentation of this file.

// -*- C++ -*-
//
// RTCORBAC.cpp,v 1.46 2006/04/19 09:30:04 jwillemsen Exp

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

// TAO_IDL - Generated from
// be\be_codegen.cpp:291


#include "tao/RTCORBA/RTCORBA.h"
#include "tao/CDR.h"
#include "tao/Basic_Arguments.h"
#include "tao/Special_Basic_Arguments.h"
#include "tao/UB_String_Arguments.h"
#include "ace/OS_NS_string.h"

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

// TAO_IDL - Generated from
// be\be_visitor_arg_traits.cpp:70

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

// Arg traits specializations.
namespace TAO
{
}

//////////////////////////////////////////////////////
// CDR Encoding Support hand crafted

CORBA::Boolean
RTCORBA::ProtocolProperties::_tao_encode (TAO_OutputCDR &)
{
  return 1;
}
// TAO_IDL - Generated from
// be/be_visitor_arg_traits.cpp:60

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

// TAO_IDL - Generated from
// be\be_visitor_structure/structure_cs.cpp:66

void
RTCORBA::ThreadpoolLane::_tao_any_destructor (
    void *_tao_void_pointer
  )
{
  ThreadpoolLane *_tao_tmp_pointer =
    static_cast<ThreadpoolLane *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

// TAO_IDL - Generated from
// be\be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_RTCORBA_THREADPOOLLANES_CS_)
#define _RTCORBA_THREADPOOLLANES_CS_

RTCORBA::ThreadpoolLanes::ThreadpoolLanes (void)
{}

RTCORBA::ThreadpoolLanes::ThreadpoolLanes (
    CORBA::ULong max
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::ThreadpoolLane
      >
    (max)
{}

RTCORBA::ThreadpoolLanes::ThreadpoolLanes (
    CORBA::ULong max,
    CORBA::ULong length,
    RTCORBA::ThreadpoolLane * buffer,
    CORBA::Boolean release
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::ThreadpoolLane
      >
    (max, length, buffer, release)
{}

RTCORBA::ThreadpoolLanes::ThreadpoolLanes (
    const ThreadpoolLanes &seq
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::ThreadpoolLane
      >
    (seq)
{}

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

void RTCORBA::ThreadpoolLanes::_tao_any_destructor (
    void * _tao_void_pointer
  )
{
  ThreadpoolLanes * _tao_tmp_pointer =
    static_cast<ThreadpoolLanes *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::PriorityModelPolicy.

RTCORBA::PriorityModelPolicy_ptr
TAO::Objref_Traits<RTCORBA::PriorityModelPolicy>::duplicate (
    RTCORBA::PriorityModelPolicy_ptr p
  )
{
  return RTCORBA::PriorityModelPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::PriorityModelPolicy>::release (
    RTCORBA::PriorityModelPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::PriorityModelPolicy_ptr
TAO::Objref_Traits<RTCORBA::PriorityModelPolicy>::nil (void)
{
  return RTCORBA::PriorityModelPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::PriorityModelPolicy>::marshal (
    RTCORBA::PriorityModelPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::PriorityModelPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  PriorityModelPolicy *_tao_tmp_pointer =
    static_cast<PriorityModelPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PriorityModelPolicy::_duplicate (
      dynamic_cast<PriorityModelPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::PriorityModelPolicy_ptr
RTCORBA::PriorityModelPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PriorityModelPolicy::_duplicate (
      dynamic_cast<PriorityModelPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::PriorityModelPolicy::_tao_release (PriorityModelPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::PriorityModelPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/PriorityModelPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::PriorityModelPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::ThreadpoolPolicy.

RTCORBA::ThreadpoolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ThreadpoolPolicy>::duplicate (
    RTCORBA::ThreadpoolPolicy_ptr p
  )
{
  return RTCORBA::ThreadpoolPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::ThreadpoolPolicy>::release (
    RTCORBA::ThreadpoolPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::ThreadpoolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ThreadpoolPolicy>::nil (void)
{
  return RTCORBA::ThreadpoolPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::ThreadpoolPolicy>::marshal (
    RTCORBA::ThreadpoolPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::ThreadpoolPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ThreadpoolPolicy *_tao_tmp_pointer =
    static_cast<ThreadpoolPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ThreadpoolPolicy::_duplicate (
      dynamic_cast<ThreadpoolPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::ThreadpoolPolicy_ptr
RTCORBA::ThreadpoolPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ThreadpoolPolicy::_duplicate (
      dynamic_cast<ThreadpoolPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::ThreadpoolPolicy::_tao_release (ThreadpoolPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::ThreadpoolPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ThreadpoolPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::ThreadpoolPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::ProtocolProperties.

RTCORBA::ProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::ProtocolProperties>::duplicate (
    RTCORBA::ProtocolProperties_ptr p
  )
{
  return RTCORBA::ProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::ProtocolProperties>::release (
    RTCORBA::ProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::ProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::ProtocolProperties>::nil (void)
{
  return RTCORBA::ProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::ProtocolProperties>::marshal (
    RTCORBA::ProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::ProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  ProtocolProperties *_tao_tmp_pointer =
    static_cast<ProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ProtocolProperties::_duplicate (
      dynamic_cast<ProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::ProtocolProperties_ptr
RTCORBA::ProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ProtocolProperties::_duplicate (
      dynamic_cast<ProtocolProperties_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::ProtocolProperties::_tao_release (ProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::ProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::ProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_structure/structure_cs.cpp:66

void
RTCORBA::Protocol::_tao_any_destructor (
    void *_tao_void_pointer
  )
{
  Protocol *_tao_tmp_pointer =
    static_cast<Protocol *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

// TAO_IDL - Generated from
// be\be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_RTCORBA_PROTOCOLLIST_CS_)
#define _RTCORBA_PROTOCOLLIST_CS_

RTCORBA::ProtocolList::ProtocolList (void)
{}

RTCORBA::ProtocolList::ProtocolList (
    CORBA::ULong max
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::Protocol
      >
    (max)
{}

RTCORBA::ProtocolList::ProtocolList (
    CORBA::ULong max,
    CORBA::ULong length,
    RTCORBA::Protocol * buffer,
    CORBA::Boolean release
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::Protocol
      >
    (max, length, buffer, release)
{}

RTCORBA::ProtocolList::ProtocolList (
    const ProtocolList &seq
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::Protocol
      >
    (seq)
{}

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

void RTCORBA::ProtocolList::_tao_any_destructor (
    void * _tao_void_pointer
  )
{
  ProtocolList * _tao_tmp_pointer =
    static_cast<ProtocolList *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::ServerProtocolPolicy.

RTCORBA::ServerProtocolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ServerProtocolPolicy>::duplicate (
    RTCORBA::ServerProtocolPolicy_ptr p
  )
{
  return RTCORBA::ServerProtocolPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::ServerProtocolPolicy>::release (
    RTCORBA::ServerProtocolPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::ServerProtocolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ServerProtocolPolicy>::nil (void)
{
  return RTCORBA::ServerProtocolPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::ServerProtocolPolicy>::marshal (
    RTCORBA::ServerProtocolPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::ServerProtocolPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ServerProtocolPolicy *_tao_tmp_pointer =
    static_cast<ServerProtocolPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ServerProtocolPolicy::_duplicate (
      dynamic_cast<ServerProtocolPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::ServerProtocolPolicy_ptr
RTCORBA::ServerProtocolPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ServerProtocolPolicy::_duplicate (
      dynamic_cast<ServerProtocolPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::ServerProtocolPolicy::_tao_release (ServerProtocolPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::ServerProtocolPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ServerProtocolPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::ServerProtocolPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::ClientProtocolPolicy.

RTCORBA::ClientProtocolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ClientProtocolPolicy>::duplicate (
    RTCORBA::ClientProtocolPolicy_ptr p
  )
{
  return RTCORBA::ClientProtocolPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::ClientProtocolPolicy>::release (
    RTCORBA::ClientProtocolPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::ClientProtocolPolicy_ptr
TAO::Objref_Traits<RTCORBA::ClientProtocolPolicy>::nil (void)
{
  return RTCORBA::ClientProtocolPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::ClientProtocolPolicy>::marshal (
    RTCORBA::ClientProtocolPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::ClientProtocolPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  ClientProtocolPolicy *_tao_tmp_pointer =
    static_cast<ClientProtocolPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ClientProtocolPolicy::_duplicate (
      dynamic_cast<ClientProtocolPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::ClientProtocolPolicy_ptr
RTCORBA::ClientProtocolPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return ClientProtocolPolicy::_duplicate (
      dynamic_cast<ClientProtocolPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::ClientProtocolPolicy::_tao_release (ClientProtocolPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::ClientProtocolPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ClientProtocolPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::ClientProtocolPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::PrivateConnectionPolicy.

RTCORBA::PrivateConnectionPolicy_ptr
TAO::Objref_Traits<RTCORBA::PrivateConnectionPolicy>::duplicate (
    RTCORBA::PrivateConnectionPolicy_ptr p
  )
{
  return RTCORBA::PrivateConnectionPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::PrivateConnectionPolicy>::release (
    RTCORBA::PrivateConnectionPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::PrivateConnectionPolicy_ptr
TAO::Objref_Traits<RTCORBA::PrivateConnectionPolicy>::nil (void)
{
  return RTCORBA::PrivateConnectionPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::PrivateConnectionPolicy>::marshal (
    RTCORBA::PrivateConnectionPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::PrivateConnectionPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  PrivateConnectionPolicy *_tao_tmp_pointer =
    static_cast<PrivateConnectionPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PrivateConnectionPolicy::_duplicate (
      dynamic_cast<PrivateConnectionPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::PrivateConnectionPolicy_ptr
RTCORBA::PrivateConnectionPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PrivateConnectionPolicy::_duplicate (
      dynamic_cast<PrivateConnectionPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::PrivateConnectionPolicy::_tao_release (PrivateConnectionPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::PrivateConnectionPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/PrivateConnectionPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::PrivateConnectionPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::TCPProtocolProperties.

RTCORBA::TCPProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::TCPProtocolProperties>::duplicate (
    RTCORBA::TCPProtocolProperties_ptr p
  )
{
  return RTCORBA::TCPProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::TCPProtocolProperties>::release (
    RTCORBA::TCPProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::TCPProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::TCPProtocolProperties>::nil (void)
{
  return RTCORBA::TCPProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::TCPProtocolProperties>::marshal (
    RTCORBA::TCPProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::TCPProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  TCPProtocolProperties *_tao_tmp_pointer =
    static_cast<TCPProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return TCPProtocolProperties::_duplicate (
      dynamic_cast<TCPProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::TCPProtocolProperties_ptr
RTCORBA::TCPProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return TCPProtocolProperties::_duplicate (
      dynamic_cast<TCPProtocolProperties_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::TCPProtocolProperties::_tao_release (TCPProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::TCPProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/TCPProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::TCPProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::GIOPProtocolProperties.

RTCORBA::GIOPProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::GIOPProtocolProperties>::duplicate (
    RTCORBA::GIOPProtocolProperties_ptr p
  )
{
  return RTCORBA::GIOPProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::GIOPProtocolProperties>::release (
    RTCORBA::GIOPProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::GIOPProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::GIOPProtocolProperties>::nil (void)
{
  return RTCORBA::GIOPProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::GIOPProtocolProperties>::marshal (
    RTCORBA::GIOPProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::GIOPProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  GIOPProtocolProperties *_tao_tmp_pointer =
    static_cast<GIOPProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return GIOPProtocolProperties::_duplicate (
      dynamic_cast<GIOPProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::GIOPProtocolProperties_ptr
RTCORBA::GIOPProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return GIOPProtocolProperties::_duplicate (
      dynamic_cast<GIOPProtocolProperties_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::GIOPProtocolProperties::_tao_release (GIOPProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::GIOPProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/GIOPProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::GIOPProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::UnixDomainProtocolProperties.

RTCORBA::UnixDomainProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::UnixDomainProtocolProperties>::duplicate (
    RTCORBA::UnixDomainProtocolProperties_ptr p
  )
{
  return RTCORBA::UnixDomainProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::UnixDomainProtocolProperties>::release (
    RTCORBA::UnixDomainProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::UnixDomainProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::UnixDomainProtocolProperties>::nil (void)
{
  return RTCORBA::UnixDomainProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::UnixDomainProtocolProperties>::marshal (
    RTCORBA::UnixDomainProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::UnixDomainProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  UnixDomainProtocolProperties *_tao_tmp_pointer =
    static_cast<UnixDomainProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return UnixDomainProtocolProperties::_duplicate (
      dynamic_cast<UnixDomainProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::UnixDomainProtocolProperties_ptr
RTCORBA::UnixDomainProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return UnixDomainProtocolProperties::_duplicate (
      dynamic_cast<UnixDomainProtocolProperties_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::UnixDomainProtocolProperties::_tao_release (UnixDomainProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::UnixDomainProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/UnixDomainProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::UnixDomainProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::SharedMemoryProtocolProperties.

RTCORBA::SharedMemoryProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::SharedMemoryProtocolProperties>::duplicate (
    RTCORBA::SharedMemoryProtocolProperties_ptr p
  )
{
  return RTCORBA::SharedMemoryProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::SharedMemoryProtocolProperties>::release (
    RTCORBA::SharedMemoryProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::SharedMemoryProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::SharedMemoryProtocolProperties>::nil (void)
{
  return RTCORBA::SharedMemoryProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::SharedMemoryProtocolProperties>::marshal (
    RTCORBA::SharedMemoryProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::SharedMemoryProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  SharedMemoryProtocolProperties *_tao_tmp_pointer =
    static_cast<SharedMemoryProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return SharedMemoryProtocolProperties::_duplicate (
      dynamic_cast<SharedMemoryProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::SharedMemoryProtocolProperties_ptr
RTCORBA::SharedMemoryProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return SharedMemoryProtocolProperties::_duplicate (
      dynamic_cast<SharedMemoryProtocolProperties_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::SharedMemoryProtocolProperties::_tao_release (SharedMemoryProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::SharedMemoryProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/SharedMemoryProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::SharedMemoryProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::UserDatagramProtocolProperties.

RTCORBA::UserDatagramProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::duplicate (
    RTCORBA::UserDatagramProtocolProperties_ptr p
  )
{
  return RTCORBA::UserDatagramProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::release (
    RTCORBA::UserDatagramProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::UserDatagramProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::nil (void)
{
  return RTCORBA::UserDatagramProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::UserDatagramProtocolProperties>::marshal (
    RTCORBA::UserDatagramProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

RTCORBA::UserDatagramProtocolProperties::UserDatagramProtocolProperties (void)
{}

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

void
RTCORBA::UserDatagramProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  UserDatagramProtocolProperties *_tao_tmp_pointer =
    static_cast<UserDatagramProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::UserDatagramProtocolProperties_ptr
RTCORBA::UserDatagramProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return UserDatagramProtocolProperties::_duplicate (
      dynamic_cast<UserDatagramProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::UserDatagramProtocolProperties_ptr
RTCORBA::UserDatagramProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return UserDatagramProtocolProperties::_duplicate (
      dynamic_cast<UserDatagramProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::UserDatagramProtocolProperties_ptr
RTCORBA::UserDatagramProtocolProperties::_duplicate (UserDatagramProtocolProperties_ptr obj)
{
  if (! ::CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }

  return obj;
}

void
RTCORBA::UserDatagramProtocolProperties::_tao_release (UserDatagramProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::UserDatagramProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/UserDatagramProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::UserDatagramProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::StreamControlProtocolProperties.

RTCORBA::StreamControlProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::duplicate (
    RTCORBA::StreamControlProtocolProperties_ptr p
  )
{
  return RTCORBA::StreamControlProtocolProperties::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::release (
    RTCORBA::StreamControlProtocolProperties_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::StreamControlProtocolProperties_ptr
TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::nil (void)
{
  return RTCORBA::StreamControlProtocolProperties::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::StreamControlProtocolProperties>::marshal (
    RTCORBA::StreamControlProtocolProperties_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

RTCORBA::StreamControlProtocolProperties::StreamControlProtocolProperties (void)
{}

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

void
RTCORBA::StreamControlProtocolProperties::_tao_any_destructor (void *_tao_void_pointer)
{
  StreamControlProtocolProperties *_tao_tmp_pointer =
    static_cast<StreamControlProtocolProperties *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::StreamControlProtocolProperties_ptr
RTCORBA::StreamControlProtocolProperties::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return StreamControlProtocolProperties::_duplicate (
      dynamic_cast<StreamControlProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::StreamControlProtocolProperties_ptr
RTCORBA::StreamControlProtocolProperties::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return StreamControlProtocolProperties::_duplicate (
      dynamic_cast<StreamControlProtocolProperties_ptr> (_tao_objref)
    );
}

RTCORBA::StreamControlProtocolProperties_ptr
RTCORBA::StreamControlProtocolProperties::_duplicate (StreamControlProtocolProperties_ptr obj)
{
  if (! ::CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }

  return obj;
}

void
RTCORBA::StreamControlProtocolProperties::_tao_release (StreamControlProtocolProperties_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::StreamControlProtocolProperties::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/ProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/StreamControlProtocolProperties:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::StreamControlProtocolProperties::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_structure/structure_cs.cpp:66

void
RTCORBA::PriorityBand::_tao_any_destructor (
    void *_tao_void_pointer
  )
{
  PriorityBand *_tao_tmp_pointer =
    static_cast<PriorityBand *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

// TAO_IDL - Generated from
// be\be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_RTCORBA_PRIORITYBANDS_CS_)
#define _RTCORBA_PRIORITYBANDS_CS_

RTCORBA::PriorityBands::PriorityBands (void)
{}

RTCORBA::PriorityBands::PriorityBands (
    CORBA::ULong max
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::PriorityBand
      >
    (max)
{}

RTCORBA::PriorityBands::PriorityBands (
    CORBA::ULong max,
    CORBA::ULong length,
    RTCORBA::PriorityBand * buffer,
    CORBA::Boolean release
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::PriorityBand
      >
    (max, length, buffer, release)
{}

RTCORBA::PriorityBands::PriorityBands (
    const PriorityBands &seq
  )
  : TAO::unbounded_value_sequence<
        RTCORBA::PriorityBand
      >
    (seq)
{}

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

void RTCORBA::PriorityBands::_tao_any_destructor (
    void * _tao_void_pointer
  )
{
  PriorityBands * _tao_tmp_pointer =
    static_cast<PriorityBands *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::PriorityBandedConnectionPolicy.

RTCORBA::PriorityBandedConnectionPolicy_ptr
TAO::Objref_Traits<RTCORBA::PriorityBandedConnectionPolicy>::duplicate (
    RTCORBA::PriorityBandedConnectionPolicy_ptr p
  )
{
  return RTCORBA::PriorityBandedConnectionPolicy::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::PriorityBandedConnectionPolicy>::release (
    RTCORBA::PriorityBandedConnectionPolicy_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
TAO::Objref_Traits<RTCORBA::PriorityBandedConnectionPolicy>::nil (void)
{
  return RTCORBA::PriorityBandedConnectionPolicy::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::PriorityBandedConnectionPolicy>::marshal (
    RTCORBA::PriorityBandedConnectionPolicy_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::PriorityBandedConnectionPolicy::_tao_any_destructor (void *_tao_void_pointer)
{
  PriorityBandedConnectionPolicy *_tao_tmp_pointer =
    static_cast<PriorityBandedConnectionPolicy *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PriorityBandedConnectionPolicy::_duplicate (
      dynamic_cast<PriorityBandedConnectionPolicy_ptr> (_tao_objref)
    );
}

RTCORBA::PriorityBandedConnectionPolicy_ptr
RTCORBA::PriorityBandedConnectionPolicy::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return PriorityBandedConnectionPolicy::_duplicate (
      dynamic_cast<PriorityBandedConnectionPolicy_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::PriorityBandedConnectionPolicy::_tao_release (PriorityBandedConnectionPolicy_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::PriorityBandedConnectionPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/PriorityBandedConnectionPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::PriorityBandedConnectionPolicy::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::Current.

RTCORBA::Current_ptr
TAO::Objref_Traits<RTCORBA::Current>::duplicate (
    RTCORBA::Current_ptr p
  )
{
  return RTCORBA::Current::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::Current>::release (
    RTCORBA::Current_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::Current_ptr
TAO::Objref_Traits<RTCORBA::Current>::nil (void)
{
  return RTCORBA::Current::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::Current>::marshal (
    RTCORBA::Current_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::Current::_tao_any_destructor (void *_tao_void_pointer)
{
  Current *_tao_tmp_pointer =
    static_cast<Current *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::Current_ptr
RTCORBA::Current::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return Current::_duplicate (
      dynamic_cast<Current_ptr> (_tao_objref)
    );
}

RTCORBA::Current_ptr
RTCORBA::Current::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return Current::_duplicate (
      dynamic_cast<Current_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::Current::_tao_release (Current_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::Current::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Current:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/Current:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::Current::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::Mutex.

RTCORBA::Mutex_ptr
TAO::Objref_Traits<RTCORBA::Mutex>::duplicate (
    RTCORBA::Mutex_ptr p
  )
{
  return RTCORBA::Mutex::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::Mutex>::release (
    RTCORBA::Mutex_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::Mutex_ptr
TAO::Objref_Traits<RTCORBA::Mutex>::nil (void)
{
  return RTCORBA::Mutex::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::Mutex>::marshal (
    RTCORBA::Mutex_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

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

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

void
RTCORBA::Mutex::_tao_any_destructor (void *_tao_void_pointer)
{
  Mutex *_tao_tmp_pointer =
    static_cast<Mutex *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::Mutex_ptr
RTCORBA::Mutex::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return Mutex::_duplicate (
      dynamic_cast<Mutex_ptr> (_tao_objref)
    );
}

RTCORBA::Mutex_ptr
RTCORBA::Mutex::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return Mutex::_duplicate (
      dynamic_cast<Mutex_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::Mutex::_tao_release (Mutex_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::Mutex::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/Mutex:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::Mutex::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_interface/interface_cs.cpp:60

// Traits specializations for RTCORBA::RTORB.

RTCORBA::RTORB_ptr
TAO::Objref_Traits<RTCORBA::RTORB>::duplicate (
    RTCORBA::RTORB_ptr p
  )
{
  return RTCORBA::RTORB::_duplicate (p);
}

void
TAO::Objref_Traits<RTCORBA::RTORB>::release (
    RTCORBA::RTORB_ptr p
  )
{
  ::CORBA::release (p);
}

RTCORBA::RTORB_ptr
TAO::Objref_Traits<RTCORBA::RTORB>::nil (void)
{
  return RTCORBA::RTORB::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<RTCORBA::RTORB>::marshal (
    RTCORBA::RTORB_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// TAO_IDL - Generated from
// be\be_visitor_exception/exception_cs.cpp:63

RTCORBA::RTORB::MutexNotFound::MutexNotFound (void)
  : CORBA::UserException (
        "IDL:omg.org/RTCORBA/RTORB/MutexNotFound:1.0",
        "MutexNotFound"
      )
{
}

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

RTCORBA::RTORB::MutexNotFound::MutexNotFound (const ::RTCORBA::RTORB::MutexNotFound &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

RTCORBA::RTORB::MutexNotFound&
RTCORBA::RTORB::MutexNotFound::operator= (const ::RTCORBA::RTORB::MutexNotFound &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  return *this;
}

void RTCORBA::RTORB::MutexNotFound::_tao_any_destructor (void *_tao_void_pointer)
{
  MutexNotFound *_tao_tmp_pointer =
    static_cast<MutexNotFound *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

RTCORBA::RTORB::MutexNotFound *
RTCORBA::RTORB::MutexNotFound::_downcast (CORBA::Exception *_tao_excp)
{
  return dynamic_cast<MutexNotFound *> (_tao_excp);
}

const RTCORBA::RTORB::MutexNotFound *
RTCORBA::RTORB::MutexNotFound::_downcast (CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const MutexNotFound *> (_tao_excp);
}

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

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

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

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr RTCORBA::RTORB::MutexNotFound::_tao_type (void) const
{
  return ::RTCORBA::RTORB::_tc_MutexNotFound;
}

// TAO_IDL - Generated from
// be\be_visitor_exception/exception_cs.cpp:63

RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (void)
  : CORBA::UserException (
        "IDL:omg.org/RTCORBA/RTORB/InvalidThreadpool:1.0",
        "InvalidThreadpool"
      )
{
}

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

RTCORBA::RTORB::InvalidThreadpool::InvalidThreadpool (const ::RTCORBA::RTORB::InvalidThreadpool &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

RTCORBA::RTORB::InvalidThreadpool&
RTCORBA::RTORB::InvalidThreadpool::operator= (const ::RTCORBA::RTORB::InvalidThreadpool &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  return *this;
}

void RTCORBA::RTORB::InvalidThreadpool::_tao_any_destructor (void *_tao_void_pointer)
{
  InvalidThreadpool *_tao_tmp_pointer =
    static_cast<InvalidThreadpool *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

RTCORBA::RTORB::InvalidThreadpool *
RTCORBA::RTORB::InvalidThreadpool::_downcast (CORBA::Exception *_tao_excp)
{
  return dynamic_cast<InvalidThreadpool *> (_tao_excp);
}

const RTCORBA::RTORB::InvalidThreadpool *
RTCORBA::RTORB::InvalidThreadpool::_downcast (CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const InvalidThreadpool *> (_tao_excp);
}

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

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

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

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

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

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr RTCORBA::RTORB::InvalidThreadpool::_tao_type (void) const
{
  return ::RTCORBA::RTORB::_tc_InvalidThreadpool;
}

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

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

void
RTCORBA::RTORB::_tao_any_destructor (void *_tao_void_pointer)
{
  RTORB *_tao_tmp_pointer =
    static_cast<RTORB *> (_tao_void_pointer);
  ::CORBA::release (_tao_tmp_pointer);
}

RTCORBA::RTORB_ptr
RTCORBA::RTORB::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return RTORB::_duplicate (
      dynamic_cast<RTORB_ptr> (_tao_objref)
    );
}

RTCORBA::RTORB_ptr
RTCORBA::RTORB::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return RTORB::_duplicate (
      dynamic_cast<RTORB_ptr> (_tao_objref)
    );
}

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

  return obj;
}

void
RTCORBA::RTORB::_tao_release (RTORB_ptr obj)
{
  ::CORBA::release (obj);
}

CORBA::Boolean
RTCORBA::RTORB::_is_a (
    const char *value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/RTCORBA/RTORB:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/LocalObject:1.0"
        ) ||
      !ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return false;
    }
}

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

CORBA::Boolean
RTCORBA::RTORB::marshal (TAO_OutputCDR &)
{
  return false;
}

// TAO_IDL - Generated from
// be\be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::ThreadpoolLane &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.lane_priority) &&
    (strm << _tao_aggregate.static_threads) &&
    (strm << _tao_aggregate.dynamic_threads);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::ThreadpoolLane &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.lane_priority) &&
    (strm >> _tao_aggregate.static_threads) &&
    (strm >> _tao_aggregate.dynamic_threads);
}

// TAO_IDL - Generated from
// be\be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_
#define _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::ThreadpoolLanes &_tao_sequence
  )
{
  return TAO::marshal_sequence(strm, _tao_sequence);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::ThreadpoolLanes &_tao_sequence
  )
{
  return TAO::demarshal_sequence(strm, _tao_sequence);
}

#endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_CPP_ */

// TAO_IDL - Generated from
// be\be_visitor_enum/cdr_op_cs.cpp:51

CORBA::Boolean operator<< (TAO_OutputCDR & strm, RTCORBA::PriorityModel _tao_enumerator)
{
  return strm << static_cast<CORBA::ULong> (_tao_enumerator);
}

CORBA::Boolean operator>> (TAO_InputCDR & strm, RTCORBA::PriorityModel & _tao_enumerator)
{
  CORBA::ULong _tao_temp = 0;
  CORBA::Boolean const _tao_success = strm >> _tao_temp;

  if (_tao_success)
    {
      _tao_enumerator = static_cast<RTCORBA::PriorityModel> (_tao_temp);
    }

  return _tao_success;
}

// TAO_IDL - Generated from
// be\be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::PriorityBand &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.low) &&
    (strm << _tao_aggregate.high);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::PriorityBand &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.low) &&
    (strm >> _tao_aggregate.high);
}

// TAO_IDL - Generated from
// be\be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_
#define _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const RTCORBA::PriorityBands &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();

  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = true;

      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }

      return _tao_marshal_flag;
    }

  return false;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    RTCORBA::PriorityBands &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;

  if (strm >> _tao_seq_len)
    {
      // 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 false;
        }

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

      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = true;

      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }

      return _tao_marshal_flag;

    }

  return false;
}

#endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_CPP_ */

TAO_END_VERSIONED_NAMESPACE_DECL

---