// -*- 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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_codegen.cpp:314


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

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

#include "tao/IFR_Client_Adapter.h"
#include "ace/Dynamic_Service.h"

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

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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_cs.cpp:61

int CORBA::DomainManager::_tao_class_id = 0;

CORBA::DomainManager_ptr
CORBA::tao_DomainManager_life::tao_duplicate (
    CORBA::DomainManager_ptr p
  )
{
  return CORBA::DomainManager::_duplicate (p);
}

void
CORBA::tao_DomainManager_life::tao_release (
    CORBA::DomainManager_ptr p
  )
{
  CORBA::release (p);
}

CORBA::DomainManager_ptr
CORBA::tao_DomainManager_life::tao_nil (
    void
  )
{
  return CORBA::DomainManager::_nil ();
}

CORBA::Boolean
CORBA::tao_DomainManager_life::tao_marshal (
    CORBA::DomainManager_ptr p,
    TAO_OutputCDR &cdr
  )
{
  return p->marshal (cdr);
}

CORBA::DomainManager_ptr
CORBA::tao_DomainManager_cast::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return CORBA::DomainManager::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA::tao_DomainManager_cast::tao_upcast (
    void *src
  )
{
  CORBA::DomainManager **tmp =
    ACE_static_cast (CORBA::DomainManager **, src);
  return *tmp;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
  template class
    TAO_Objref_Var_T<
        CORBA::DomainManager,
        CORBA::tao_DomainManager_life
      >;
  template class
    TAO_Objref_Out_T<
        CORBA::DomainManager,
        CORBA::tao_DomainManager_life
      >;
template class TAO_Seq_Var_Base_T<CORBA::DomainManagerList,
                                  TAO_Object_Manager<CORBA::DomainManager,
                                                     TAO_Objref_Var_T<CORBA::DomainManager,
                                                                      CORBA::tao_DomainManager_life>,
                                                     CORBA::tao_DomainManager_life> >;

#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate \
    TAO_Objref_Var_T< \
        CORBA::DomainManager, \
        CORBA::tao_DomainManager_life \
      >
# pragma instantiate \
    TAO_Objref_Out_T< \
        CORBA::DomainManager, \
        CORBA::tao_DomainManager_life \
      >

#pragma instantiate TAO_Seq_Var_Base_T<CORBA::DomainManagerList,
                                       TAO_Object_Manager<CORBA::DomainManager,
                                       TAO_Objref_Var_T<CORBA::DomainManager, CORBA::tao_DomainManager_life>,
                                       CORBA::tao_DomainManager_life> >

#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interceptors_cs.cpp:56

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:76

class TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const CORBA::PolicyType & policy_type
      ACE_ENV_ARG_DECL_WITH_DEFAULTS);

    virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

    virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

    virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

    void result (::CORBA::Policy_ptr result);

  private:
    TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (const TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy &);
    void operator= (const TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy &);
    const CORBA::PolicyType & policy_type_;

    ::CORBA::Policy_ptr _result;
  };

  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:376

  TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const CORBA::PolicyType & policy_type
      ACE_ENV_ARG_DECL_NOT_USED
    )
      : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
      policy_type_ (policy_type)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::arguments (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (1);
  CORBA::ULong len = 0;
  (*parameter_list)[len].argument <<= policy_type_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::exceptions (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}

CORBA::Any *
TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::result (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  CORBA::Any_var safe_result_any = result_any;

  (*result_any) <<= this->_result;
  return safe_result_any._retn ();
}

void
TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::result (::CORBA::Policy_ptr result)
{
  // Update the result.
  this->_result = result;
}

#endif /* TAO_HAS_INTERCEPTORS */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/remote_proxy_impl_cs.cpp:31

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

CORBA::_TAO_DomainManager_Proxy_Impl::_TAO_DomainManager_Proxy_Impl (void)
{}

CORBA::_TAO_DomainManager_Remote_Proxy_Impl::_TAO_DomainManager_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/remote_proxy_impl_cs.cpp:63

::CORBA::Policy_ptr CORBA::_TAO_DomainManager_Remote_Proxy_Impl::get_domain_policy (
    CORBA::Object *_collocated_tao_target_,
    CORBA::PolicyType policy_type
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  CORBA::Policy_var _tao_retval (CORBA::Policy::_nil ());
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();

  if (istub == 0)
    {
      ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval._retn ());
    }

  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "get_domain_policy",
      17,
      1,
      istub->orb_core ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy _tao_ri (
          &_tao_call,
          _collocated_tao_target_,
          policy_type
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK_RETURN (_tao_retval._retn ());

#endif /* TAO_HAS_INTERCEPTORS */

      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
            }
          else
            {

#endif /* TAO_HAS_INTERCEPTORS */

              _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
              TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

              _tao_call.prepare_header (
                  ACE_static_cast (CORBA::Octet, _tao_response_flag)
                  ACE_ENV_ARG_PARAMETER
                );
              TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

              TAO_OutputCDR &_tao_out = _tao_call.out_stream ();

              if (!(
                  (_tao_out << policy_type)
                  ))
                {
                  TAO_OutputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER);
                  TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

                }

              _invoke_status =
                _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
              TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

              if (_invoke_status == TAO_INVOKE_EXCEPTION)
                {
                  TAO_INTERCEPTOR_THROW_RETURN (
                      CORBA::UNKNOWN (
                          CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES
                        ),
                      0
                    );
                }
              else if (_invoke_status == TAO_INVOKE_RESTART)
                {
                  _tao_call.restart_flag (1);
                  TAO_INTERCEPTOR (
                      _tao_ri.reply_status (_invoke_status);
                      _tao_vfr.receive_other (
                          &_tao_ri
                          ACE_ENV_ARG_PARAMETER
                        );
                      ACE_TRY_CHECK;
                    )
                }
              else
                {

                  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
                  _tao_call.transport()->assign_translators (&_tao_in,0);

                  if (!(
                      (_tao_in >> _tao_retval.inout ())
                      ))
                    {
                      TAO_InputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER);
                      TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());


                    }

#if TAO_HAS_INTERCEPTORS == 1
                  ::CORBA::Policy_ptr _tao_retval_info =
                    _tao_retval._retn ();
                  _tao_ri.result (_tao_retval_info);
                  _tao_retval = _tao_retval_info;

                  _tao_ri.reply_status (_invoke_status);
                  _tao_vfr.receive_reply (
                      &_tao_ri
                      ACE_ENV_ARG_PARAMETER
                    );
                  ACE_TRY_CHECK;

#endif  /* TAO_HAS_INTERCEPTORS */
                }

#if TAO_HAS_INTERCEPTORS == 1
            }
        }
      ACE_CATCHANY
        {
          _tao_ri.exception (&ACE_ANY_EXCEPTION);
          _tao_vfr.receive_exception (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          const PortableInterceptor::ReplyStatus _tao_status =
            _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
              || _tao_status == PortableInterceptor::USER_EXCEPTION)
            {
              ACE_RE_THROW;
            }
        }

# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;

          _tao_ri.exception (&ex);
          _tao_vfr.receive_exception (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          const PortableInterceptor::ReplyStatus _tao_status =
            _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */

      ACE_ENDTRY;
      ACE_CHECK_RETURN (_tao_retval._retn ());

      const PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK_RETURN (_tao_retval._retn ());

      if (_tao_status != PortableInterceptor::LOCATION_FORWARD
          && _tao_status != PortableInterceptor::TRANSPORT_RETRY)

#endif  /* TAO_HAS_INTERCEPTORS */

        if (_invoke_status != TAO_INVOKE_RESTART)
          break;
    }

return _tao_retval._retn ();
}

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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/remote_proxy_broker_cs.cpp:31

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

CORBA::_TAO_DomainManager_Proxy_Broker::_TAO_DomainManager_Proxy_Broker (void)
{
}

CORBA::_TAO_DomainManager_Proxy_Broker::~_TAO_DomainManager_Proxy_Broker (void)
{
}

CORBA::_TAO_DomainManager_Proxy_Broker * (*CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
CORBA::_TAO_DomainManager_Remote_Proxy_Broker *
CORBA::_TAO_DomainManager_Remote_Proxy_Broker::the_TAO_DomainManager_Remote_Proxy_Broker (void)
{
  static ::CORBA::_TAO_DomainManager_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

CORBA::_TAO_DomainManager_Remote_Proxy_Broker::_TAO_DomainManager_Remote_Proxy_Broker (void)
{
}

CORBA::_TAO_DomainManager_Remote_Proxy_Broker::~_TAO_DomainManager_Remote_Proxy_Broker (void)
{
}

CORBA::_TAO_DomainManager_Proxy_Impl&
CORBA::_TAO_DomainManager_Remote_Proxy_Broker::select_proxy (
    ::CORBA::DomainManager *
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return this->remote_proxy_impl_;
}

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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_cs.cpp:232

CORBA::DomainManager::DomainManager (int collocated)
{
  this->CORBA_DomainManager_setup_collocation (collocated);
}

void
CORBA::DomainManager::CORBA_DomainManager_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_DomainManager_Proxy_Broker_ =
      ::CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_DomainManager_Proxy_Broker_ =
      ::CORBA::_TAO_DomainManager_Remote_Proxy_Broker::the_TAO_DomainManager_Remote_Proxy_Broker ();
}

CORBA::DomainManager::~DomainManager (void)
{}

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

CORBA::DomainManager_ptr
CORBA::DomainManager::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    {
      return DomainManager::_nil ();
    }

  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a =
        obj->_is_a (
            "IDL:omg.org/CORBA/DomainManager:1.0"
            ACE_ENV_ARG_PARAMETER
          );
      ACE_CHECK_RETURN (DomainManager::_nil ());

      if (is_a == 0)
        {
          return DomainManager::_nil ();
        }
    }

  return DomainManager::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

CORBA::DomainManager_ptr
CORBA::DomainManager::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    {
      return DomainManager::_nil ();
    }

  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();

      if (stub != 0)
        {
          stub->_incr_refcnt ();
        }

      DomainManager_ptr default_proxy = DomainManager::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::CORBA::DomainManager (
                  stub,
                  1,
                  obj->_servant ()
                ),
              DomainManager::_nil ()
            );
        }

      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::CORBA::DomainManager (
                  stub,
                  0,
                  obj->_servant ()
                ),
              DomainManager::_nil ()
            );
        }

      return default_proxy;
    }
  else
    return
      ACE_reinterpret_cast (
          DomainManager_ptr,
          obj->_tao_QueryInterface (
              ACE_reinterpret_cast (
                  ptrdiff_t,
                  &DomainManager::_tao_class_id
                )
            )
        );
}

CORBA::DomainManager_ptr
CORBA::DomainManager::_duplicate (DomainManager_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }

  return obj;
}

CORBA::Boolean
CORBA::DomainManager::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/DomainManager:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

void *CORBA::DomainManager::_tao_QueryInterface (ptrdiff_t type)
{
  void *retv = 0;

  if (type == ACE_reinterpret_cast (
              ptrdiff_t,
              &ACE_NESTED_CLASS (::CORBA, DomainManager)::_tao_class_id)
            )
    {
      retv = ACE_reinterpret_cast (void*, this);
    }
  else if (type == ACE_reinterpret_cast (
               ptrdiff_t,
               &CORBA::Object::_tao_class_id)
             )
    {
      retv =
        ACE_reinterpret_cast (
            void *,
            ACE_static_cast (CORBA::Object_ptr, this)
          );
    }

  if (retv != 0)
    {
      this->_add_ref ();
    }

  return retv;
}

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

CORBA::Boolean
CORBA::DomainManager::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/operation_cs.cpp:80

::CORBA::Policy_ptr CORBA::DomainManager::get_domain_policy (
    CORBA::PolicyType policy_type
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_DomainManager_Proxy_Impl &proxy =
    this->the_TAO_DomainManager_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return proxy.get_domain_policy (
      this,
      policy_type
      ACE_ENV_ARG_PARAMETER
    );
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_typecode/typecode_defn.cpp:284

static const CORBA::Long _oc_CORBA_DomainManager[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  36,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x434f5242),
  ACE_NTOHL (0x412f446f),
  ACE_NTOHL (0x6d61696e),
  ACE_NTOHL (0x4d616e61),
  ACE_NTOHL (0x6765723a),
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManager:1.0
    14,
  ACE_NTOHL (0x446f6d61),
  ACE_NTOHL (0x696e4d61),
  ACE_NTOHL (0x6e616765),
  ACE_NTOHL (0x72000000),  // name = DomainManager
  };

static CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManager (
    CORBA::tk_objref,
    sizeof (_oc_CORBA_DomainManager),
    (char *) &_oc_CORBA_DomainManager,
    0,
    sizeof (CORBA::DomainManager)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (CORBA)
TAO_NAMESPACE_DEFINE (
    ::CORBA::TypeCode_ptr,
    _tc_DomainManager,
    &_tc_TAO_tc_CORBA_DomainManager
  )
TAO_NAMESPACE_END

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_cs.cpp:61

int CORBA::ConstructionPolicy::_tao_class_id = 0;

CORBA::ConstructionPolicy_ptr
CORBA::tao_ConstructionPolicy_life::tao_duplicate (
    CORBA::ConstructionPolicy_ptr p
  )
{
  return CORBA::ConstructionPolicy::_duplicate (p);
}

void
CORBA::tao_ConstructionPolicy_life::tao_release (
    CORBA::ConstructionPolicy_ptr p
  )
{
  CORBA::release (p);
}

CORBA::ConstructionPolicy_ptr
CORBA::tao_ConstructionPolicy_life::tao_nil (
    void
  )
{
  return CORBA::ConstructionPolicy::_nil ();
}

CORBA::Boolean
CORBA::tao_ConstructionPolicy_life::tao_marshal (
    CORBA::ConstructionPolicy_ptr p,
    TAO_OutputCDR &cdr
  )
{
  return p->marshal (cdr);
}

CORBA::ConstructionPolicy_ptr
CORBA::tao_ConstructionPolicy_cast::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return CORBA::ConstructionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
CORBA::tao_ConstructionPolicy_cast::tao_upcast (
    void *src
  )
{
  CORBA::ConstructionPolicy **tmp =
    ACE_static_cast (CORBA::ConstructionPolicy **, src);
  return *tmp;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
  template class
    TAO_Objref_Var_T<
        CORBA::ConstructionPolicy,
        CORBA::tao_ConstructionPolicy_life
      >;
  template class
    TAO_Objref_Out_T<
        CORBA::ConstructionPolicy,
        CORBA::tao_ConstructionPolicy_life
      >;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate \
    TAO_Objref_Var_T< \
        CORBA::ConstructionPolicy, \
        CORBA::tao_ConstructionPolicy_life \
      >
# pragma instantiate \
    TAO_Objref_Out_T< \
        CORBA::ConstructionPolicy, \
        CORBA::tao_ConstructionPolicy_life \
      >
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interceptors_cs.cpp:56

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:76

class TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      CORBA::InterfaceDef_ptr object_type,
      const CORBA::Boolean & constr_policy
      ACE_ENV_ARG_DECL_WITH_DEFAULTS);

    virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

    virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

    virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
      ACE_THROW_SPEC ((CORBA::SystemException));

  private:
    TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (const TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager &);
    void operator= (const TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager &);
    CORBA::InterfaceDef_ptr object_type_;
    const CORBA::Boolean & constr_policy_;
  };

  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:376

  TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      CORBA::InterfaceDef_ptr object_type,
      const CORBA::Boolean & constr_policy
      ACE_ENV_ARG_DECL_NOT_USED
    )
      : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
      object_type_ (object_type),
      constr_policy_ (constr_policy)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::arguments (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  Dynamic::ParameterList_var safe_parameter_list = parameter_list;

  parameter_list->length (2);
  CORBA::ULong len = 0;

  TAO_IFR_Client_Adapter *adapter =
    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
        TAO_ORB_Core::ifr_client_adapter_name ()
      );

  adapter->interfacedef_any_insert (
      (*parameter_list)[len].argument,
      this->object_type_
    );

  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->constr_policy_);
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;

  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::exceptions (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return exception_list;
}

CORBA::Any *
TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::result (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);

  return result_any;
}



#endif /* TAO_HAS_INTERCEPTORS */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/remote_proxy_impl_cs.cpp:31

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

CORBA::_TAO_ConstructionPolicy_Proxy_Impl::_TAO_ConstructionPolicy_Proxy_Impl (void)
{}

CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::_TAO_ConstructionPolicy_Remote_Proxy_Impl (void)
{}

// Remote Implementation of the IDL interface methods

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/remote_proxy_impl_cs.cpp:63

void CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::make_domain_manager (
    CORBA::Object *_collocated_tao_target_,
    CORBA::InterfaceDef_ptr object_type,
    CORBA::Boolean constr_policy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();

  if (istub == 0)
    {
      ACE_THROW (CORBA::INTERNAL ());
    }

  TAO_GIOP_Twoway_Invocation _tao_call (
      istub,
      "make_domain_manager",
      19,
      2,
      istub->orb_core ()
    );

  int _invoke_status;

#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_ClientRequestInterceptor_Adapter _tao_vfr (
      istub->orb_core ()->client_request_interceptors (),
      &_tao_call,
      _invoke_status
    );

#endif  /* TAO_HAS_INTERCEPTORS */

  TAO_IFR_Client_Adapter *adapter =
    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
        TAO_ORB_Core::ifr_client_adapter_name ()
      );

  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;

#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager _tao_ri (
          &_tao_call,
          _collocated_tao_target_,
          object_type,
          constr_policy
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;

#endif /* TAO_HAS_INTERCEPTORS */

      CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
      TAO_INTERCEPTOR (_tao_ri.response_expected (1));

#if TAO_HAS_INTERCEPTORS == 1

      ACE_TRY
        {
          _tao_vfr.send_request (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          if (_invoke_status == TAO_INVOKE_RESTART)
            {
              _tao_call.restart_flag (1);
            }
          else
            {

#endif /* TAO_HAS_INTERCEPTORS */

              _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
              TAO_INTERCEPTOR_CHECK;

              _tao_call.prepare_header (
                  ACE_static_cast (CORBA::Octet, _tao_response_flag)
                  ACE_ENV_ARG_PARAMETER
                );
              TAO_INTERCEPTOR_CHECK;

              TAO_OutputCDR &_tao_out = _tao_call.out_stream ();

              if (!(
                  (adapter->interfacedef_cdr_insert (_tao_out, object_type)) &&
                  (_tao_out << CORBA::Any::from_boolean (constr_policy))
                  ))
                {
                  TAO_OutputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER);
                  TAO_INTERCEPTOR_CHECK;

                }

              _invoke_status =
                _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
              TAO_INTERCEPTOR_CHECK;

              if (_invoke_status == TAO_INVOKE_EXCEPTION)
                {
                  TAO_INTERCEPTOR_THROW (
                      CORBA::UNKNOWN (
                          CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES
                        )
                    );
                }
              else if (_invoke_status == TAO_INVOKE_RESTART)
                {
                  _tao_call.restart_flag (1);
                  TAO_INTERCEPTOR (
                      _tao_ri.reply_status (_invoke_status);
                      _tao_vfr.receive_other (
                          &_tao_ri
                          ACE_ENV_ARG_PARAMETER
                        );
                      ACE_TRY_CHECK;
                    )
                }
              else
                {
#if TAO_HAS_INTERCEPTORS == 1

                  _tao_ri.reply_status (_invoke_status);
                  _tao_vfr.receive_reply (
                      &_tao_ri
                      ACE_ENV_ARG_PARAMETER
                    );
                  ACE_TRY_CHECK;

#endif  /* TAO_HAS_INTERCEPTORS */
                }

#if TAO_HAS_INTERCEPTORS == 1
            }
        }
      ACE_CATCHANY
        {
          _tao_ri.exception (&ACE_ANY_EXCEPTION);
          _tao_vfr.receive_exception (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          const PortableInterceptor::ReplyStatus _tao_status =
            _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
              || _tao_status == PortableInterceptor::USER_EXCEPTION)
            {
              ACE_RE_THROW;
            }
        }

# if defined (ACE_HAS_EXCEPTIONS) \
     && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
      ACE_CATCHALL
        {
          CORBA::UNKNOWN ex;

          _tao_ri.exception (&ex);
          _tao_vfr.receive_exception (
              &_tao_ri
              ACE_ENV_ARG_PARAMETER
            );
          ACE_TRY_CHECK;

          const PortableInterceptor::ReplyStatus _tao_status =
            _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
            ACE_TRY_THROW (ex);
        }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */

      ACE_ENDTRY;
      ACE_CHECK;

      const PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      if (_tao_status != PortableInterceptor::LOCATION_FORWARD
          && _tao_status != PortableInterceptor::TRANSPORT_RETRY)

#endif  /* TAO_HAS_INTERCEPTORS */

        if (_invoke_status != TAO_INVOKE_RESTART)
          break;
    }
}

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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/remote_proxy_broker_cs.cpp:31

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

CORBA::_TAO_ConstructionPolicy_Proxy_Broker::_TAO_ConstructionPolicy_Proxy_Broker (void)
{
}

CORBA::_TAO_ConstructionPolicy_Proxy_Broker::~_TAO_ConstructionPolicy_Proxy_Broker (void)
{
}

CORBA::_TAO_ConstructionPolicy_Proxy_Broker * (*CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker *
CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::the_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
{
  static ::CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
{
}

CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::~_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
{
}

CORBA::_TAO_ConstructionPolicy_Proxy_Impl&
CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::select_proxy (
    ::CORBA::ConstructionPolicy *
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  return this->remote_proxy_impl_;
}

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

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/interface_cs.cpp:232

CORBA::ConstructionPolicy::ConstructionPolicy (int collocated)
{
  this->CORBA_ConstructionPolicy_setup_collocation (collocated);
}

void
CORBA::ConstructionPolicy::CORBA_ConstructionPolicy_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_ConstructionPolicy_Proxy_Broker_ =
      ::CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_ConstructionPolicy_Proxy_Broker_ =
      ::CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::the_TAO_ConstructionPolicy_Remote_Proxy_Broker ();

  this->CORBA_Policy_setup_collocation (collocated);
}

CORBA::ConstructionPolicy::~ConstructionPolicy (void)
{}

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

CORBA::ConstructionPolicy_ptr
CORBA::ConstructionPolicy::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    {
      return ConstructionPolicy::_nil ();
    }

  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a =
        obj->_is_a (
            "IDL:omg.org/CORBA/ConstructionPolicy:1.0"
            ACE_ENV_ARG_PARAMETER
          );
      ACE_CHECK_RETURN (ConstructionPolicy::_nil ());

      if (is_a == 0)
        {
          return ConstructionPolicy::_nil ();
        }
    }

  return ConstructionPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

CORBA::ConstructionPolicy_ptr
CORBA::ConstructionPolicy::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    {
      return ConstructionPolicy::_nil ();
    }

  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();

      if (stub != 0)
        {
          stub->_incr_refcnt ();
        }

      ConstructionPolicy_ptr default_proxy = ConstructionPolicy::_nil ();

      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::CORBA::ConstructionPolicy (
                  stub,
                  1,
                  obj->_servant ()
                ),
              ConstructionPolicy::_nil ()
            );
        }

      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::CORBA::ConstructionPolicy (
                  stub,
                  0,
                  obj->_servant ()
                ),
              ConstructionPolicy::_nil ()
            );
        }

      return default_proxy;
    }
  else
    return
      ACE_reinterpret_cast (
          ConstructionPolicy_ptr,
          obj->_tao_QueryInterface (
              ACE_reinterpret_cast (
                  ptrdiff_t,
                  &ConstructionPolicy::_tao_class_id
                )
            )
        );
}

CORBA::ConstructionPolicy_ptr
CORBA::ConstructionPolicy::_duplicate (ConstructionPolicy_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }

  return obj;
}

CORBA::Boolean
CORBA::ConstructionPolicy::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/ConstructionPolicy:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Policy:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

void *CORBA::ConstructionPolicy::_tao_QueryInterface (ptrdiff_t type)
{
  void *retv = 0;

  if (type == ACE_reinterpret_cast (
              ptrdiff_t,
              &ACE_NESTED_CLASS (::CORBA, ConstructionPolicy)::_tao_class_id)
            )
    {
      retv = ACE_reinterpret_cast (void*, this);
    }
  else if (type == ACE_reinterpret_cast (
              ptrdiff_t,
              &::CORBA::Policy::_tao_class_id)
            )
    {
      retv =
        ACE_reinterpret_cast (
            void *,
            ACE_static_cast (
                CORBA::Policy_ptr,
                this
              )
          );
    }
  else if (type == ACE_reinterpret_cast (
               ptrdiff_t,
               &CORBA::Object::_tao_class_id)
             )
    {
      retv =
        ACE_reinterpret_cast (
            void *,
            ACE_static_cast (CORBA::Object_ptr, this)
          );
    }

  if (retv != 0)
    {
      this->_add_ref ();
    }

  return retv;
}

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

CORBA::Boolean
CORBA::ConstructionPolicy::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/operation_cs.cpp:80

void CORBA::ConstructionPolicy::make_domain_manager (
    CORBA::InterfaceDef_ptr object_type,
    CORBA::Boolean constr_policy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  _TAO_ConstructionPolicy_Proxy_Impl &proxy =
    this->the_TAO_ConstructionPolicy_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  proxy.make_domain_manager (
      this,
      object_type,
      constr_policy
      ACE_ENV_ARG_PARAMETER
    );
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_typecode/typecode_defn.cpp:284

static const CORBA::Long _oc_CORBA_ConstructionPolicy[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  41,
  ACE_NTOHL (0x49444c3a),
  ACE_NTOHL (0x6f6d672e),
  ACE_NTOHL (0x6f72672f),
  ACE_NTOHL (0x434f5242),
  ACE_NTOHL (0x412f436f),
  ACE_NTOHL (0x6e737472),
  ACE_NTOHL (0x75637469),
  ACE_NTOHL (0x6f6e506f),
  ACE_NTOHL (0x6c696379),
  ACE_NTOHL (0x3a312e30),
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ConstructionPolicy:1.0
    19,
  ACE_NTOHL (0x436f6e73),
  ACE_NTOHL (0x74727563),
  ACE_NTOHL (0x74696f6e),
  ACE_NTOHL (0x506f6c69),
  ACE_NTOHL (0x63790000),  // name = ConstructionPolicy
  };

static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstructionPolicy (
    CORBA::tk_objref,
    sizeof (_oc_CORBA_ConstructionPolicy),
    (char *) &_oc_CORBA_ConstructionPolicy,
    0,
    sizeof (CORBA::ConstructionPolicy)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (CORBA)
TAO_NAMESPACE_DEFINE (
    ::CORBA::TypeCode_ptr,
    _tc_ConstructionPolicy,
    &_tc_TAO_tc_CORBA_ConstructionPolicy
  )
TAO_NAMESPACE_END

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/sequence_cs.cpp:50

CORBA::DomainManagerList::DomainManagerList (void)
{}

CORBA::DomainManagerList::DomainManagerList (CORBA::ULong max)
  : TAO_Unbounded_Object_Sequence<
        CORBA::DomainManager,
        CORBA::DomainManager_var,
        CORBA::tao_DomainManager_life,
        CORBA::tao_DomainManager_cast
      >
    (max)
{}

CORBA::DomainManagerList::DomainManagerList (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::DomainManager_ptr *buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Object_Sequence<
        CORBA::DomainManager,
        CORBA::DomainManager_var,
        CORBA::tao_DomainManager_life,
        CORBA::tao_DomainManager_cast
      >
    (max, length, buffer, release)
{}

CORBA::DomainManagerList::DomainManagerList (const DomainManagerList &seq)
  : TAO_Unbounded_Object_Sequence<
        CORBA::DomainManager,
        CORBA::DomainManager_var,
        CORBA::tao_DomainManager_life,
        CORBA::tao_DomainManager_cast
      >
    (seq)
{}

CORBA::DomainManagerList::~DomainManagerList (void)
{}

void CORBA::DomainManagerList::_tao_any_destructor (void *_tao_void_pointer)
{
  DomainManagerList *tmp = ACE_static_cast (DomainManagerList*, _tao_void_pointer);
  delete tmp;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)

template class
  TAO_MngSeq_Var_T<
      CORBA::DomainManagerList,
      TAO_Object_Manager<
          CORBA::DomainManager,
          CORBA::DomainManager_var,
          CORBA::tao_DomainManager_life
        >
    >;
template class TAO_Unbounded_Object_Sequence<CORBA::DomainManager,
                                             CORBA::DomainManager_var,
                                             CORBA::tao_DomainManager_life,
                                             CORBA::tao_DomainManager_cast>;

template class
  TAO_MngSeq_Out_T<
      CORBA::DomainManagerList,
      CORBA::DomainManagerList_var,
      TAO_Object_Manager<
          CORBA::DomainManager,
          CORBA::DomainManager_var,
          CORBA::tao_DomainManager_life
        >
    >;

#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)

# pragma instantiate \
    TAO_MngSeq_Var_T< \
        CORBA::DomainManagerList, \
        TAO_Object_Manager< \
            CORBA::DomainManager, \
            CORBA::DomainManager_var, \
            CORBA::tao_DomainManager_life \
          > \
      >
#pragma instantiate TAO_Unbounded_Object_Sequence<CORBA::DomainManager,
                                                  CORBA::DomainManager_var,
                                                  CORBA::tao_DomainManager_life,
                                                  CORBA::tao_DomainManager_cast>

# pragma instantiate \
    TAO_Seq_Out_T< \
        CORBA::DomainManagerList, \
        CORBA::DomainManagerList_var, \
        TAO_Object_Manager< \
            CORBA::DomainManager, \
            CORBA::DomainManager_var, \
            CORBA::tao_DomainManager_life \
          > \
      >

#endif /* !ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_typecode/typecode_defn.cpp:284

  static const CORBA::Long _oc_CORBA_DomainManagerList[] =
  {
        TAO_ENCAP_BYTE_ORDER, // byte order
    40,
    ACE_NTOHL (0x49444c3a),
    ACE_NTOHL (0x6f6d672e),
    ACE_NTOHL (0x6f72672f),
    ACE_NTOHL (0x434f5242),
    ACE_NTOHL (0x412f446f),
    ACE_NTOHL (0x6d61696e),
    ACE_NTOHL (0x4d616e61),
    ACE_NTOHL (0x6765724c),
    ACE_NTOHL (0x6973743a),
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManagerList:1.0
        18,
    ACE_NTOHL (0x446f6d61),
    ACE_NTOHL (0x696e4d61),
    ACE_NTOHL (0x6e616765),
    ACE_NTOHL (0x724c6973),
    ACE_NTOHL (0x74000000),  // name = DomainManagerList
        CORBA::tk_sequence, // typecode kind
    80, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_objref, // typecode kind
      64, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        36,
        ACE_NTOHL (0x49444c3a),
        ACE_NTOHL (0x6f6d672e),
        ACE_NTOHL (0x6f72672f),
        ACE_NTOHL (0x434f5242),
        ACE_NTOHL (0x412f446f),
        ACE_NTOHL (0x6d61696e),
        ACE_NTOHL (0x4d616e61),
        ACE_NTOHL (0x6765723a),
        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManager:1.0
                14,
        ACE_NTOHL (0x446f6d61),
        ACE_NTOHL (0x696e4d61),
        ACE_NTOHL (0x6e616765),
        ACE_NTOHL (0x72000000),  // name = DomainManager

      0U,

};

  static CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManagerList (
      CORBA::tk_alias,
      sizeof (_oc_CORBA_DomainManagerList),
      (char *) &_oc_CORBA_DomainManagerList,
      0,
      sizeof (CORBA::DomainManagerList)
    );

  TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
  TAO_NAMESPACE_BEGIN (CORBA)
  TAO_NAMESPACE_DEFINE (
      ::CORBA::TypeCode_ptr,
      _tc_DomainManagerList,
      &_tc_TAO_tc_CORBA_DomainManagerList
    )
  TAO_NAMESPACE_END

  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/any_op_cs.cpp:52

  // Copying insertion.
  void
  operator<<= (
      CORBA::Any &_tao_any,
      CORBA::DomainManager_ptr _tao_elem
    )
  {
    CORBA::DomainManager_ptr _tao_objptr =
      CORBA::DomainManager::_duplicate (_tao_elem);
    _tao_any <<= &_tao_objptr;
  }

  // Non-copying insertion.
  void
  operator<<= (
      CORBA::Any &_tao_any,
      CORBA::DomainManager_ptr *_tao_elem
    )
  {
    TAO::Any_Impl_T<CORBA::DomainManager>::insert (
        _tao_any,
        CORBA::DomainManager::_tao_any_destructor,
        CORBA::_tc_DomainManager,
        *_tao_elem
      );
  }

  CORBA::Boolean
  operator>>= (
      const CORBA::Any &_tao_any,
      CORBA::DomainManager_ptr &_tao_elem
    )
  {
    return
      TAO::Any_Impl_T<CORBA::DomainManager>::extract (
          _tao_any,
          CORBA::DomainManager::_tao_any_destructor,
          CORBA::_tc_DomainManager,
          _tao_elem
        );
  }

  template<>
  CORBA::Boolean
  TAO::Any_Impl_T<CORBA::DomainManager>::to_object (
      CORBA::Object_ptr &_tao_elem
    ) const
  {
    _tao_elem = CORBA::Object::_duplicate (this->value_);
    return 1;
  }

  #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
      defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var, CORBA::tao_DomainManager_life>;
    template class TAO::Any_Impl_T<CORBA::DomainManager>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  # pragma instantiate TAO_Object_Manager<CORBA::DomainManager, CORBA::DomainManager_var, CORBA::tao_DomainManager_life>
  # pragma instantiate TAO::Any_Impl_T<CORBA::DomainManager>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/any_op_cs.cpp:52

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CORBA::ConstructionPolicy_ptr _tao_elem
  )
{
  CORBA::ConstructionPolicy_ptr _tao_objptr =
    CORBA::ConstructionPolicy::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    CORBA::ConstructionPolicy_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<CORBA::ConstructionPolicy>::insert (
      _tao_any,
      CORBA::ConstructionPolicy::_tao_any_destructor,
      CORBA::_tc_ConstructionPolicy,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    CORBA::ConstructionPolicy_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<CORBA::ConstructionPolicy>::extract (
        _tao_any,
        CORBA::ConstructionPolicy::_tao_any_destructor,
        CORBA::_tc_ConstructionPolicy,
        _tao_elem
      );
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO_Object_Manager<CORBA::ConstructionPolicy,CORBA::ConstructionPolicy_var, CORBA::tao_ConstructionPolicy_life>;
  template class TAO::Any_Impl_T<CORBA::ConstructionPolicy>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate TAO_Object_Manager<CORBA::ConstructionPolicy, CORBA::ConstructionPolicy_var, CORBA::tao_ConstructionPolicy_life>
# pragma instantiate TAO::Any_Impl_T<CORBA::ConstructionPolicy>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/any_op_cs.cpp:54

// Copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    const CORBA::DomainManagerList &_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CORBA::DomainManagerList>::insert_copy (
      _tao_any,
      CORBA::DomainManagerList::_tao_any_destructor,
      CORBA::_tc_DomainManagerList,
      _tao_elem
    );
}

// Non-copying insertion.
void operator<<= (
    CORBA::Any &_tao_any,
    CORBA::DomainManagerList *_tao_elem
  )
{
  TAO::Any_Dual_Impl_T<CORBA::DomainManagerList>::insert (
      _tao_any,
      CORBA::DomainManagerList::_tao_any_destructor,
      CORBA::_tc_DomainManagerList,
      _tao_elem
    );
}

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

// Extraction to const pointer.
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    const CORBA::DomainManagerList *&_tao_elem
  )
{
  return
    TAO::Any_Dual_Impl_T<CORBA::DomainManagerList>::extract (
        _tao_any,
        CORBA::DomainManagerList::_tao_any_destructor,
        CORBA::_tc_DomainManagerList,
        _tao_elem
      );
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO::Any_Dual_Impl_T<CORBA::DomainManagerList>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate TAO::Any_Dual_Impl_T<CORBA::DomainManagerList>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CORBA::DomainManager_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CORBA::DomainManager_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;

    if ((strm >> obj.inout ()) == 0)
      {
        return 0;
      }

    // Narrow to the right type.
    _tao_objref =
      CORBA::DomainManager::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const CORBA::ConstructionPolicy_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CORBA::ConstructionPolicy_ptr &_tao_objref
  )
{
  ACE_TRY_NEW_ENV
  {
    CORBA::Object_var obj;

    if ((strm >> obj.inout ()) == 0)
      {
        return 0;
      }

    // Narrow to the right type.
    _tao_objref =
      CORBA::ConstructionPolicy::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}

// TAO_IDL - Generated from
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_sequence/cdr_op_cs.cpp:93

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

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

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

      return _tao_marshal_flag;
    }

  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    CORBA::DomainManagerList &_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 0;
        }

      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);

      // If length is 0 we return true.
      if (0 >= _tao_seq_len)
        {
          return 1;
        }

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

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

      return _tao_marshal_flag;
    }

  return 0;
}