pns.c

mico_example_siegel c源代码

#include "PNS.h"

//--------------------------------------------------------
//  Implementation of stubs
//--------------------------------------------------------

// Stub interface PseudoNameService
PseudoNameService::~PseudoNameService()
{
}

PseudoNameService_ptr PseudoNameService::_duplicate( PseudoNameService_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) )
    _obj->_ref();
  return _obj;
}

void *PseudoNameService::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:PseudoNameService:1.0" ) == 0 )
    return (void *)this;
  return NULL;
}

bool PseudoNameService::_narrow_helper2( CORBA::Object_ptr _obj )
{
  if( strcmp( _obj->_repoid(), "IDL:PseudoNameService:1.0" ) == 0) {
    return true;
  }
  for( vector<CORBA::Narrow_proto>::size_type _i = 0;
       _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
    bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
    if( _res )
      return true;
  }
  return false;
}

PseudoNameService_ptr PseudoNameService::_narrow( CORBA::Object_ptr _obj )
{
  PseudoNameService_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:PseudoNameService:1.0" )))
      return _duplicate( (PseudoNameService_ptr) _p );
    if( _narrow_helper2( _obj ) ) {
      _o = new PseudoNameService_stub;
      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
      return _o;
    }
  }
  return _nil();
}

PseudoNameService_ptr PseudoNameService::_nil()
{
  return NULL;
}

PseudoNameService_stub::~PseudoNameService_stub()
{
}

void PseudoNameService_stub::BindName( const char* ObjectName, CORBA::Object_ptr ObjectRef )
{
  CORBA::Request_var _req = this->_request( "BindName" );
  _req->add_in_arg( "ObjectName" ) <<= CORBA::Any::from_string( (char *) ObjectName, 0 );
  _req->add_in_arg( "ObjectRef" ) <<= CORBA::Any::from_object( ObjectRef, "Object" );
  _req->result()->value()->type( CORBA::_tc_void );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
}


CORBA::Object_ptr PseudoNameService_stub::ResolveName( const char* ObjectName )
{
  CORBA::Request_var _req = this->_request( "ResolveName" );
  _req->add_in_arg( "ObjectName" ) <<= CORBA::Any::from_string( (char *) ObjectName, 0 );
  _req->result()->value()->type( CORBA::_tc_Object );
  _req->invoke();
  #ifdef HAVE_EXCEPTIONS
  if( _req->env()->exception() ) {
    CORBA::Exception *_ex = _req->env()->exception();
    CORBA::UnknownUserException *_uuex = CORBA::UnknownUserException::_narrow( _ex );
    if( _uuex ) {
      mico_throw( CORBA::UNKNOWN() );
    } else {
      mico_throw( *_ex );
    }
  }
  #else
  {
    CORBA::Exception *_ex;
    if( (_ex = _req->env()->exception()) )
      CORBA::Exception::_throw_failed( _ex );
  }
  #endif
  CORBA::Object_ptr _res;
  *_req->result()->value() >>= CORBA::Any::to_object( _res );
  return _res;
}


vector<CORBA::Narrow_proto> * PseudoNameService::_narrow_helpers;
CORBA::TypeCodeConst _tc_PseudoNameService;

CORBA::Boolean
operator<<=( CORBA::Any &_a, const PseudoNameService_ptr _obj )
{
  return (_a <<= CORBA::Any::from_object( _obj, "PseudoNameService" ));
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, PseudoNameService_ptr &_obj )
{
  CORBA::Object_ptr _o;
  if( !(_a >>= CORBA::Any::to_object( _o )) )
    return FALSE;
  if( CORBA::is_nil( _o ) ) {
    _obj = ::PseudoNameService::_nil();
    return TRUE;
  }
  _obj = ::PseudoNameService::_narrow( _o );
  CORBA::release( _o );
  return TRUE;
}

struct __tc_init_PNS {
  __tc_init_PNS()
  {
    _tc_PseudoNameService = "000000000000000e0000003a000000000000001a49444c3a50736575646f"
    "4e616d65536572766963653a312e300000000000001250736575646f4e61"
    "6d655365727669636500";
  }
};

static __tc_init_PNS __init_PNS;

//--------------------------------------------------------
//  Implementation of skeletons
//--------------------------------------------------------

// Dynamic Implementation Routine for interface PseudoNameService
PseudoNameService_skel::PseudoNameService_skel( const CORBA::BOA::ReferenceData &_id )
{
  CORBA::ImplementationDef_var _impl =
    _find_impl( "IDL:PseudoNameService:1.0", "PseudoNameService" );
  assert( !CORBA::is_nil( _impl ) );
  _create_ref( _id,
    CORBA::InterfaceDef::_nil(),
    _impl,
    "IDL:PseudoNameService:1.0" );
  register_dispatcher( new InterfaceDispatcherWrapper<PseudoNameService_skel>( this ) );
}

PseudoNameService_skel::PseudoNameService_skel( CORBA::Object_ptr _obj )
{
  CORBA::ImplementationDef_var _impl =
    _find_impl( "IDL:PseudoNameService:1.0", "PseudoNameService" );
  assert( !CORBA::is_nil( _impl ) );
  _restore_ref( _obj,
    CORBA::BOA::ReferenceData(),
    CORBA::InterfaceDef::_nil(),
    _impl );
  register_dispatcher( new InterfaceDispatcherWrapper<PseudoNameService_skel>( this ) );
}

PseudoNameService_skel::~PseudoNameService_skel()
{
}

bool PseudoNameService_skel::dispatch( CORBA::ServerRequest_ptr _req, CORBA::Environment & /*_env*/ )
{
  if( strcmp( _req->op_name(), "BindName" ) == 0 ) {
    CORBA::String_var ObjectName;
    CORBA::Object_var ObjectRef;

    CORBA::NVList_ptr _args = new CORBA::NVList (2);
    _args->add( CORBA::ARG_IN );
    _args->item( 0 )->value()->type( CORBA::_tc_string );
    _args->add( CORBA::ARG_IN );
    _args->item( 1 )->value()->type( CORBA::_tc_Object );

    if (!_req->params( _args ))
      return true;

    *_args->item( 0 )->value() >>= CORBA::Any::to_string( ObjectName, 0 );
    *_args->item( 1 )->value() >>= CORBA::Any::to_object( ObjectRef );
    #ifdef HAVE_EXCEPTIONS
    try {
    #endif
      BindName( ObjectName, ObjectRef );
    #ifdef HAVE_EXCEPTIONS
    } catch( CORBA::SystemException_var &_ex ) {
      _req->exception( _ex->_clone() );
      return true;
    } catch( ... ) {
      assert( 0 );
      return true;
    }
    #endif
    return true;
  }
  if( strcmp( _req->op_name(), "ResolveName" ) == 0 ) {
    CORBA::String_var ObjectName;

    CORBA::NVList_ptr _args = new CORBA::NVList (1);
    _args->add( CORBA::ARG_IN );
    _args->item( 0 )->value()->type( CORBA::_tc_string );

    if (!_req->params( _args ))
      return true;

    *_args->item( 0 )->value() >>= CORBA::Any::to_string( ObjectName, 0 );
    CORBA::Object_ptr _res;
    #ifdef HAVE_EXCEPTIONS
    try {
    #endif
      _res = ResolveName( ObjectName );
    #ifdef HAVE_EXCEPTIONS
    } catch( CORBA::SystemException_var &_ex ) {
      _req->exception( _ex->_clone() );
      return true;
    } catch( ... ) {
      assert( 0 );
      return true;
    }
    #endif
    CORBA::Any *_any_res = new CORBA::Any;
    *_any_res <<= CORBA::Any::from_object( _res, "Object" );
    CORBA::release( _res );
    _req->result( _any_res );
    return true;
  }
  return false;
}

PseudoNameService_ptr PseudoNameService_skel::_this()
{
  return PseudoNameService::_duplicate( this );
}