CORBA Anwendung Gültigkeitsbereich

[BoosterBey]

Es geht um folgendes. Ich habe versucht mit mico die IDL zu kompelieren:

module broadcast{
        interface messages {
                /* Abfragen aller Nachrichten */
                string getmessages(in string rechnerid, out boolean getall);
                /* Senden einer Nachricht */
                long dropmessage(in string message, in long msgID);
                /* Abfragen der eindeutigen Nachrichtennummer */
                long getmsgid(in string rechnerid);
        };
};

klappt au. Heraus kamen die automatisch generierten Klassen messages.h und .cpp . Hab ich ans Ende ran gestellt weil ich denke das der Fehler in der Klasse client_test.cpp liegt. Die hab ich dann selber geschrieben und immer wieder kommt der mit den Meldungen:

client_test.cpp:40: Fehler: »messages_var« wurde in diesem Gültigkeitsbereich nicht definiert
client_test.cpp:40: Fehler: expected `;' before »f«
client_test.cpp:42: Fehler: »getmessages« wurde in diesem Gültigkeitsbereich nicht definiert

Prinzipeill gesehen müsste er darauf zugreifen können.
Das ganze basiert auf dem Beispiel von:
http://cplus.kompf.de/corbatut.html

#include <CORBA.h>
#include "messages.h"
#include <coss/CosNaming.h>

#include <iostream> 

using namespace std;

int main( int argc, char **argv)
{
    CORBA::ORB_var orb = CORBA::ORB_init( argc, argv);

    int rc = 0;
    if (argc != 3) {
        cerr << "usage: " << argv[0] << " name number\n";
        exit(1);
    }
    try {
        // resolve the naming service
        CORBA::Object_var nsobj =
            orb->resolve_initial_references ("NameService");
        if (CORBA::is_nil( nsobj)) {
            cerr << "can't resolve NameService\n";
            exit(1);
        }
        // narrow the root naming context
        CosNaming::NamingContext_var nc =
            CosNaming::NamingContext::_narrow (nsobj);

        // create a name component
        CosNaming::Name name;
        name.length (1);
        name[0].id = CORBA::string_dup ("TestServer");
        name[0].kind = CORBA::string_dup ("");

        CORBA::Object_var obj = nc->resolve( name);

        messages_var f = messages::_narrow( obj);

	getmessages(argv[1], argv[2]); 
	 }
    catch(CORBA::SystemException_catch& ex)
    {
        ex -> _print(cerr);
        cerr << endl;
        rc = 1;
    }

    return rc;
}

die messages.cpp:

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

#include <messages.h>

using namespace std;

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

/*
 * Base interface for class messages
 */

broadcast::messages::~messages()
{
}

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

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

broadcast::messages_ptr
broadcast::messages::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}

class _Marshaller_broadcast_messages : public ::CORBA::StaticTypeInfo {
    typedef broadcast::messages_ptr _MICO_T;
  public:
    ~_Marshaller_broadcast_messages();
    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;
};

_Marshaller_broadcast_messages::~_Marshaller_broadcast_messages()
{
}

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

void _Marshaller_broadcast_messages::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = ::broadcast::messages::_duplicate( *(_MICO_T*) s );
}

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

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

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

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

::CORBA::StaticTypeInfo *_marshaller_broadcast_messages;

/*
 * Stub interface for class messages
 */

broadcast::messages_stub::~messages_stub()
{
}

#ifndef MICO_CONF_NO_POA

void *
POA_broadcast::messages::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:broadcast/messages:1.0") == 0) {
    return (void *) this;
  }
  return NULL;
}

POA_broadcast::messages *
POA_broadcast::messages::_narrow (PortableServer::Servant serv) 
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:broadcast/messages:1.0")) != NULL) {
    serv->_add_ref ();
    return (POA_broadcast::messages *) p;
  }
  return NULL;
}

broadcast::messages_stub_clp::messages_stub_clp ()
{
}

broadcast::messages_stub_clp::messages_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : CORBA::Object(*obj), PortableServer::StubBase(poa)
{
}

broadcast::messages_stub_clp::~messages_stub_clp ()
{
}

#endif // MICO_CONF_NO_POA

char* broadcast::messages_stub::getmessages( const char* _par_rechnerid, CORBA::Boolean_out _par_getall )
{
  CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid );
  CORBA::StaticAny _sa_getall( CORBA::_stc_boolean, &_par_getall );
  char* _res = NULL;
  CORBA::StaticAny __res( CORBA::_stc_string, &_res );

  CORBA::StaticRequest __req( this, "getmessages" );
  __req.add_in_arg( &_sa_rechnerid );
  __req.add_out_arg( &_sa_getall );
  __req.set_result( &__res );

  __req.invoke();

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

#ifndef MICO_CONF_NO_POA

char*
broadcast::messages_stub_clp::getmessages( const char* _par_rechnerid, CORBA::Boolean_out _par_getall )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      char* __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->getmessages(_par_rechnerid, _par_getall);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::getmessages(_par_rechnerid, _par_getall);
}

#endif // MICO_CONF_NO_POA

CORBA::Long broadcast::messages_stub::dropmessage( const char* _par_message, CORBA::Long _par_msgID )
{
  CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message );
  CORBA::StaticAny _sa_msgID( CORBA::_stc_long, &_par_msgID );
  CORBA::Long _res;
  CORBA::StaticAny __res( CORBA::_stc_long, &_res );

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

  __req.invoke();

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

#ifndef MICO_CONF_NO_POA

CORBA::Long
broadcast::messages_stub_clp::dropmessage( const char* _par_message, CORBA::Long _par_msgID )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      CORBA::Long __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->dropmessage(_par_message, _par_msgID);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::dropmessage(_par_message, _par_msgID);
}

#endif // MICO_CONF_NO_POA

CORBA::Long broadcast::messages_stub::getmsgid( const char* _par_rechnerid )
{
  CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid );
  CORBA::Long _res;
  CORBA::StaticAny __res( CORBA::_stc_long, &_res );

  CORBA::StaticRequest __req( this, "getmsgid" );
  __req.add_in_arg( &_sa_rechnerid );
  __req.set_result( &__res );

  __req.invoke();

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

#ifndef MICO_CONF_NO_POA

CORBA::Long
broadcast::messages_stub_clp::getmsgid( const char* _par_rechnerid )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      CORBA::Long __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->getmsgid(_par_rechnerid);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::getmsgid(_par_rechnerid);
}

#endif // MICO_CONF_NO_POA

struct __tc_init_MESSAGES {
  __tc_init_MESSAGES()
  {
    _marshaller_broadcast_messages = new _Marshaller_broadcast_messages;
  }

  ~__tc_init_MESSAGES()
  {
    delete static_cast<_Marshaller_broadcast_messages*>(_marshaller_broadcast_messages);
  }
};

static __tc_init_MESSAGES __init_MESSAGES;

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

// PortableServer Skeleton Class for interface broadcast::messages
POA_broadcast::messages::~messages()
{
}

::broadcast::messages_ptr
POA_broadcast::messages::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this();
  return ::broadcast::messages::_narrow (obj);
}

CORBA::Boolean
POA_broadcast::messages::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:broadcast/messages:1.0") == 0) {
    return TRUE;
  }
  return FALSE;
}

CORBA::InterfaceDef_ptr
POA_broadcast::messages::_get_interface ()
{
  CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:broadcast/messages:1.0");

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_broadcast::messages::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:broadcast/messages:1.0");
}

CORBA::Object_ptr
POA_broadcast::messages::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new ::broadcast::messages_stub_clp (poa, obj);
}

bool
POA_broadcast::messages::dispatch (CORBA::StaticServerRequest_ptr __req)
{
  #ifdef HAVE_EXCEPTIONS
  try {
  #endif
    if( strcmp( __req->op_name(), "getmessages" ) == 0 ) {
      CORBA::String_var _par_rechnerid;
      CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid._for_demarshal() );
      CORBA::Boolean _par_getall;
      CORBA::StaticAny _sa_getall( CORBA::_stc_boolean, &_par_getall );

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

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

      _res = getmessages( _par_rechnerid.inout(), _par_getall );
      __req->write_results();
      CORBA::string_free( _res );
      return true;
    }
    if( strcmp( __req->op_name(), "dropmessage" ) == 0 ) {
      CORBA::String_var _par_message;
      CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message._for_demarshal() );
      CORBA::Long _par_msgID;
      CORBA::StaticAny _sa_msgID( CORBA::_stc_long, &_par_msgID );

      CORBA::Long _res;
      CORBA::StaticAny __res( CORBA::_stc_long, &_res );
      __req->add_in_arg( &_sa_message );
      __req->add_in_arg( &_sa_msgID );
      __req->set_result( &__res );

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

      _res = dropmessage( _par_message.inout(), _par_msgID );
      __req->write_results();
      return true;
    }
    if( strcmp( __req->op_name(), "getmsgid" ) == 0 ) {
      CORBA::String_var _par_rechnerid;
      CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid._for_demarshal() );

      CORBA::Long _res;
      CORBA::StaticAny __res( CORBA::_stc_long, &_res );
      __req->add_in_arg( &_sa_rechnerid );
      __req->set_result( &__res );

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

      _res = getmsgid( _par_rechnerid.inout() );
      __req->write_results();
      return true;
    }
  #ifdef HAVE_EXCEPTIONS
  } catch( CORBA::SystemException_catch &_ex ) {
    __req->set_exception( _ex->_clone() );
    __req->write_results();
    return true;
  } catch( ... ) {
    CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
    __req->set_exception (_ex->_clone());
    __req->write_results ();
    return true;
  }
  #endif

  return false;
}

void
POA_broadcast::messages::invoke (CORBA::StaticServerRequest_ptr __req)
{
  if (dispatch (__req)) {
      return;
  }

  CORBA::Exception * ex = 
    new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
  __req->set_exception (ex);
  __req->write_results();
}

und die messages.h

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

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __MESSAGES_H__
#define __MESSAGES_H__

namespace broadcast
{

class messages;
typedef messages *messages_ptr;
typedef messages_ptr messagesRef;
typedef ObjVar< messages > messages_var;
typedef ObjOut< messages > messages_out;

}

namespace broadcast
{

/*
 * Base class and common definitions for interface messages
 */

class messages : 
  virtual public CORBA::Object
{
  public:
    virtual ~messages();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef messages_ptr _ptr_type;
    typedef messages_var _var_type;
    #endif

    static messages_ptr _narrow( CORBA::Object_ptr obj );
    static messages_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static messages_ptr _duplicate( messages_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static messages_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* getmessages( const char* rechnerid, CORBA::Boolean_out getall ) = 0;
    virtual CORBA::Long dropmessage( const char* message, CORBA::Long msgID ) = 0;
    virtual CORBA::Long getmsgid( const char* rechnerid ) = 0;

  protected:
    messages() {};
  private:
    messages( const messages& );
    void operator=( const messages& );
};

// Stub for interface messages
class messages_stub:
  virtual public messages
{
  public:
    virtual ~messages_stub();
    char* getmessages( const char* rechnerid, CORBA::Boolean_out getall );
    CORBA::Long dropmessage( const char* message, CORBA::Long msgID );
    CORBA::Long getmsgid( const char* rechnerid );

  private:
    void operator=( const messages_stub& );
};

#ifndef MICO_CONF_NO_POA

class messages_stub_clp :
  virtual public messages_stub,
  virtual public PortableServer::StubBase
{
  public:
    messages_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~messages_stub_clp ();
    char* getmessages( const char* rechnerid, CORBA::Boolean_out getall );
    CORBA::Long dropmessage( const char* message, CORBA::Long msgID );
    CORBA::Long getmsgid( const char* rechnerid );

  protected:
    messages_stub_clp ();
  private:
    void operator=( const messages_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}

#ifndef MICO_CONF_NO_POA

namespace POA_broadcast
{

class messages : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~messages ();
    broadcast::messages_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static messages * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual char* getmessages( const char* rechnerid, CORBA::Boolean_out getall ) = 0;
    virtual CORBA::Long dropmessage( const char* message, CORBA::Long msgID ) = 0;
    virtual CORBA::Long getmsgid( const char* rechnerid ) = 0;

  protected:
    messages () {};

  private:
    messages (const messages &);
    void operator= (const messages &);
};

}

#endif // MICO_CONF_NO_POA

extern CORBA::StaticTypeInfo *_marshaller_broadcast_messages;

#endif

[drakon]

Der Fehler sollte ja klar sein. Der Compiler finde keine Definition von messages_var . Schau, wo du die definiert hast, respektive wo sie definiert ist und dann schau zu, dass sie auch dort, wo du sie nutzten möchtest einbindest.

[BoosterBey]

das ist mir klar
in der Zeile 25 von der message.h. Nur das ganze ist doch äquivalent zu dem Beispiel was ich gelinkt habe deswegen sollte er das doch genauso kennen... und eine andere Datei wird ja nirgendwo includiert. Das ganze besteht ja eigentlich nur aus den 3 Dateien... und mit dem normalen Beispiel was nicht abgeändetr is funzt es...

[dooooomi]

Wenn du dir die generierte messages.h näher anguckst siehst du, daß sich die Klasse messages mitsamt aller dazugehörigen Definitionen im Namensraum broadcast befindet. Was du brauchst ist also nicht messages_var, sondern broadcast::messages_var, etc.

[BoosterBey]

Danke!!!!!