src/MedCorba_Swig/libMedCorba_Swig.i

   1 %module libMedCorba_Swig
   2
   3 %include "libMEDMEM_Swig.i"
   4
   5 %{
   6 #include "convert.hxx"
   7 #include "Family_i.hxx"
   8 #include "FieldDouble_i.hxx"
   9 #include "Field_i.hxx"
  10 #include "FieldInt_i.hxx"
  11 #include "FieldOf_i.hxx"
  12 #include "Group_i.hxx"
  13 #include "Med_i.hxx"
  14 #include "Mesh_i.hxx"
  15 #include "Support_i.hxx"
  16 #include "MEDMEM_SWIG_FieldDouble.hxx"
  17 #include "MEDMEM_SWIG_FieldInt.hxx"
  18 %}
  19
  20 /*
  21   typemap in and out for Corba Objects (MESH, FIELDDOUBLE, FIELDINT and
  22   Support) between C++ and Python
  23
  24   WARNING (NB) to the user of those typmaps (SWIG wrapping for C++ routines
  25   -------------------------------------------------------------------------
  26
  27   You have to be quite careful about the SWIG version your are currently
  28   using, because CORBA pointeur _ptr or _var could be wrapped by SWIG using
  29   their reference rather than the pointeur itself (differences detected using
  30   SWIG 1.1.x, SWIG 1.3.13 and SWIG 1.3.17)
  31 */
  32
  33 %typemap(python,out) SALOME_MED::MESH_ptr, SALOME_MED::FIELDDOUBLE_ptr,
  34   SALOME_MED::FIELDINT_ptr, SALOME_MED::SUPPORT_ptr,
  35   const SALOME_MED::MESH_ptr, const SALOME_MED::FIELDDOUBLE_ptr,
  36   const SALOME_MED::FIELDINT_ptr, const SALOME_MED::SUPPORT_ptr
  37 {
  38   MESSAGE("typemap out sur Objet Corba version ptr");
  39
  40   SCRUTE($1);
  41
  42   // Get the orb corba python
  43
  44   PyObject* pdict = PyDict_New();
  45   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
  46   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
  47
  48   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
  49                    pdict, pdict);
  50
  51   PyObject* orb = PyDict_GetItemString(pdict, "o");
  52
  53   // Get the orb Corba C++
  54
  55   int argc = 0;
  56   char *xargv = "";
  57   char **argv = &xargv;
  58   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
  59
  60   string s =  ORB->object_to_string($1);
  61   SCRUTE(s);
  62   PyObject * tmp = PyString_FromString(s.c_str());
  63   SCRUTE(tmp);
  64   $result = PyObject_CallMethod(orb, "string_to_object", "O", tmp);
  65   SCRUTE($result);
  66 }
  67
  68 %typemap(python,out) SALOME_MED::MESH_var, SALOME_MED::FIELDDOUBLE_var,
  69   SALOME_MED::FIELDINT_var, SALOME_MED::SUPPORT_var,
  70   const SALOME_MED::MESH_var, const SALOME_MED::FIELDDOUBLE_var,
  71   const SALOME_MED::FIELDINT_var, const SALOME_MED::SUPPORT_var
  72 {
  73   MESSAGE("typemap out sur Objet Corba version var");
  74
  75   // Get the orb corba python
  76
  77   PyObject* pdict = PyDict_New();
  78   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
  79   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
  80
  81   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
  82                    pdict, pdict);
  83
  84   PyObject* orb = PyDict_GetItemString(pdict, "o");
  85
  86   // Get the orb Corba C++
  87
  88   int argc = 0;
  89   char *xargv = "";
  90   char **argv = &xargv;
  91   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
  92
  93   string s =  ORB->object_to_string(*$1);
  94   SCRUTE(s);
  95   PyObject * tmp = PyString_FromString(s.c_str());
  96   SCRUTE(tmp);
  97   $result = PyObject_CallMethod(orb, "string_to_object", "O", tmp);
  98   SCRUTE($result);
  99 }
 100
 101 %typemap(python,in) const SALOME_MED::MESH_ptr &, SALOME_MED::MESH_ptr &
 102 {
 103
 104   MESSAGE("typemap in sur Objet Corba MESH avec reference");
 105
 106   PyObject* pdict = PyDict_New();
 107   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 108   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 109
 110   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 111                    pdict, pdict);
 112
 113   PyObject* orb = PyDict_GetItemString(pdict, "o");
 114
 115   // Ask omniORBpy to transform MESH (python Corba) ptr to IOR string
 116
 117   PyObject* iorMesh
 118     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 119
 120   if (iorMesh == Py_None)
 121     return NULL;
 122   char * s = PyString_AsString(PyObject_Str(iorMesh));
 123
 124   // Ask omniORB to convert IOR string to MESH (C++ Corba) ptr
 125
 126   int argc = 0;
 127   char *xargv = "";
 128   char **argv = &xargv;
 129   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 130   CORBA::Object_var O =  ORB->string_to_object(s);
 131   SCRUTE(O);
 132   SALOME_MED::MESH_ptr t = SALOME_MED::MESH::_narrow(O);
 133
 134   $1 = &t;
 135   SCRUTE(*$1);
 136 }
 137
 138 %typemap(python,in) const SALOME_MED::FIELDDOUBLE_ptr &,
 139                     SALOME_MED::FIELDDOUBLE_ptr &
 140 {
 141
 142   MESSAGE("typemap in sur Objet Corba FIELDDOUBLE avec reference");
 143
 144   PyObject* pdict = PyDict_New();
 145   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 146   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 147
 148   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 149                    pdict, pdict);
 150
 151   PyObject* orb = PyDict_GetItemString(pdict, "o");
 152
 153   // Ask omniORBpy to transform FIELDDOUBLE (python Corba) ptr to IOR string
 154
 155   PyObject* iorFieldDouble
 156     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 157
 158   if (iorFieldDouble == Py_None)
 159     return NULL;
 160   char * s = PyString_AsString(PyObject_Str(iorFieldDouble));
 161
 162   // Ask omniORB to convert IOR string to FIELDDOUBLE (C++ Corba) ptr
 163
 164   int argc = 0;
 165   char *xargv = "";
 166   char **argv = &xargv;
 167   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 168   CORBA::Object_var O =  ORB->string_to_object(s);
 169   SCRUTE(O);
 170   SALOME_MED::FIELDDOUBLE_ptr t = SALOME_MED::FIELDDOUBLE::_narrow(O);
 171
 172   $1 = &t;
 173   SCRUTE(*$1);
 174 }
 175
 176 %typemap(python,in) const SALOME_MED::FIELDINT_ptr &,
 177                     SALOME_MED::FIELDINT_ptr &
 178 {
 179
 180   MESSAGE("typemap in sur Objet Corba FIELDINT avec reference");
 181
 182   PyObject* pdict = PyDict_New();
 183   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 184   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 185
 186   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 187                    pdict, pdict);
 188
 189   PyObject* orb = PyDict_GetItemString(pdict, "o");
 190
 191   // Ask omniORBpy to transform FIELDINT (python Corba) ptr to IOR string
 192
 193   PyObject* iorFieldInt
 194     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 195
 196   if (iorFieldInt == Py_None)
 197     return NULL;
 198   char * s = PyString_AsString(PyObject_Str(iorFieldInt));
 199
 200   // Ask omniORB to convert IOR string to FIELDINT (C++ Corba) ptr
 201
 202   int argc = 0;
 203   char *xargv = "";
 204   char **argv = &xargv;
 205   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 206   CORBA::Object_var O =  ORB->string_to_object(s);
 207   SCRUTE(O);
 208   SALOME_MED::FIELDINT_ptr t = SALOME_MED::FIELDINT::_narrow(O);
 209
 210   $1 = &t;
 211   SCRUTE(*$1);
 212 }
 213
 214 %typemap(python,in) const SALOME_MED::SUPPORT_ptr &, SALOME_MED::SUPPORT_ptr &
 215 {
 216
 217   MESSAGE("typemap in sur Objet Corba SUPPORT avec reference");
 218
 219   PyObject* pdict = PyDict_New();
 220   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 221   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 222
 223   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 224                    pdict, pdict);
 225
 226   PyObject* orb = PyDict_GetItemString(pdict, "o");
 227
 228   // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 229
 230   PyObject* iorSupport
 231     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 232
 233   if (iorSupport == Py_None)
 234     return NULL;
 235   char * s = PyString_AsString(PyObject_Str(iorSupport));
 236
 237   // Ask omniORB to convert IOR string to SUPPORT (C++ Corba) ptr
 238
 239   int argc = 0;
 240   char *xargv = "";
 241   char **argv = &xargv;
 242   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 243   CORBA::Object_var O =  ORB->string_to_object(s);
 244   SCRUTE(O);
 245   SALOME_MED::SUPPORT_ptr t = SALOME_MED::SUPPORT::_narrow(O);
 246
 247   $1 = &t;
 248   SCRUTE(*$1);
 249 }
 250
 251 %typemap(python,in) const SALOME_MED::SUPPORT_ptr, SALOME_MED::SUPPORT_ptr
 252 {
 253
 254   MESSAGE("typemap in sur Objet Corba SUPPORT sans reference");
 255
 256   SCRUTE($input);
 257
 258   PyObject* pdict = PyDict_New();
 259   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 260   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 261
 262   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 263                    pdict, pdict);
 264
 265   PyObject* orb = PyDict_GetItemString(pdict, "o");
 266
 267   // Ask omniORBpy to transform SUPPORT (python Corba) ptr to IOR string
 268
 269   PyObject* iorSupport
 270     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 271
 272   if (iorSupport == Py_None)
 273     return NULL;
 274   char * s = PyString_AsString(PyObject_Str(iorSupport));
 275
 276   // Ask omniORB to convert IOR string to SUPPORT (C++ Corba) ptr
 277
 278   int argc = 0;
 279   char *xargv = "";
 280   char **argv = &xargv;
 281   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 282   CORBA::Object_var O =  ORB->string_to_object(s);
 283   SCRUTE(O);
 284   SALOME_MED::SUPPORT_ptr t = SALOME_MED::SUPPORT::_narrow(O);
 285
 286   $1 = t;
 287   SCRUTE($1);
 288 }
 289
 290 %typemap(python,in) const SALOME_MED::MESH_ptr, SALOME_MED::MESH_ptr
 291 {
 292
 293   MESSAGE("typemap in sur Objet Corba MESH sans reference");
 294
 295   SCRUTE($input);
 296
 297   PyObject* pdict = PyDict_New();
 298   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 299   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 300
 301   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 302                    pdict, pdict);
 303
 304   PyObject* orb = PyDict_GetItemString(pdict, "o");
 305
 306   // Ask omniORBpy to transform MESH (python Corba) ptr to IOR string
 307
 308   PyObject* iorMesh
 309     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 310
 311   if (iorMesh == Py_None)
 312     return NULL;
 313   char * s = PyString_AsString(PyObject_Str(iorMesh));
 314
 315   // Ask omniORB to convert IOR string to MESH (C++ Corba) ptr
 316
 317   int argc = 0;
 318   char *xargv = "";
 319   char **argv = &xargv;
 320   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 321   CORBA::Object_var O =  ORB->string_to_object(s);
 322   SCRUTE(O);
 323   SALOME_MED::MESH_ptr t = SALOME_MED::MESH::_narrow(O);
 324
 325   $1 = t;
 326   SCRUTE($1);
 327 }
 328
 329 %typemap(python,in) const SALOME_MED::FIELDDOUBLE_ptr,
 330                     SALOME_MED::FIELDDOUBLE_ptr &
 331 {
 332
 333   MESSAGE("typemap in sur Objet Corba FIELDDOUBLE sans reference");
 334
 335   SCRUTE($input);
 336
 337   PyObject* pdict = PyDict_New();
 338   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 339   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 340
 341   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 342                    pdict, pdict);
 343
 344   PyObject* orb = PyDict_GetItemString(pdict, "o");
 345
 346   // Ask omniORBpy to transform FIELDDOUBLE (python Corba) ptr to IOR string
 347
 348   PyObject* iorFieldDouble
 349     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 350
 351   if (iorFieldDouble == Py_None)
 352     return NULL;
 353   char * s = PyString_AsString(PyObject_Str(iorFieldDouble));
 354
 355   // Ask omniORB to convert IOR string to FIELDDOUBLE (C++ Corba) ptr
 356
 357   int argc = 0;
 358   char *xargv = "";
 359   char **argv = &xargv;
 360   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 361   CORBA::Object_var O =  ORB->string_to_object(s);
 362   SCRUTE(O);
 363   SALOME_MED::FIELDDOUBLE_ptr t = SALOME_MED::FIELDDOUBLE::_narrow(O);
 364
 365   $1 = t;
 366   SCRUTE($1);
 367 }
 368
 369 %typemap(python,in) const SALOME_MED::FIELDINT_ptr,
 370                     SALOME_MED::FIELDINT_ptr
 371 {
 372
 373   MESSAGE("typemap in sur Objet Corba FIELDINT sans reference");
 374
 375   SCRUTE($input);
 376
 377   PyObject* pdict = PyDict_New();
 378   PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
 379   PyRun_String("import CORBA", Py_single_input, pdict, pdict);
 380
 381   PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input,
 382                    pdict, pdict);
 383
 384   PyObject* orb = PyDict_GetItemString(pdict, "o");
 385
 386   // Ask omniORBpy to transform FIELDINT (python Corba) ptr to IOR string
 387
 388   PyObject* iorFieldInt
 389     = PyObject_CallMethod(orb, "object_to_string", "O", $input);
 390
 391   if (iorFieldInt == Py_None)
 392     return NULL;
 393   char * s = PyString_AsString(PyObject_Str(iorFieldInt));
 394
 395   // Ask omniORB to convert IOR string to FIELDINT (C++ Corba) ptr
 396
 397   int argc = 0;
 398   char *xargv = "";
 399   char **argv = &xargv;
 400   CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv);
 401   CORBA::Object_var O =  ORB->string_to_object(s);
 402   SCRUTE(O);
 403   SALOME_MED::FIELDINT_ptr t = SALOME_MED::FIELDINT::_narrow(O);
 404
 405   $1 = t;
 406   SCRUTE($1);
 407 }
 408
 409 SALOME_MED::FIELDDOUBLE_ptr createCorbaFieldDouble(SALOME_MED::SUPPORT_ptr,
 410                                                    FIELDDOUBLE *);
 411
 412 SALOME_MED::FIELDINT_ptr createCorbaFieldInt(SALOME_MED::SUPPORT_ptr,
 413                                              FIELDINT *);
 414
 415 SALOME_MED::SUPPORT_ptr createCorbaSupport(const SUPPORT *);
 416
 417 FIELDDOUBLE * createLocalFieldDouble(const int, const int);
 418
 419 FIELDINT * createLocalFieldInt(const int, const int);
 420
 421 SALOME_MED::MESH_ptr createCorbaMesh(MESH * mesh);
 422
 423 %{
 424   SALOME_MED::FIELDDOUBLE_ptr createCorbaFieldDouble(SALOME_MED::SUPPORT_ptr mySupportIOR,FIELDDOUBLE * field)
 425     {
 426       BEGIN_OF("SALOME_MED::FIELDDOUBLE_ptr createCorbaFieldDouble from libMedCorba_Swig");
 427
 428       SCRUTE(mySupportIOR);
 429
 430       SCRUTE(field);
 431
 432       field->setName("Corba Double Field");
 433
 434       field->setDescription("Got From A Local One");
 435
 436       FIELDDOUBLE_i * fieldimpl = new FIELDDOUBLE_i(mySupportIOR,field);
 437
 438       POA_SALOME_MED::FIELDDOUBLE_tie<FIELDDOUBLE_i> * fieldcorba1 =
 439         new POA_SALOME_MED::FIELDDOUBLE_tie<FIELDDOUBLE_i>(fieldimpl,true);
 440
 441       SALOME_MED::FIELDDOUBLE_ptr fieldcorba2 = fieldcorba1->_this();
 442
 443       SALOME_MED::FIELDDOUBLE_ptr fieldcorba3 = SALOME_MED::FIELDDOUBLE::_duplicate(fieldcorba2);
 444
 445       fieldcorba1->_remove_ref();
 446
 447       SCRUTE(fieldimpl);
 448
 449       SCRUTE(fieldcorba1);
 450
 451       SCRUTE(fieldcorba2);
 452
 453       SCRUTE(fieldcorba3);
 454
 455       END_OF("SALOME_MED::FIELDDOUBLE_ptr createCorbaFieldDouble from libMedCorba_Swig");
 456
 457       MESSAGE("Test de tirarge sur le pointeur Corba Field dans le cxx");
 458
 459       char * name = fieldcorba3->getName();
 460
 461       SCRUTE(name);
 462
 463      return fieldcorba3;
 464     }
 465
 466   SALOME_MED::FIELDINT_ptr createCorbaFieldInt(SALOME_MED::SUPPORT_ptr mySupportIOR,FIELDINT * field)
 467     {
 468       BEGIN_OF("SALOME_MED::FIELDINT_ptr createCorbaFieldInt from libMedCorba_Swig");
 469
 470       SCRUTE(mySupportIOR);
 471
 472       SCRUTE(field);
 473
 474       field->setName("Corba Integer Field");
 475
 476       field->setDescription("Got From A Local One");
 477
 478       FIELDINT_i * fieldimpl = new FIELDINT_i(mySupportIOR,field);
 479
 480       POA_SALOME_MED::FIELDINT_tie<FIELDINT_i> * fieldcorba1 =
 481         new POA_SALOME_MED::FIELDINT_tie<FIELDINT_i>(fieldimpl,true);
 482
 483       SALOME_MED::FIELDINT_ptr fieldcorba2 = fieldcorba1->_this();
 484
 485       SALOME_MED::FIELDINT_ptr fieldcorba3 = SALOME_MED::FIELDINT::_duplicate(fieldcorba2);
 486
 487       fieldcorba1->_remove_ref();
 488
 489       SCRUTE(fieldimpl);
 490
 491       SCRUTE(fieldcorba1);
 492
 493       SCRUTE(fieldcorba2);
 494
 495       SCRUTE(fieldcorba3);
 496
 497       END_OF("SALOME_MED::FIELDINT_ptr createCorbaFieldInt from libMedCorba_Swig");
 498       MESSAGE("Test de tirarge sur le pointeur Corba Field dans le cxx");
 499
 500       char * name = fieldcorba3->getName();
 501
 502       SCRUTE(name);
 503
 504       return fieldcorba3;
 505     }
 506
 507   SALOME_MED::SUPPORT_ptr createCorbaSupport(const SUPPORT * const support)
 508     {
 509       BEGIN_OF("SALOME_MED::SUPPORT_ptr createCorbaSupport from libMedCorba_Swig");
 510
 511       SCRUTE(support);
 512
 513       SUPPORT_i * supportimpl = new SUPPORT_i(support);
 514
 515       SALOME_MED::SUPPORT_ptr supportcorba =
 516         supportimpl->POA_SALOME_MED::SUPPORT::_this();
 517
 518       SCRUTE(supportimpl);
 519
 520       SCRUTE(supportcorba);
 521
 522       supportimpl->_remove_ref();
 523
 524       END_OF("SALOME_MED::SUPPORT_ptr createCorbaSupport from libMedCorba_Swig");
 525
 526       return supportcorba;
 527     }
 528
 529   SALOME_MED::MESH_ptr createCorbaMesh(MESH * mesh)
 530     {
 531       BEGIN_OF("SALOME_MED::MESH_ptr createCorbaMesh from libMedCorba_Swig");
 532
 533       SCRUTE(mesh);
 534
 535       MESH_i * meshimpl = new MESH_i(mesh);
 536
 537       SALOME_MED::MESH_ptr meshcorba =
 538         meshimpl->POA_SALOME_MED::MESH::_this();
 539
 540       SCRUTE(meshimpl);
 541
 542       SCRUTE(meshcorba);
 543
 544       meshimpl->_remove_ref();
 545
 546       END_OF("SALOME_MED::MESH_ptr createCorbaMesh from libMedCorba_Swig");
 547
 548       return meshcorba;
 549     }
 550
 551   FIELDDOUBLE * createLocalFieldDouble(const int NumberOfComponents,
 552                                       const int LengthValue)
 553     {
 554       BEGIN_OF("FIELDDOUBLE createLocalFieldDouble from libMedCorba_Swig");
 555
 556       SCRUTE(NumberOfComponents);
 557       SCRUTE(LengthValue);
 558
 559       //FIELD<double> * fieldloc =  new FIELD<double>();
 560       FIELDDOUBLE * fieldloc =  new FIELDDOUBLE();
 561       fieldloc -> allocValue(NumberOfComponents,LengthValue);
 562
 563       END_OF("FIELDDOUBLE createLocalFieldDouble from libMedCorba_Swig");
 564
 565       return fieldloc;
 566     }
 567
 568   FIELDINT * createLocalFieldInt(const int NumberOfComponents,
 569                                  const int LengthValue)
 570     {
 571       BEGIN_OF("FIELDINT createLocalFieldInt from libMedCorba_Swig");
 572
 573       SCRUTE(NumberOfComponents);
 574       SCRUTE(LengthValue);
 575
 576       //FIELD<int> * fieldloc =  new FIELD<int>();
 577       FIELDINT * fieldloc =  new FIELDINT();
 578       fieldloc -> allocValue(NumberOfComponents,LengthValue);
 579
 580       END_OF("FIELDDOUBLE createLocalFieldInt from libMedCorba_Swig");
 581
 582       return fieldloc;
 583     }
 584 %}