Logo Search packages:      
Sourcecode: gambas2 version File versions

CCorbaApplication.cpp

/***************************************************************************

  CCorbaApplication.cpp

  CORBA DII routines

  (c) 2005 Carlo Sorda <gambas@users.sourceforge.net><csorda@libero.it>

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 1, or (at your option)
  any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/
#define __CCORBA_APPLICATION_CPP


#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include "main.h"
#include "gambas.h"
#include "gb_common.h"
#include "CCorbaApplication.h"

#include <omniORB4/CORBA.h>

#ifdef HAVE_STD
#  include <iostream>
   using namespace std;
#else
#  include <iostream.h>
#endif

//#define CORBA_DEBUG 0
 
//CORBA::Object_var corbaobj;

      
typedef
  struct {
    char *dcop;
    GB_TYPE type;
    }
  TYPE_CONV;
  
void CORBA_init(void)
{
}
void CORBA_exit(void)
{
  
}

// static void hello(CORBA::Object_ptr obj)
// {
//   
// CORBA::String_var arg = (const char*) "Hello!";
//   CORBA::Request_var req = obj->_request("echoString");
//   req->add_in_arg() <<= arg;
//   req->set_return_type(CORBA::_tc_string);
// 
//   req->invoke();
// 
//   if( req->env()->exception() ) {
//     cout << "echo_diiclt: An exception was thrown!" << endl;
//     return;
//   }
// 
//   const char* ret;
//   req->return_value() >>= ret;
// 
//   cerr << "I said, \"" << (char*)arg << "\"." << endl
//        << "The Echo object replied, \"" << ret <<"\"." << endl;
// }
// static void hello_deferred(CORBA::Object_ptr obj)
// {
//   CORBA::String_var arg = (const char*) "Hello!";
//   CORBA::Request_var req = obj->_request("echoString");
//   req->add_in_arg() <<= arg;
//   req->set_return_type(CORBA::_tc_string);
// 
//   req->send_deferred();
//   cerr << "Sending deferred request: ";
//   while( !req->poll_response() )
//     cerr << '#';
//   cerr << endl << "Response received." << endl;
// 
//   if( req->env()->exception() ) {
//     cout << "echo_diiclt: An exception was thrown!" << endl;
//     return;
//   }
// 
//   const char* ret;
//   req->return_value() >>= ret;
// 
//   cerr << "I said, \"" << (char*)arg << "\"." << endl
//        << "The Echo object replied, \"" << ret <<"\"." << endl;
// }
static CORBA::Object_ptr
getObjectReference(CORBA::ORB_ptr orb, CCORBA_COSNAMING *CosNaming_)
{
      //corbalocAddress = "corbaloc::iiop:172.22.201.24:10435/NameService";
      CosNaming::NamingContext_var rootContext;
      #ifdef CORBA_DEBUG            
            cout << "prima di try" << endl;
      #endif
      try {
      // Obtain a reference to the root context of the Name service:
      CORBA::Object_var obj;
      obj = orb->resolve_initial_references("NameService");
      
            //cout << "dentro try " << corbalocAddress << endl;
      // Narrow the reference returned.
      rootContext = CosNaming::NamingContext::_narrow(obj);
            #ifdef CORBA_DEBUG            
                  cout << "rootContext = CosNaming::NamingContext::_narrow(obj);" << endl;
            #endif

      if( CORBA::is_nil(rootContext) ) {
                        cerr << "Failed to narrow the root naming context." << endl;
            return CORBA::Object::_nil();
      }
      }
  catch(CORBA::ORB::InvalidName& ex) {
    // This should not happen!
      GB.Error("Service required is invalid [does not exist].");
    cerr << "Service required is invalid [does not exist]." << endl;
    return CORBA::Object::_nil();
  }
  catch(...) {
    // This should not happen!
      GB.Error("Errore generale");
    cerr << "Errore generale." << endl;
    return CORBA::Object::_nil();
  }
      

      #ifdef CORBA_DEBUG            
            cout << "dopo try"<< endl;
      #endif
      // Create a name object, containing the name test/context:
      CosNaming::Name name;
      name.length(CosNaming_->name.length());

      for (unsigned int i =0;i<CosNaming_->name.length();i++){
            name[i].id   = CosNaming_->name[i].id;       // string copied
            #ifdef CORBA_DEBUG            
                  cout << "id=" << name[i].id << endl; 
            #endif
            if ( CosNaming_->name[i].kind != 0 ){
                  name[i].kind   = CosNaming_->name[i].kind;       // string copied
                  #ifdef CORBA_DEBUG            
                        cout << "kind=" << name[i].kind << endl; 
                  #endif
                  }

        }
  
      //~ name[0].id   = (const char*) CosNaming_->id;       // string copied
      //~ if ( CosNaming_->kind != 0 )
            //~ name[0].kind   = (const char*) CosNaming_->kind;       // string copied

      #ifdef CORBA_DEBUG            
                  cout << "Dopo assegnazione name"<< endl; 
      #endif

  //name[0].kind = (const char*) ""; // string copied
  // Note on kind: The kind field is used to indicate the type
  // of the object. This is to avoid conventions such as that used
  // by files (name.type -- e.g. test.ps = postscript etc.)


// Create a name object, containing the name test/context:
//   CosNaming::Name name;
//   name.length(2);
// 
//   name[0].id   = (const char*) "test";       // string copied
//   name[0].kind = (const char*) "my_context"; // string copied
//   name[1].id   = (const char*) "Echo";
//   name[1].kind = (const char*) "Object";

      try {
      // Resolve the name to an object reference.
            #ifdef CORBA_DEBUG            
                  cout << "Prima di resolve()"<< endl; 
            #endif
            return rootContext->resolve(name);
            
      }
      catch(CosNaming::NamingContext::NotFound& ex) {
      // This exception is thrown if any of the components of the
      // path [contexts or the object] aren't found:
            GB.Error("Context not found.");
      cerr << "Context not found." << endl;
      }
      catch(CORBA::COMM_FAILURE& ex) {
            GB.Error("Caught system exception COMM_FAILURE -- unable to contact the naming service.");
      cerr << "Caught system exception COMM_FAILURE -- unable to contact the " << "naming service." << endl;
      }
      catch(CORBA::SystemException&) {
            GB.Error("Caught a CORBA::SystemException while using the naming service.");
      cerr << "Caught a CORBA::SystemException while using the naming service." << endl;
      }

  return CORBA::Object::_nil();
}
//~ static void getdress(CORBA::Object_ptr obj)
//~ {
      //~ cout << "Sto eseguendo getddress()" << endl;
      //~ CORBA::String_var arg = (const char*) "34343434";
      //~ CORBA::String_var arg1 = (const char*) "3434";

      //~ CORBA::Request_var req = obj->_request("getddress");
      //~ req->add_in_arg() <<= arg;
      //~ req->add_in_arg() <<= arg1;
      //~ req->set_return_type(CORBA::_tc_string);

      //~ req->invoke();

      //~ if( req->env()->exception() ) {
      //~ cout << "echo_diiclt: An exception was thrown!" << endl;
      //~ return;
      //~ }

  //~ const char* ret;
  //~ req->return_value() >>= ret;

  //~ cerr << "I said, \"" << (char*)arg << "\"." << "\"" << (char*)arg1 << "\"." <<endl
       //~ << "The Echo object replied, \"" << ret <<"\"." << endl;
//~ }
/***************************************************************************

 CORBA

***************************************************************************/
//callIdlMethod(retType, GB.GetUnknown(), ARG(param[0]), GB.NParam()))

static bool callIdlMethod(CORBA::Object_var corbaobj, const char *name, GB_VALUE *args, int nparam)
{
      //hello(corbaobj);      
      GB_VALUE *arg;
      int i,n,retType;
      CORBA::Request_var req;
      //DynamicAny::DynAnyFactory_var fac;

      n = nparam;
      
      #ifdef CORBA_DEBUG
            cout << name << " ( ";
      #endif
      
      //arg = &args[0]; 
      arg = &args[0];
      retType = ((GB_INTEGER *)arg)->value;

//    1 Type 4 AS Integer
//    2 Type 7 AS Float
//    3 Type 8 AS Date
//    4 Type 3 AS Short
//    5 Type 2 AS Byte
//    6 Type 5 AS Long
//    7 Type 16 AS Object
//    8 Type 9-10 AS String
//    9 Type 6 AS Single
//    10 Type 15 AS Variant
      req = corbaobj->_request(name);

   for (i = 1; i < n; i++)
      {
      arg = &args[i];   
            
            #ifdef CORBA_DEBUG
                  cout << "Count=" << i << " " << " Type = " << arg->type << endl;
            #endif
            
            //string -> char*
            if (arg->type == 10){
                  CORBA::String_var argument = (const char*)GB.ToZeroString((GB_STRING*)arg);
                  //CORBA::String_var argument = (const char*)"2323";
                  
                  req->add_in_arg() <<= argument;
                  #ifdef CORBA_DEBUG
                  if (i >  1)
                        cout << ",";

               cout << "\"" << argument << "\"";
                  #endif
            }
            //integer -> short(int)
            //short -> short
            else if (arg->type == 4 || arg->type == 3){
                  CORBA::Short value = ((GB_INTEGER *)arg)->value;
                  //req = corbaobj->_request(name);
                  req->add_in_arg() <<= value;
                  #ifdef CORBA_DEBUG
                  if (i >  1)
                        cout << ",";
                  
                  cout << value;
                  #endif
                  }
            //float -> float
            else if (arg->type == 7){
                  CORBA::Double value = ((GB_FLOAT *)arg)->value;
                  //req = corbaobj->_request(name);
                  req->add_in_arg() <<= value;
                  #ifdef CORBA_DEBUG
                  if (i ==  1)
                        cout << value;
                  else
                        cout << "," << value;
                  #endif
                  }
                              //float -> float
            else if (arg->type == 6){
                  CORBA::Float value = ((GB_FLOAT *)arg)->value;
                  //req = corbaobj->_request(name);
                  req->add_in_arg() <<= value;
                  #ifdef CORBA_DEBUG
                  if (i ==  1)
                        cout << value;
                  else
                        cout << "," << value;
                  #endif
                  }
            //long -> long
            else if (arg->type == 5){
                  CORBA::Long value = ((GB_LONG *)arg)->value;
                  //req = corbaobj->_request(name);
                  req->add_in_arg() <<= value;
                  #ifdef CORBA_DEBUG
                  if (i ==  1)
                        cout << value;
                  else
                        cout << "," << value;
                  #endif
                  }
//          //Boolean
//          else if (arg->type == 1){
//                CORBA::Long value = ((GB_BOOLEAN *)arg)->value;
//                req->add_in_arg() <<= value;
//                #ifdef CORBA_DEBUG
//                if (i >  1)
//                      cout << ",";
//                
//                cout << value;
//                #endif
//                }


      }
      #ifdef CORBA_DEBUG            
            cout << " ) " << endl;
      #endif

      if (retType == 0)
            req->set_return_type(CORBA::_tc_void);    
      else if (retType == 10)
            req->set_return_type(CORBA::_tc_string);  
      else if (retType == 4 || retType == 3)
            req->set_return_type (CORBA::_tc_short);
      else if (retType == 7)  
            req->set_return_type (CORBA::_tc_float);
      else if (retType == 8)  
            req->set_return_type (CORBA::_tc_double);
      else if (retType == 5)  
            req->set_return_type (CORBA::_tc_long);
      else if (retType == 16) 
            req->set_return_type (CORBA::_tc_Object);
      else if (retType == 20) 
            req->set_return_type (CORBA::_tc_ushort);
      else if (retType == 30){      
            req->set_return_type (CORBA::_tc_any);
            cout << "rettype = 30" << endl;
            }
//    else if (retType == 1)  
//          req->set_return_type (CORBA::_tc_boolean);

  req->invoke();

      if( req->env()->exception() ) {
            cout << "An exception was thrown!" << endl;
            GB.Error("An exception was thrown!");
            return false;
      }
      #ifdef CORBA_DEBUG            
      cout << "Command was executed!"<<endl;
      #endif

      if (retType == 0){
            return true;
      }
      //string
      if (retType == 10){
            const char* ret;
            req->return_value() >>= ret;
            GB.ReturnNewZeroString(ret);
      }
      //int
      else if (retType == 4 || retType == 3){
            CORBA::Short ret = 0;
            req->return_value() >>= ret;
            GB.ReturnInteger(ret);
      }
      //float
      else if (retType == 20 ){
            CORBA::UShort ret = 0;
            req->return_value() >>= ret;
            GB.ReturnInteger(ret);
      }

      //float
      else if (retType == 7 ){
            CORBA::Float ret = 0;
            req->return_value() >>= ret;
            GB.ReturnFloat(ret);
      }
      else if (retType == 8 ){
            CORBA::Double ret = 0;
            req->return_value() >>= ret;
            GB.ReturnFloat(ret);
      }

      else if (retType == 5 ){
            CORBA::Long ret = 0;
            req->return_value() >>= ret;
            GB.ReturnLong(ret);
      }
      else if (retType == 16){
            CCORBA_OBJECT *_object = 0;   
            GB.New((void **)&_object, GB.FindClass("CORBAObject"), NULL, NULL);
            //_object->ref = new DCOPRef(dcopref);

            //req->set_return_type (CORBA::_tc_Object);
            // Extract the returned object reference from the request.
      req->return_value () >>= CORBA::Any::to_object (_object->obj_var_.out ());
            GB.ReturnObject(_object);
      }
      else if (retType == 30){
            #ifdef CORBA_DEBUG            
                  cout << "retType=30" << endl;
            #endif
            GB_ARRAY array;
      //const char *data;
            CORBA::Any temp;

      //req->set_return_type (CORBA::_tc_any);
            req->return_value () >>= temp;
            
            CORBA::StringSeq* elem_ptr = new  CORBA::StringSeq();
            
            temp >>= elem_ptr;
            
            
            n =elem_ptr->length();
            cout << "n:" << n << endl;

      GB.Array.New(&array, GB_T_STRING, n);
      for (i = 0; i < n; i++)
      {
                  //data = *elem_ptr[i];
                  //GB.NewString((char **)GB.Array.Get(array, i), data, 0);
      }

      GB.ReturnObject(array);
            
            
            
            //~ CCORBA_OBJECT *_object = 0;     
            //~ GB.New((void **)&_object, GB.FindClass("CORBAObject"), NULL, NULL);
            //~ //_object->ref = new DCOPRef(dcopref);

            //~ req->set_return_type (CORBA::_tc_Object);
            //~ // Extract the returned object reference from the request.
      //~ req->return_value () >>= CORBA::Any::to_object (_object->obj_var_.out ());
            //~ GB.ReturnObject(_object);
      }


/*    //Boolean
      else if (retType == 1 ){
            CORBA::Boolean ret = false;
            req->return_value() >>= ret;
            GB.ReturnBoolean(ret);
      }*/
      return false;
}
#undef THIS
#define THIS ((CCORBA_COSNAMING *)_object)
BEGIN_METHOD_VOID(CCORBA_COSNAMING_new)
      THIS->kind = 0;
      THIS->id = 0;

      //~ for (int i =0;i<THIS->name.length();i++){
                  //~ name[i].id   = CosNaming_->name[i].id;       // string copied
                  //~ if ( CosNaming_->name[i].kind != 0 )
                        //~ name[i].kind   = CosNaming_->name[i].kind;       // string copied
      
              //~ }
        
END_METHOD

BEGIN_METHOD_VOID(CCORBA_COSNAMING_free)
      
END_METHOD
BEGIN_METHOD_VOID(CCORBA_COSNAMING_length)
      
      if (READ_PROPERTY)
      GB.ReturnInteger(THIS->name.length());
      else
      THIS->name.length((VPROP(GB_INTEGER)));
END_METHOD
BEGIN_PROPERTY(CCORBA_COSNAMING_id)
      char* id_ = 0;
      
      if (READ_PROPERTY){
            if (!THIS->name[THIS->index].id)
                  GB.ReturnNewString(NULL,0); 
            else
                  GB.ReturnNewString(THIS->name[THIS->index].id,0);
                  
            return ;
      }
      GB.StoreString(PROP(GB_STRING), &id_);
      
      THIS->name[THIS->index].id = strdup(id_);
      #ifdef CORBA_DEBUG            
            cout << "id = " << id_<< endl; 
      #endif
      GB.FreeString(&id_);
      
END_METHOD
BEGIN_PROPERTY(CCORBA_COSNAMING_kind)
      char* kind_=0;
      
      if (READ_PROPERTY){
            if (!THIS->name[THIS->index].kind)
                  GB.ReturnNewString(NULL,0); 
            else
                  GB.ReturnNewString(THIS->name[THIS->index].kind,0);
                  
            return ;
      }
      
      GB.StoreString(PROP(GB_STRING), &kind_);
      THIS->name[THIS->index].kind = strdup(kind_);
      #ifdef CORBA_DEBUG            
            cout << "kind = " << kind_<< endl; 
      #endif
      GB.FreeString(&kind_);
      
      
END_METHOD

BEGIN_METHOD(CCORBA_COSNAMING_get, GB_INTEGER index)

      long index = VARG(index);

      THIS->index = index;
      RETURN_SELF();

END_METHOD

GB_DESC CCORBACosNamingNameDesc[] =
{
      GB_DECLARE(".CosNamingName",0), GB_VIRTUAL_CLASS(),

      GB_PROPERTY("id",   "s", CCORBA_COSNAMING_id),
      GB_PROPERTY("kind", "s", CCORBA_COSNAMING_kind),

      GB_END_DECLARE
};
GB_DESC CCORBACosNamingNamesDesc[] =
{
        GB_DECLARE("CORBACosNamingName", sizeof(CCORBA_COSNAMING)),
      
        GB_METHOD("_free", NULL, CCORBA_COSNAMING_free, NULL),
      
        //~ GB_PROPERTY("id", "s", CCORBA_COSNAMING_id),
        //~ GB_PROPERTY("kind", "s", CCORBA_COSNAMING_kind),
      
            GB_METHOD("_get", ".CosNamingName", CCORBA_COSNAMING_get, "(Index)i"),
            GB_PROPERTY("length", "i", CCORBA_COSNAMING_length),
      //GB_METHOD("_put", NULL, CCORBA_COSNAMING_put, "(id)s(kind)s"),
      //GB_METHOD("length", NULL, CCORBA_COSNAMING_length, "(length)i"),

  GB_END_DECLARE
};

#undef THIS
#define THIS ((CCORBA_APPLICATION *)_object)

/*!
      CORBAApplication
      E' possibile creare un oggetto CORBAClient attraverso lo IOR del server CORBA di 
      cui si vogliono richiedere i servizi.
      E' Possibile creare un oggetto CORBAClient attraverso un URI dell'oggetto remoto o del NameServer
      
      GAMBAS2 Sample
      Statis Sub main()
            Dim CorbaApp as CORBAApplication
            Dim IOR as string
            Dim URI as string

            IOR = "IOR:00945405945045945094509...."
            CorbaApp = new CORBAApplication(IOR)
            
            'or you can crete a new object by URI like this
            URI = "corbaloc:iiop:localhost:10435/Nameservice"
            CorbaApp = new CORBAApplication(IOR)
            
      end sub
*/
BEGIN_METHOD_VOID(CCORBA_APPLICATION_new)
END_METHOD

BEGIN_METHOD(CCORBA_APPLICATION_InitIOR,GB_STRING IOR)
      
      int   argc        = 1;
      char  **argv      = 0;
      char* sIOR_;
      CCORBA_OBJECT *_obj = 0;      
      
      sIOR_= GB.ToZeroString(ARG(IOR));
      if (strlen(sIOR_) == 0){
            GB.Error("IOR must be not zero lenght!");
            return;
      }     

      //strcpy(THIS->IOR,sIOR_); 
      argv = (char**)malloc(sizeof(char*)*(1)); 
      argv[0] = strdup("omniORB4");

      try {
            THIS->orb = CORBA::ORB_init(argc, argv, "omniORB4");
            
            if( CORBA::is_nil(THIS->orb) ) 
                  GB.Error("ORB not initialized!");

                  
/*      THIS->obj_var_ = THIS->orb->string_to_object(sIOR_);
            if( CORBA::is_nil(THIS->obj_var_) ) 
                  GB.Error("Remote CORBA OBJECT not initialized!");*/
            
            GB.New((void **)&_obj, GB.FindClass("CORBAObject"), NULL, NULL);
            _obj->obj_var_ = THIS->orb->string_to_object(sIOR_);

            free(argv[0]);
            free(argv); 

            GB.ReturnObject(_obj);

  }
  catch(CORBA::COMM_FAILURE& ex) {
      GB.Error("Caught system exception COMM_FAILURE -- unable to contact the object.");
   cerr << "Caught system exception COMM_FAILURE -- unable to contact the object." << endl;
  }
  catch(CORBA::SystemException&) {
      GB.Error("Caught a CORBA::SystemException.");
      cerr << "Caught a CORBA::SystemException." << endl;
  }
  catch(CORBA::Exception&) {
      GB.Error("Caught CORBA::Exception.");
    cerr << "Caught CORBA::Exception." << endl;
  }
  catch(omniORB::fatalException& fe) {
      GB.Error("Caught omniORB::fatalException:");     
      cerr << "Caught omniORB::fatalException:" << endl;
/*     cerr << "  file: " << fe.file() << endl;
     cerr << "  line: " << fe.line() << endl;
     cerr << "  mesg: " << fe.errmsg() << endl;*/
  }
  catch(...) {
      GB.Error("Caught unknown exception.");
    cerr << "Caught unknown exception." << endl;
  }

      
      
      //GB.ReturnBoolean(true);
END_METHOD
BEGIN_METHOD(CCORBA_APPLICATION_InitURI,GB_OBJECT CosNamingName;GB_STRING NameServiceURI)
      
      int   argc        = 3;
      char  **argv      = 0;

      //char* URI_;
      //char* CorbaServerName_;
      CCORBA_OBJECT *_obj = 0;
      CCORBA_COSNAMING *CosNaming_ = 0;   
      
      THIS->URI = GB.ToZeroString(ARG(NameServiceURI));

    argv = (char**)malloc(sizeof(char*)*(3));   
      argv[0] = strdup("omniORB4");
      argv[1] = strdup("-ORBInitRef");
      //argv[2] = strdup("NameService=corbaloc:iiop:stargate:10435/NameService");
      argv[2] = THIS->URI;    


      CosNaming_ = (CCORBA_COSNAMING*) VARG(CosNamingName);

      if (strlen(THIS->URI) == 0){
            GB.Error("NameServiceURI must be not zero lenght!");
            return;
      }     
      
// cout << "riga 3" << endl;
//    strcpy(THIS->CorbaServerName,CorbaServerName_); 
// cout << "riga 4" << endl;
//    strcpy(THIS->URI,URI_); 
// cout << "riga 5" << endl;

      try {
            THIS->orb = CORBA::ORB_init(argc, argv);
            if( CORBA::is_nil(THIS->orb) ) 
                  GB.Error("ORB not initialized!");

            GB.New((void **)&_obj, GB.FindClass("CORBAObject"), NULL, NULL);
            _obj->obj_var_ = getObjectReference(THIS->orb,CosNaming_);
            #ifdef CORBA_DEBUG            
            cout << "Dopo il getObject..."<< endl;
            #endif

//          free(argv[2]);
//          free(argv[1]);
//          free(argv[0]);
//          free(argv); 

            GB.ReturnObject(_obj);
}
  catch(CORBA::COMM_FAILURE& ex) {
      GB.Error("Caught system exception COMM_FAILURE -- unable to contact the object.");
   cerr << "Caught system exception COMM_FAILURE -- unable to contact the object." << endl;
  }
  catch(CORBA::SystemException&) {
      GB.Error("Caught a CORBA::SystemException.");
      cerr << "Caught a CORBA::SystemException." << endl;
  }
  catch(CORBA::Exception&) {
      GB.Error("Caught CORBA::Exception.");
    cerr << "Caught CORBA::Exception." << endl;
  }
  catch(omniORB::fatalException& fe) {
      GB.Error("Caught omniORB::fatalException:");     
      cerr << "Caught omniORB::fatalException:" << endl;
  }
  catch(...) {
      GB.Error("Caught unknown exception.");
    cerr << "Caught unknown exception." << endl;
  }

/*cout << "prima della liberazione della memoria" << endl;

      free(argv[2]);
      free(argv[1]);
      free(argv[0]);
      free(argv); 
cout << "dopo della liberazione della memoria" << endl;*/
END_METHOD

BEGIN_METHOD_VOID(CCORBA_APPLICATION_free)
      //THIS->orb must not nil
      THIS->orb->destroy();
END_METHOD
BEGIN_METHOD_VOID(CCORBA_APPLICATION_exit)
      
END_METHOD
BEGIN_METHOD(CCORBA_APPLICATION_unknown, GB_VALUE param[0])

      //GB_VALUE *arg;
//    //int i;
      int n;
      //int retType;
      GB_VALUE *args;

      n = GB.NParam();
      args = ARG(param[0]);

//    for (i = 1; i < n; i++)
//    {
//          arg = &args[i];   
//          printf("i= %d  Type= %d\n",i,arg->type);  
//    }
//    return ;

      if (GB.IsProperty())
      {
      
/*          if (call_method(THIS, NULL, GB.GetUnknown(), NULL, 0, false))
                  get_object(THIS, GB.GetUnknown());
 */   
            //Return type
//          arg = &args[0];
//          retType = ((GB_INTEGER *)arg)->value;
//          
//          if (callIdl(retType, GB.GetUnknown(), ARG(param[0]), GB.NParam()))
//                cout << "Tutto bene" << endl;
//          else
//                cout << "Errore" << endl;
//          
            //call_method(THIS, THIS->object, GB.GetUnknown(), ARG(param[0]), GB.NParam(), true);
            //GB.FreeString(&THIS->object);

      }
      else
      {
      
            //Return type
            if (callIdlMethod(THIS->obj_var_,GB.GetUnknown(), ARG(param[0]), GB.NParam())){
            #ifdef CORBA_DEBUG                  
            cout << "Tutto bene" << endl;
                  #endif
            }
            else{
                  #ifdef CORBA_DEBUG            
                  cout << "Errore" << endl;
                  #endif
            }
            
            //call_method(THIS, THIS->object, GB.GetUnknown(), ARG(param[0]), GB.NParam(), true);
            //GB.FreeString(&THIS->object);
  }

END_METHOD


      
GB_DESC CCORBAApplicationDesc[] = 
{
      GB_DECLARE("CORBAApplication",sizeof(CCORBA_APPLICATION)),
      GB_METHOD("_new",NULL,CCORBA_APPLICATION_new,NULL),   
      GB_METHOD("_free", NULL, CCORBA_APPLICATION_free, NULL),

      GB_CONSTANT("CorbaStringSequence", "i", 30),
      GB_CONSTANT("CorbaObjectSequence", "i", 31),
      GB_CONSTANT("CorbaObject", "i", 16),
      GB_CONSTANT("CorbaFloat", "i", 7),
      GB_CONSTANT("CorbaDouble", "i", 8),
      GB_CONSTANT("CorbaString", "i", 10),
      GB_CONSTANT("CorbaShort", "i", 3),
      GB_CONSTANT("CorbaUShort", "i", 20),

      GB_CONSTANT("CorbaInteger", "i", 4),
      GB_CONSTANT("CorbaLong", "i", 5),
      GB_CONSTANT("CorbaVoid", "i", 0),
      
      GB_STATIC_METHOD("_exit", NULL, CCORBA_APPLICATION_exit, NULL),
      GB_METHOD("_unknown", "v", CCORBA_APPLICATION_unknown, "."),

      //GB_METHOD("InitIOR", "b", CCORBA_APPLICATION_InitIOR, "(IOR)s"),
      GB_METHOD("InitIOR", "CORBAObject", CCORBA_APPLICATION_InitIOR, "(IOR)s"),
      GB_METHOD("InitURI", "CORBAObject", CCORBA_APPLICATION_InitURI, "(CosNamingName)CORBACosNamingName;(NameServiceURI)s"),
      
      GB_END_DECLARE
};

#undef THIS
#define THIS ((CCORBA_OBJECT *)_object)

BEGIN_METHOD_VOID(CCORBA_OBJECT_free)

END_METHOD

BEGIN_PROPERTY(CCORBA_OBJECT_IOR)
      GB.ReturnNewZeroString(THIS->IOR);
END_PROPERTY
BEGIN_METHOD(CCORBA_OBJECT_unknown, GB_VALUE param[0])

  callIdlMethod(THIS->obj_var_, GB.GetUnknown(), ARG(param[0]), GB.NParam());

END_METHOD

GB_DESC CCORBAObjectDesc[] =
{
  GB_DECLARE("CORBAObject", sizeof(CCORBA_OBJECT)), GB_NOT_CREATABLE(),

  GB_METHOD("_free", NULL, CCORBA_OBJECT_free, NULL),
  GB_METHOD("_unknown", "v", CCORBA_OBJECT_unknown, "."),

  GB_PROPERTY_READ("IOR", "s", CCORBA_OBJECT_IOR),
  GB_END_DECLARE
};

Generated by  Doxygen 1.6.0   Back to index