// -*- 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/
// 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
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_codegen.cpp:301


#include "testC.h"
#include "tao/Stub.h"
#include "tao/Invocation_Base.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/Basic_Arguments.h"
#include "tao/UB_String_Arguments.h"

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

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

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

one_bad::one_bad (void)
  : CORBA::UserException (
        "IDL:one_bad:1.0",
        "one_bad"
      )
{
}

one_bad::~one_bad (void)
{
}

one_bad::one_bad (const ::one_bad &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

one_bad&
one_bad::operator= (const ::one_bad &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

one_bad *
one_bad::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:one_bad:1.0", _tao_excp->_rep_id ()))
    {
      return ACE_dynamic_cast (one_bad *, _tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void one_bad::_raise (void)
{
  TAO_RAISE (*this);
}

void one_bad::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void one_bad::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr one_bad::_type (void) const
{
  return ::_tc_one_bad;
}

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

static const CORBA::Long _oc_one_bad[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  16,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6e655f), 
  ACE_NTOHL (0x6261643a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:one_bad:1.0
    8,
  ACE_NTOHL (0x6f6e655f), 
  ACE_NTOHL (0x62616400),  // name = one_bad
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_one_bad (
    CORBA::tk_except,
    sizeof (_oc_one_bad),
    (char *) &_oc_one_bad,
    0,
    sizeof (one_bad)
  );

::CORBA::TypeCode_ptr _tc_one_bad =
  &_tc_TAO_tc_one_bad;

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

two_bad::two_bad (void)
  : CORBA::UserException (
        "IDL:two_bad:1.0",
        "two_bad"
      )
{
}

two_bad::~two_bad (void)
{
}

two_bad::two_bad (const ::two_bad &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

two_bad&
two_bad::operator= (const ::two_bad &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

two_bad *
two_bad::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:two_bad:1.0", _tao_excp->_rep_id ()))
    {
      return ACE_dynamic_cast (two_bad *, _tao_excp);
    }
  else
    {
      return 0;
    }
}

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

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

void two_bad::_raise (void)
{
  TAO_RAISE (*this);
}

void two_bad::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void two_bad::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr two_bad::_type (void) const
{
  return ::_tc_two_bad;
}

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

static const CORBA::Long _oc_two_bad[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  16,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x74776f5f), 
  ACE_NTOHL (0x6261643a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:two_bad:1.0
    8,
  ACE_NTOHL (0x74776f5f), 
  ACE_NTOHL (0x62616400),  // name = two_bad
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_two_bad (
    CORBA::tk_except,
    sizeof (_oc_two_bad),
    (char *) &_oc_two_bad,
    0,
    sizeof (two_bad)
  );

::CORBA::TypeCode_ptr _tc_two_bad =
  &_tc_TAO_tc_two_bad;

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

// Traits specializations for foo.

foo_ptr
TAO::Objref_Traits<foo>::tao_duplicate (
    foo_ptr p
  )
{
  return foo::_duplicate (p);
}

void
TAO::Objref_Traits<foo>::tao_release (
    foo_ptr p
  )
{
  CORBA::release (p);
}

foo_ptr
TAO::Objref_Traits<foo>::tao_nil (void)
{
  return foo::_nil ();
}

CORBA::Boolean
TAO::Objref_Traits<foo>::tao_marshal (
    foo_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return p->marshal (cdr);
}

int foo::_tao_class_id = 0;

foo_ptr
tao_foo_life::tao_duplicate (
    foo_ptr p
  )
{
  return foo::_duplicate (p);
}

void
tao_foo_life::tao_release (
    foo_ptr p
  )
{
  CORBA::release (p);
}

foo_ptr
tao_foo_life::tao_nil (
    void
  )
{
  return foo::_nil ();
}

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

foo_ptr
tao_foo_cast::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return foo::_narrow (p ACE_ENV_ARG_PARAMETER);
}

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

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
  template class
    TAO_Objref_Var_T<
        foo,
        tao_foo_life
      >;
  template class
    TAO_Objref_Out_T<
        foo,
        tao_foo_life
      >;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate \
    TAO_Objref_Var_T< \
        foo, \
        tao_foo_life \
      >
# pragma instantiate \
    TAO_Objref_Out_T< \
        foo, \
        tao_foo_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_foo_all_str : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_foo_all_str (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * inarg,
      char *& inoutarg
      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 (char * result);
    
  private:
    TAO_ClientRequestInfo_foo_all_str (const TAO_ClientRequestInfo_foo_all_str &);
    void operator= (const TAO_ClientRequestInfo_foo_all_str &);
    const char * inarg_;
    char * inoutarg_;
    
    char * _result;
  };
  
  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:376
  
  TAO_ClientRequestInfo_foo_all_str::TAO_ClientRequestInfo_foo_all_str (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * inarg,
      char *& inoutarg
      ACE_ENV_ARG_DECL_NOT_USED      
    )
      : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
      inarg_ (inarg),
      inoutarg_ (inoutarg)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_foo_all_str::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;
  (*parameter_list)[len].argument <<= inarg_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= inoutarg_;
  (*parameter_list)[len].mode = CORBA::PARAM_INOUT;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_foo_all_str::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);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_foo_all_str_exceptiondata[] = 
  {
    _tc_one_bad,
    _tc_two_bad
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_foo_all_str_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode, CORBA::TypeCode_var> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ClientRequestInfo_foo_all_str::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_foo_all_str::result (char * result)
{
  // Update the result. 
  this->_result = result;
}

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

class TAO_ClientRequestInfo_foo_push : public TAO_ClientRequestInfo_i
{
public:
  TAO_ClientRequestInfo_foo_push (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * inarg
      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_foo_push (const TAO_ClientRequestInfo_foo_push &);
    void operator= (const TAO_ClientRequestInfo_foo_push &);
    const char * inarg_;
  };
  
  // TAO_IDL - Generated from
  // W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_operation/interceptors_cs.cpp:376
  
  TAO_ClientRequestInfo_foo_push::TAO_ClientRequestInfo_foo_push (
      TAO_GIOP_Invocation *_tao_invocation,
      CORBA::Object_ptr _tao_target,
      const char * inarg
      ACE_ENV_ARG_DECL_NOT_USED      
    )
      : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
      inarg_ (inarg)
{}

Dynamic::ParameterList *
TAO_ClientRequestInfo_foo_push::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 <<= inarg_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ClientRequestInfo_foo_push::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_foo_push::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. 
//

_TAO_foo_Proxy_Impl::_TAO_foo_Proxy_Impl (void)
{}

_TAO_foo_Remote_Proxy_Impl::_TAO_foo_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

char * _TAO_foo_Remote_Proxy_Impl::all_str (
    CORBA::Object *_collocated_tao_target_,
    const char * inarg,
    char *& inoutarg,
    CORBA::String_out outarg
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , one_bad
    , two_bad
  ))
{
  static TAO_Exception_Data _tao_foo_all_str_exceptiondata [] = 
    {
      {
        "IDL:one_bad:1.0",
        one_bad::_alloc
      },
      
      {
        "IDL:two_bad:1.0",
        two_bad::_alloc
      }
    };
  
  TAO::Arg_Traits<CORBA::Char *>::stub_ret_val _tao_retval;
  TAO::Arg_Traits<CORBA::Char *>::in_arg_val _tao_inarg (inarg);
  TAO::Arg_Traits<CORBA::Char *>::inout_arg_val _tao_inoutarg (inoutarg);
  TAO::Arg_Traits<CORBA::Char *>::out_arg_val _tao_outarg (outarg);
  
  TAO::Argument *_tao_signature [] =
    {
      &_tao_retval,
      &_tao_inarg,
      &_tao_inoutarg,
      &_tao_outarg
    };
  
  TAO::Invocation_Base _tao_call (
      _collocated_tao_target_,
      _tao_signature,
      4,
      "all_str",
      7
    );
  
  _tao_call.invoke (
      _tao_foo_all_str_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());

#if 0
  
  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,
      "all_str",
      7,
      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 */
  
  for (;;)
    {
      _invoke_status = TAO_INVOKE_EXCEPTION;
      
#if TAO_HAS_INTERCEPTORS == 1
      TAO_ClientRequestInfo_foo_all_str _tao_ri (
          &_tao_call,
          _collocated_tao_target_,
          inarg,
          inoutarg
          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 << inarg) &&
                  (_tao_out << inoutarg)
                  ))
                {
                  TAO_OutputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER); 
                  TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

                }
              
              _invoke_status =
                _tao_call.invoke (_tao_foo_all_str_exceptiondata, 2 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
                {                  CORBA::string_free (inoutarg);
                  
                  
                  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
                  _tao_call.transport()->assign_translators (&_tao_in,0);
                  
                  if (!(
                      (_tao_in >> _tao_retval.inout ()) &&
                      (_tao_in >> inoutarg) &&
                      (_tao_in >> outarg.ptr ())
                      ))
                    {
                      TAO_InputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER); 
                      TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());

                      
                    }
                  
#if TAO_HAS_INTERCEPTORS == 1
                  char * _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;
    }

#endif /* 0 */
  
  return _tao_retval.retn ();
}

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

void _TAO_foo_Remote_Proxy_Impl::push (
    CORBA::Object *_collocated_tao_target_,
    const char * inarg
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  TAO::Arg_Traits<void>::stub_ret_val _tao_retval;
  TAO::Arg_Traits<CORBA::Char *>::in_arg_val _tao_inarg (inarg);
  
  TAO::Argument *_tao_signature [] =
    {
      &_tao_retval,
      &_tao_inarg
    };
  
  TAO::Invocation_Base _tao_call (
      _collocated_tao_target_,
      _tao_signature,
      2,
      "push",
      4,
      TAO::TAO_ONEWAY_INVOCATION
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

#if 0
  
  TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
  
  if (istub == 0)
    {
      ACE_THROW (CORBA::INTERNAL ());
    }
    
  TAO_GIOP_Oneway_Invocation _tao_call (
      istub,
      "push",
      4,
      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_foo_push _tao_ri (
          &_tao_call,
          _collocated_tao_target_,
          inarg
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
#endif /* TAO_HAS_INTERCEPTORS */
      
      CORBA::Short _tao_response_flag = _tao_call.sync_scope ();
      TAO_INTERCEPTOR (_tao_ri.response_expected (0));
      
#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 (!(
                  (_tao_out << inarg)
                  ))
                {
                  TAO_OutputCDR::throw_stub_exception (errno ACE_ENV_ARG_PARAMETER); 
                  TAO_INTERCEPTOR_CHECK;

                }
              
              _invoke_status =
                _tao_call.invoke (ACE_ENV_SINGLE_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_other (
                    &_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;
    }

#endif /* 0 */
}

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

_TAO_foo_Proxy_Broker::_TAO_foo_Proxy_Broker (void)
{
}

_TAO_foo_Proxy_Broker::~_TAO_foo_Proxy_Broker (void)
{
}

_TAO_foo_Proxy_Broker * (*_TAO_foo_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// Factory Member function Implementation.
_TAO_foo_Remote_Proxy_Broker *
_TAO_foo_Remote_Proxy_Broker::the_TAO_foo_Remote_Proxy_Broker (void)
{
  static ::_TAO_foo_Remote_Proxy_Broker remote_proxy_broker;
  return &remote_proxy_broker;
}

_TAO_foo_Remote_Proxy_Broker::_TAO_foo_Remote_Proxy_Broker (void)
{
}

_TAO_foo_Remote_Proxy_Broker::~_TAO_foo_Remote_Proxy_Broker (void)
{
}

_TAO_foo_Proxy_Impl&
_TAO_foo_Remote_Proxy_Broker::select_proxy (
    ::foo *
    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:284

foo::foo (int collocated)
{
  this->foo_setup_collocation (collocated);
}

void
foo::foo_setup_collocation (int collocated)
{
  if (collocated)
    this->the_TAO_foo_Proxy_Broker_ =
      ::_TAO_foo_Proxy_Broker_Factory_function_pointer (this);
  else
    this->the_TAO_foo_Proxy_Broker_ =
      ::_TAO_foo_Remote_Proxy_Broker::the_TAO_foo_Remote_Proxy_Broker ();
}

foo::~foo (void)
{}

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

foo_ptr
foo::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  if (CORBA::is_nil (obj))
    {
      return foo::_nil ();
    }
  
  if (! obj->_is_local ())
    {
      CORBA::Boolean is_a =
        obj->_is_a (
            "IDL:foo:1.0"
            ACE_ENV_ARG_PARAMETER
          );
      ACE_CHECK_RETURN (foo::_nil ());
      
      if (is_a == 0)
        {
          return foo::_nil ();
        }
    }
  
  return foo::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

foo_ptr 
foo::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    {
      return foo::_nil ();
    }
  
  foo_ptr default_proxy = foo::_nil ();
  
  // Code for lazily evaluated IOR's
  if (!obj->is_evaluated ())
    {
      ACE_NEW_RETURN (
          default_proxy,
          ::foo (
              obj->steal_ior (),
              obj->orb_core ()
            ),
          foo::_nil ()
        );
      
      return default_proxy;
    }
  
  if (! obj->_is_local ())
    {
      TAO_Stub* stub = obj->_stubobj ();
      
      if (stub != 0)
        {
          stub->_incr_refcnt ();
        }
      
      if (
          !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
          stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
          obj->_is_collocated () &&
          _TAO_foo_Proxy_Broker_Factory_function_pointer != 0
        )
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::foo (
                  stub,
                  1,
                  obj->_servant ()
                ),
              foo::_nil ()
            );
        }
      
      if (CORBA::is_nil (default_proxy))
        {
          ACE_NEW_RETURN (
              default_proxy,
              ::foo (
                  stub,
                  0,
                  obj->_servant ()
                ),
              foo::_nil ()
            );
        }
      
      return default_proxy;
    }
  else 
    return
      ACE_reinterpret_cast (
          foo_ptr,
          obj->_tao_QueryInterface (
              ACE_reinterpret_cast (
                  ptrdiff_t,
                  &foo::_tao_class_id
                )
            )
        );
}

foo_ptr
foo::_duplicate (foo_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
foo::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:foo: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 *foo::_tao_QueryInterface (ptrdiff_t type)
{
  void *retv = 0;
  
  if (type == ACE_reinterpret_cast (
              ptrdiff_t,
              &foo::_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* foo::_interface_repository_id (void) const
{
  return "IDL:foo:1.0";
}

CORBA::Boolean
foo::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

char * foo::all_str (
    const char * inarg,
    char *& inoutarg,
    CORBA::String_out outarg
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
    , one_bad
    , two_bad
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    
    }
  if (this->the_TAO_foo_Proxy_Broker_ == 0)
    {
      foo_setup_collocation (
          this->ACE_NESTED_CLASS (CORBA, Object)::_is_collocated ()
        );
    }
  
  _TAO_foo_Proxy_Impl &proxy = 
    this->the_TAO_foo_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return proxy.all_str (
      this,
      inarg,
      inoutarg,
      outarg
      ACE_ENV_ARG_PARAMETER
    );
}

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

void foo::push (
    const char * inarg
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    
    }
  if (this->the_TAO_foo_Proxy_Broker_ == 0)
    {
      foo_setup_collocation (
          this->ACE_NESTED_CLASS (CORBA, Object)::_is_collocated ()
        );
    }
  
  _TAO_foo_Proxy_Impl &proxy = 
    this->the_TAO_foo_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  proxy.push (
      this,
      inarg
      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_foo[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  12,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x666f6f3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:foo:1.0
    4,
  ACE_NTOHL (0x666f6f00),  // name = foo
  };

static CORBA::TypeCode _tc_TAO_tc_foo (
    CORBA::tk_objref,
    sizeof (_oc_foo),
    (char *) &_oc_foo,
    0,
    sizeof (foo)
  );

::CORBA::TypeCode_ptr _tc_foo =
  &_tc_TAO_tc_foo;

// TAO_IDL - Generated from 
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_exception/any_op_cs.cpp:50

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

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

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

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

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

// TAO_IDL - Generated from 
// W:\ACE_wrappers\TAO\TAO_IDL\be\be_visitor_exception/any_op_cs.cpp:50

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

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

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

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

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

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

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

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

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    foo_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<foo>::extract (
        _tao_any,
        foo::_tao_any_destructor,
        _tc_foo,
        _tao_elem
      );
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
  template class TAO::Any_Impl_T<foo>;
#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
# pragma instantiate TAO::Any_Impl_T<foo>
#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 foo_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    foo_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 =
      foo::_unchecked_narrow (
          obj.in ()
          ACE_ENV_ARG_PARAMETER
        );
    ACE_TRY_CHECK;
    return 1;
  }
  ACE_CATCHANY
  {
    // do nothing
  }
  ACE_ENDTRY;
  return 0;
}