src/runtime/Test/echo_clt.cxx

   1 //  Copyright (C) 2006-2008  CEA/DEN, EDF R&D
   2 //
   3 //  This library is free software; you can redistribute it and/or
   4 //  modify it under the terms of the GNU Lesser General Public
   5 //  License as published by the Free Software Foundation; either
   6 //  version 2.1 of the License.
   7 //
   8 //  This library is distributed in the hope that it will be useful,
   9 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 //  Lesser General Public License for more details.
  12 //
  13 //  You should have received a copy of the GNU Lesser General Public
  14 //  License along with this library; if not, write to the Free Software
  15 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 //#define REFCNT
  20 //
  21 #ifdef REFCNT
  22 #define private public
  23 #define protected public
  24 #include <omniORB4/CORBA.h>
  25 #include <omniORB4/internal/typecode.h>
  26 #endif
  27
  28 #include <echo.hh>
  29 #include <iostream>
  30 #include <vector>
  31 #include <map>
  32
  33 //#define _DEVDEBUG_
  34 #include "YacsTrace.hxx"
  35
  36 int main(int argc, char** argv)
  37 {
  38   try
  39     {
  40       CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
  41       CORBA::Object_var obj = orb->string_to_object("corbaname:rir:#test.my_context/Echo.Object");
  42       eo::Echo_var echoref = eo::Echo::_narrow(obj);
  43       if( CORBA::is_nil(echoref) )
  44         {
  45           std::cerr << "Can't narrow reference to type Echo (or it was nil)." << std::endl;
  46           return 1;
  47         }
  48
  49       CORBA::String_var src = (const char*) "Hello!";
  50       CORBA::String_var dest = echoref->echoString(src);
  51       std::cerr << "I said, \"" << (char*)src << "\"." << std::endl
  52        << "The Echo object replied, \"" << (char*)dest <<"\"." << std::endl;
  53
  54       CORBA::Object_var ob = orb->string_to_object("corbaname:rir:#test.my_context/D.Object");
  55       eo::D_var Dref = eo::D::_narrow(ob);
  56       if( CORBA::is_nil(Dref) ) {
  57         std::cerr << "Can't narrow reference to type D (or it was nil)." << std::endl;
  58         return 1;
  59         }
  60       Dref->echoLong2(10);
  61
  62       eo::D_var dout;
  63       echoref->echoD(Dref,dout);
  64       std::cerr << dout->echoLong2(10) << std::endl;
  65
  66       eo::D_var ddout;
  67       echoref->echoD(dout,ddout);
  68       std::cerr << dout->echoLong2(10) << std::endl;
  69
  70       CORBA::Object_var oob = orb->string_to_object("corbaname:rir:#test.my_context/Obj.Object");
  71       eo::Obj_var Objref = eo::Obj::_narrow(oob);
  72       Objref->echoLong(10);
  73       eo::Obj_var Objout;
  74       echoref->echoObj2(Objref,Objout);
  75       std::cerr << Objout->echoLong(10) << std::endl;
  76
  77       CORBA::Object_var cob = orb->string_to_object("corbaname:rir:#test.my_context/C.Object");
  78       eo::C_var Cref = eo::C::_narrow(cob);
  79       eo::C_var Cout;
  80       echoref->echoC(Cref,Cout);
  81
  82       echoref->echoObj2(Cref,Objout);
  83       //echoref->echoC(Cref,Objout); compilation impossible
  84       //echoref->echoObj2(Cref,Cout);  compilation impossible
  85       //echoref->echoC(Objref,Cout); compilation impossible
  86
  87       CORBA::Object_var dobj = orb->resolve_initial_references("DynAnyFactory");
  88       DynamicAny::DynAnyFactory_var dynFactory = DynamicAny::DynAnyFactory::_narrow(dobj);
  89
  90       CORBA::TypeCode_var content_type=orb->create_interface_tc("IDL:eo/Obj:1.0","Obj");
  91
  92       std::vector<CORBA::Any*> v;
  93       std::vector<CORBA::Any*>::const_iterator iter;
  94
  95       CORBA::Any *any = new CORBA::Any();
  96       *any <<= cob;
  97       v.push_back(any);
  98       /*
  99       */
 100       CORBA::Any *any2 = new CORBA::Any();
 101       *any2 <<= oob;
 102       v.push_back(any2);
 103 #ifdef REFCNT
 104       std::cerr << "refcount: " << oob->_PR_getobj()->pd_refCount << std::endl;
 105 #endif
 106
 107       CORBA::Any *any3 = new CORBA::Any();
 108       *any3 <<= oob;
 109       v.push_back(any3);
 110 #ifdef REFCNT
 111       std::cerr << "refcount: " << oob->_PR_getobj()->pd_refCount << std::endl;
 112 #endif
 113
 114       eo::Obj_ptr xobj;
 115       *any2 >>= xobj;
 116 #ifdef REFCNT
 117       std::cerr << "refcount: " << xobj->_PR_getobj()->pd_refCount << std::endl;
 118 #endif
 119       eo::Obj_ptr yobj;
 120       *any2 >>= yobj;
 121 #ifdef REFCNT
 122       std::cerr << "refcount: " << yobj->_PR_getobj()->pd_refCount << std::endl;
 123 #endif
 124
 125       CORBA::Object_var zobj ;
 126       *any2 >>= CORBA::Any::to_object(zobj) ;
 127 #ifdef REFCNT
 128       std::cerr << "refcount: " << zobj->_PR_getobj()->pd_refCount << std::endl;
 129 #endif
 130
 131       // Build an Any from vector v
 132       int homog=1;
 133       CORBA::TypeCode_var tc;
 134
 135       if(v.size() != 0)
 136         {
 137           // Check if it's an homogeneous vector : all TypeCodes must be equivalent
 138           CORBA::TypeCode_var any_tc=v[0]->type();
 139           tc=orb->create_sequence_tc(0,any_tc);
 140
 141           for(iter=v.begin();iter!=v.end();iter++)
 142             {
 143               CORBA::Any* a=*iter;
 144               CORBA::TypeCode_var tc2=a->type();
 145               if(!tc2->equivalent(any_tc))
 146                 {
 147                   // It's a non homogeneous vector : create a sequence of any
 148                   tc=orb->create_sequence_tc(0,CORBA::_tc_any);
 149                   homog=0;
 150                   break;
 151                 }
 152             }
 153           // It's a homogeneous vector : create a sequence of the homogeneous type
 154         }
 155       else
 156         {
 157           // It's an empty vector : create a sequence of any
 158           tc=orb->create_sequence_tc(0,CORBA::_tc_any);
 159           homog=0;
 160         }
 161
 162       DynamicAny::DynAny_var dynany = dynFactory->create_dyn_any_from_type_code(tc);
 163       DynamicAny::DynSequence_var ds = DynamicAny::DynSequence::_narrow(dynany);
 164
 165       ds->set_length(v.size());
 166       for(iter=v.begin();iter!=v.end();iter++)
 167         {
 168           DynamicAny::DynAny_var temp=ds->current_component();
 169           CORBA::Any* a=*iter;
 170           if(homog)
 171             temp->from_any(*a);
 172           else
 173             ds->insert_any(*a);
 174           //delete intermediate any
 175           delete a;
 176           ds->next();
 177         }
 178       CORBA::Any_var seqany=ds->to_any();
 179       ds->destroy();
 180
 181       //DynStruct from map
 182       std::map<std::string,CORBA::Any*> m;
 183       CORBA::Any *any4 = new CORBA::Any();
 184       *any4 <<= oob;
 185       //*any4 <<= cob;
 186       m["ob"]=any4;
 187       CORBA::Any *any5 = new CORBA::Any();
 188       *any5 <<= 1.0;
 189       m["x"]=any5;
 190       CORBA::Any *any6 = new CORBA::Any();
 191       *any6 <<= (long)1;
 192       m["y"]=any6;
 193       CORBA::Any *any7 = new CORBA::Any();
 194       *any7 <<= (const char*)"coucou";
 195       m["s"]=any7;
 196       CORBA::Any *any8 = new CORBA::Any();
 197       *any8 <<= CORBA::Any::from_boolean(1);
 198       m["b"]=any8;
 199
 200 /*
 201   struct S3
 202   {
 203     double x;
 204     long y;
 205     string s;
 206     boolean b;
 207     Obj ob;
 208   };
 209 */
 210
 211       int nMember=5;
 212       CORBA::StructMemberSeq mseq;
 213       mseq.length(nMember);
 214       mseq[0].name=CORBA::string_dup("x");
 215       mseq[0].type=CORBA::TypeCode::_duplicate(CORBA::_tc_double);
 216       mseq[1].name=CORBA::string_dup("y");
 217       mseq[1].type=CORBA::TypeCode::_duplicate(CORBA::_tc_long);
 218       mseq[2].name=CORBA::string_dup("s");
 219       mseq[2].type=CORBA::TypeCode::_duplicate(CORBA::_tc_string);
 220       mseq[3].name=CORBA::string_dup("b");
 221       mseq[3].type=CORBA::TypeCode::_duplicate(CORBA::_tc_boolean);
 222       mseq[4].name=CORBA::string_dup("ob");
 223       mseq[4].type=content_type;
 224       for(int i=0;i<nMember;i++)
 225         {
 226           const char* name=mseq[i].name;
 227           std::cerr << mseq[i].name << std::endl;
 228           if(m.count(name) !=0)
 229             {
 230               std::cerr << "member: " << mseq[i].name << std::endl;
 231               mseq[i].type=m[name]->type();
 232             }
 233         }
 234       CORBA::TypeCode_var ts= orb->create_struct_tc("","",mseq);
 235       //CORBA::TypeCode_var ts= orb->create_struct_tc("IDL:eo/S3:1.0","S3",mseq);
 236       dynany = dynFactory->create_dyn_any_from_type_code(ts);
 237       DynamicAny::DynStruct_var dst = DynamicAny::DynStruct::_narrow(dynany);
 238
 239       for(int i=0;i<nMember;i++)
 240         {
 241           DynamicAny::DynAny_var temp=dst->current_component();
 242           const char* name=mseq[i].name;
 243           std::cerr << name << std::endl;
 244           CORBA::Any* a=m[name];
 245           temp->from_any(*a);
 246           //delete intermediate any
 247           delete a;
 248           dst->next();
 249         }
 250       CORBA::Any_var structany=dst->to_any();
 251       dst->destroy();
 252
 253       /*
 254       for(int i=0;i<nMember;i++)
 255         {
 256               const char * name=tst->memberName(i);
 257               //TypeCode* tm=tst->memberType(i);
 258               //do not test member presence : test has been done in ToYacs convertor
 259               CORBA::Any* a=m[name];
 260               members[i].id=CORBA::string_dup(name);
 261               members[i].value=*a;
 262               //delete intermediate any
 263               delete a;
 264          }
 265          */
 266
 267
 268       //DII invoke
 269       CORBA::TypeCode_var tcout=orb->create_sequence_tc(0,content_type);
 270
 271       CORBA::Request_var req = echoref->_request("echoStruct2");
 272       //CORBA::Request_var req = echoref->_request("echoObjectVec");
 273       CORBA::NVList_ptr arguments = req->arguments() ;
 274
 275       arguments->add_value( "s1" , structany , CORBA::ARG_IN ) ;
 276       //arguments->add_value( "s1" , seqany , CORBA::ARG_IN ) ;
 277
 278       CORBA::Any out;
 279       out.replace(ts, (void*) 0);
 280       //out.replace(tcout, (void*) 0);
 281       arguments->add_value( "s2" , out , CORBA::ARG_OUT );
 282
 283       req->set_return_type(CORBA::_tc_void);
 284       //user exceptions
 285       //req->exceptions()->add(eo::_tc_SALOME_Exception);
 286
 287       req->invoke();
 288       CORBA::Exception *exc =req->env()->exception();
 289       if( exc )
 290         {
 291           std::cerr << "The raised exception is of Type:" << exc->_name() << std::endl;
 292           if(strcmp(exc->_name(),"MARSHAL") == 0)
 293             {
 294               const char* ms = ((CORBA::MARSHAL*)exc)->NP_minorString();
 295               if (ms)
 296                 std::cerr << "(CORBA::MARSHAL: minor = " << ms << ")" << std::endl;
 297             }
 298         }
 299
 300       //DII on echoObj2
 301       std::cerr << "Before request" << std::endl;
 302       req = echoref->_request("echoObj2");
 303       std::cerr << "After request" << std::endl;
 304       req->add_in_arg() <<= Objref;
 305       std::cerr << "After add_in_arg" << std::endl;
 306       req->add_out_arg() <<= Objout;
 307       std::cerr << "After add_out_arg" << std::endl;
 308       req->set_return_type(CORBA::_tc_void);
 309       std::cerr << "After set_return_type" << std::endl;
 310       req->invoke();
 311       std::cerr << "After invoke" << std::endl;
 312       exc =req->env()->exception();
 313       if( exc )
 314         {
 315           std::cerr << "The raised exception is of Type:" << exc->_name() << std::endl;
 316         }
 317       //end of DII on echoObj2
 318
 319       //DII on echoObjVec
 320       req = echoref->_request("echoObjVec");
 321       CORBA::Any *aAny = new CORBA::Any();
 322       *aAny <<= oob;
 323
 324       CORBA::TypeCode_var any_tc2=aAny->type();
 325       CORBA::TypeCode_var tc2=orb->create_sequence_tc(0,any_tc2);
 326       DynamicAny::DynAny_var dynany2 = dynFactory->create_dyn_any_from_type_code(tc2);
 327       DynamicAny::DynSequence_var ds2 = DynamicAny::DynSequence::_narrow(dynany2);
 328       ds2->set_length(2);
 329       DynamicAny::DynAny_var temp=ds2->current_component();
 330       temp->from_any(*aAny);
 331       ds2->next();
 332       temp=ds2->current_component();
 333       CORBA::Any *aAny2 = new CORBA::Any();
 334       *aAny2 <<= cob;
 335       CORBA::Object_var zzobj ;
 336       *aAny2 >>= CORBA::Any::to_object(zzobj) ;
 337       temp->insert_reference(zzobj);
 338       ds2->next();
 339
 340       CORBA::Any_var seqany2=ds2->to_any();
 341       ds2->destroy();
 342
 343       arguments = req->arguments() ;
 344       arguments->add_value( "s1" , seqany2 , CORBA::ARG_IN ) ;
 345
 346       CORBA::Any out2;
 347       out2.replace(tc2, (void*) 0);
 348       arguments->add_value( "s2" , out2 , CORBA::ARG_OUT );
 349       req->set_return_type(CORBA::_tc_void);
 350       req->invoke();
 351
 352       CORBA::Exception *exc2 =req->env()->exception();
 353       if( exc2 )
 354         {
 355           std::cerr << "The raised exception is of Type:" << exc2->_name() << std::endl;
 356           if(strcmp(exc2->_name(),"MARSHAL") == 0)
 357             {
 358               const char* ms = ((CORBA::MARSHAL*)exc2)->NP_minorString();
 359               if (ms)
 360                 std::cerr << "(CORBA::MARSHAL: minor = " << ms << ")" << std::endl;
 361             }
 362         }
 363       else
 364         {
 365           CORBA::Any *ob=arguments->item(1)->value();
 366           DynamicAny::DynAny_var dynany= dynFactory->create_dyn_any(*ob);
 367           DynamicAny::DynSequence_ptr ds=DynamicAny::DynSequence::_narrow(dynany);
 368           DynamicAny::AnySeq_var as=ds->get_elements();
 369           int length=as->length();
 370           DEBTRACE(length);
 371           for(int i=0;i<length; i++)
 372             {
 373               CORBA::TypeCode_var t=as[i].type();
 374               DEBTRACE(t->id());
 375               eo::Obj_ptr xobj;
 376               as[i] >>= xobj;
 377               DEBTRACE(xobj->_PD_repoId);
 378               xobj->echoLong(12);
 379             };
 380         }
 381
 382       //end of DII on echoObjVec
 383
 384       // Delete allocated objects to remove memory leaks (valgrind tests)
 385
 386       orb->destroy();
 387     }
 388   catch(DynamicAny::DynAny::TypeMismatch& ex)
 389     {
 390       std::cerr << "Caught a DynamicAny::DynAny::TypeMismatch exception" << std::endl;
 391     }
 392   catch(DynamicAny::DynAny::InvalidValue& ex)
 393     {
 394       std::cerr << "Caught a DynamicAny::DynAny::InvalidValue exception" << std::endl;
 395     }
 396   catch(CORBA::COMM_FAILURE& ex)
 397     {
 398       std::cerr << "Caught system exception COMM_FAILURE -- unable to contact the object." << std::endl;
 399     }
 400   catch(CORBA::SystemException&)
 401     {
 402       std::cerr << "Caught a CORBA::SystemException." << std::endl;
 403     }
 404   catch(CORBA::Exception&)
 405     {
 406       std::cerr << "Caught CORBA::Exception." << std::endl;
 407     }
 408   catch(omniORB::fatalException& fe)
 409     {
 410       std::cerr << "Caught omniORB::fatalException:" << std::endl;
 411       std::cerr << "  file: " << fe.file() << std::endl;
 412       std::cerr << "  line: " << fe.line() << std::endl;
 413       std::cerr << "  mesg: " << fe.errmsg() << std::endl;
 414     }
 415   catch(...)
 416     {
 417       std::cerr << "Caught unknown exception." << std::endl;
 418     }
 419   return 0;
 420 }