/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2001 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include "Aufgabe2.h"


using namespace std;

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

/*
 * Base interface for class Server
 */

Aufgabe2::Server::~Server()
{
}

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

Aufgabe2::Server_ptr
Aufgabe2::Server::_narrow( CORBA::Object_ptr _obj )
{
  Aufgabe2::Server_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:Aufgabe2/Server:1.0" )))
      return _duplicate( (Aufgabe2::Server_ptr) _p );
    if (!strcmp (_obj->_repoid(), "IDL:Aufgabe2/Server:1.0") || _obj->_is_a_remote ("IDL:Aufgabe2/Server:1.0")) {
      _o = new Aufgabe2::Server_stub;
      _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
      return _o;
    }
  }
  return _nil();
}

Aufgabe2::Server_ptr
Aufgabe2::Server::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}

class _Marshaller_Aufgabe2_Server : public CORBA::StaticTypeInfo {
    typedef Aufgabe2::Server_ptr _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    void release (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller_Aufgabe2_Server::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_Aufgabe2_Server::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = ::Aufgabe2::Server::_duplicate( *(_MICO_T*) s );
}

void _Marshaller_Aufgabe2_Server::free( StaticValueType v ) const
{
  CORBA::release( *(_MICO_T *) v );
  delete (_MICO_T*) v;
}

void _Marshaller_Aufgabe2_Server::release( StaticValueType v ) const
{
  CORBA::release( *(_MICO_T *) v );
}

CORBA::Boolean _Marshaller_Aufgabe2_Server::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::Object_ptr obj;
  if (!CORBA::_stc_Object->demarshal(dc, &obj))
    return FALSE;
  *(_MICO_T *) v = ::Aufgabe2::Server::_narrow( obj );
  CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v);
  CORBA::release (obj);
  return ret;
}

void _Marshaller_Aufgabe2_Server::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::Object_ptr obj = *(_MICO_T *) v;
  CORBA::_stc_Object->marshal( ec, &obj );
}

CORBA::StaticTypeInfo *_marshaller_Aufgabe2_Server;


/*
 * Stub interface for class Server
 */

Aufgabe2::Server_stub::~Server_stub()
{
}

char* Aufgabe2::Server_stub::reverse( const char* _par_message )
{
  CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message );
  char* _res;
  CORBA::StaticAny __res( CORBA::_stc_string, &_res );

  CORBA::StaticRequest __req( this, "reverse" );
  __req.add_in_arg( &_sa_message );
  __req.set_result( &__res );

  __req.invoke();

  mico_sii_throw( &__req, 
    0);
  return _res;
}


struct __tc_init_AUFGABE2 {
  __tc_init_AUFGABE2()
  {
    _marshaller_Aufgabe2_Server = new _Marshaller_Aufgabe2_Server;
  }
};

static __tc_init_AUFGABE2 __init_AUFGABE2;

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

Aufgabe2::Server_skel::Server_skel( const CORBA::BOA::ReferenceData &_id )
{
  CORBA::ImplementationDef_var _impl =
    _find_impl( "IDL:Aufgabe2/Server:1.0", "Server" );
  _create_ref( _id,
    0,
    _impl,
    "IDL:Aufgabe2/Server:1.0" );
  register_dispatcher( new StaticInterfaceDispatcherWrapper< Server_skel>( this ) );
}

Aufgabe2::Server_skel::Server_skel( CORBA::Object_ptr _obj )
{
  CORBA::ImplementationDef_var _impl =
    _find_impl( "IDL:Aufgabe2/Server:1.0", "Server" );
  assert( !CORBA::is_nil( _impl ) );
  _restore_ref( _obj,
    CORBA::BOA::ReferenceData(),
    0,
    _impl );
  register_dispatcher( new StaticInterfaceDispatcherWrapper< Server_skel>( this ) );
}

Aufgabe2::Server_skel::~Server_skel()
{
}

bool Aufgabe2::Server_skel::dispatch( CORBA::StaticServerRequest_ptr __req, CORBA::Environment & /*_env*/ )
{
  #ifdef HAVE_EXCEPTIONS
  try {
  #endif
    if( strcmp( __req->op_name(), "reverse" ) == 0 ) {
      CORBA::String_var _par_message;
      CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message._for_demarshal() );

      char* _res;
      CORBA::StaticAny __res( CORBA::_stc_string, &_res );
      __req->add_in_arg( &_sa_message );
      __req->set_result( &__res );

      if( !__req->read_args() )
        return true;

      _res = reverse( _par_message.inout() );
      __req->write_results();
      CORBA::string_free( _res );
      return true;
    }
  #ifdef HAVE_EXCEPTIONS
  } catch( CORBA::SystemException_catch &_ex ) {
    __req->set_exception( _ex->_clone() );
    __req->write_results();
    return true;
  } catch( ... ) {
    assert( 0 );
    return true;
  }
  #endif
  return false;
}

Aufgabe2::Server_ptr Aufgabe2::Server_skel::_this()
{
  return Aufgabe2::Server::_duplicate( this );
}