orte/libjorte/JORTEDomainEvents.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <jni.h>
   4 #include "orte.h"
   5 #include "jorte/4all.h"
   6 #include "jorte/jorte_typedefs_defines.h"
   7 #include "jorte/jorte_protos_api.h"
   8
   9 // /////////////////////////////////////////////////////////////////////
  10 //  public void onRegFail()
  11 // /////////////////////////////////////////////////////////////////////
  12 Boolean
  13 onRegFail(void *param)
  14 {
  15 // ///////////////////////////////// SPOLECNA CAST //
  16   JavaVM          *jvm = NULL;
  17   JNIEnv          *env = NULL; // local reference
  18   jclass           cls;
  19   jmethodID        mid;
  20   //
  21   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
  22   int flag_ok = 0;
  23
  24   #ifdef TEST_STAGE
  25       printf(":c: event func. 'onRegFail()' called.. \n");
  26   #endif
  27
  28   do
  29   {
  30 // ///////////////////////////////// SPOLECNA CAST //
  31     if(domain_events_cont->jvm == 0)
  32     {
  33      #ifdef TEST_STAGE
  34        printf(":!c: jvm = NULL! \n");
  35      #endif
  36      break;
  37     }
  38     jvm = domain_events_cont->jvm;
  39     // get env
  40     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
  41     if(env == 0)
  42     {
  43      #ifdef TEST_STAGE
  44        printf(":!c: env = NULL! \n");
  45      #endif
  46      break;
  47     }
  48     // find class
  49     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
  50     if(cls == 0)
  51     {
  52      #ifdef TEST_STAGE
  53        printf(":!c: cls = NULL! \n");
  54      #endif
  55      break;
  56     }
  57 // ///////////////////////////////// SPOLECNA CAST //
  58     // get method ID
  59     mid = (*env)->GetMethodID(env,
  60                               cls,
  61                               "onRegFail",
  62                               "()V");
  63     if(mid == 0)
  64     {
  65      #ifdef TEST_STAGE
  66        printf(":!c: mid = NULL! \n");
  67      #endif
  68      break;
  69     }
  70     // call method
  71     (*env)->CallVoidMethod(env,
  72                            domain_events_cont->obj_de,
  73                            mid);
  74     flag_ok = 1;
  75   } while(0);
  76   // while broken
  77   if(flag_ok)
  78   {
  79     if((*jvm)->DetachCurrentThread(jvm) != 0)
  80     {
  81       printf(":c!: DetachCurrentThread fault! \n");
  82       return  ORTE_FALSE;
  83     }
  84   }
  85
  86   return ORTE_TRUE;
  87 }
  88
  89
  90 // /////////////////////////////////////////////////////////////////////
  91 //  Event - public void onMgrNew()
  92 // /////////////////////////////////////////////////////////////////////
  93 Boolean
  94 onMgrNew(const struct ORTEAppInfo *appInfo, void *param)
  95 {
  96 // ///////////////////////////////// SPOLECNA CAST //
  97   JavaVM          *jvm = NULL;
  98   JNIEnv          *env = NULL; // local reference
  99   jclass           cls;
 100   jobject          obj_ainfo;
 101   jmethodID        mid;
 102   //
 103   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 104   int flag_ok = 0;
 105
 106   #ifdef TEST_STAGE
 107       printf(":c: event func. 'onMgrNew()' called.. \n");
 108   #endif
 109
 110   do
 111   {
 112 // ///////////////////////////////// SPOLECNA CAST //
 113     if(domain_events_cont->jvm == 0)
 114     {
 115      #ifdef TEST_STAGE
 116        printf(":!c: jvm = NULL! \n");
 117      #endif
 118      break;
 119     }
 120     jvm = domain_events_cont->jvm;
 121     // get env
 122     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 123     if(env == 0)
 124     {
 125      #ifdef TEST_STAGE
 126        printf(":!c: env = NULL! \n");
 127      #endif
 128      break;
 129     }
 130     // find class
 131     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 132     if(cls == 0)
 133     {
 134      #ifdef TEST_STAGE
 135        printf(":!c: cls = NULL! \n");
 136      #endif
 137      break;
 138     }
 139     // create AppInfo instance
 140     obj_ainfo = createAppInfo(env, appInfo);
 141     if(obj_ainfo == 0)
 142     {
 143      #ifdef TEST_STAGE
 144        printf(":!c: obj_ainfo = NULL! \n");
 145      #endif
 146      break;
 147     }
 148 // ///////////////////////////////// SPOLECNA CAST //
 149     // get method ID
 150     mid = (*env)->GetMethodID(env,
 151                               cls,
 152                               "onMgrNew",
 153                               "(Lorg/ocera/orte/types/AppInfo;)V");
 154     if(mid == 0)
 155     {
 156      #ifdef TEST_STAGE
 157        printf(":!c: mid = NULL! \n");
 158      #endif
 159      break;
 160     }
 161     // call method
 162     (*env)->CallVoidMethod(env,
 163                            domain_events_cont->obj_de,
 164                            mid,
 165                            obj_ainfo);
 166     flag_ok = 1;
 167   } while(0);
 168   // while broken
 169   if(flag_ok)
 170   {
 171     if((*jvm)->DetachCurrentThread(jvm) != 0)
 172     {
 173       printf(":c!: DetachCurrentThread fault! \n");
 174       return  ORTE_FALSE;
 175     }
 176   }
 177
 178   return ORTE_TRUE;
 179 }
 180
 181
 182 // /////////////////////////////////////////////////////////////////////
 183 //  Event - public void onMgrDelete()
 184 // /////////////////////////////////////////////////////////////////////
 185 Boolean
 186 onMgrDelete(const struct ORTEAppInfo *appInfo, void *param)
 187 {
 188 // ///////////////////////////////// SPOLECNA CAST //
 189   JavaVM          *jvm = NULL;
 190   JNIEnv          *env = NULL; // local reference
 191   jclass           cls;
 192   jobject          obj_ainfo;
 193   jmethodID        mid;
 194   //
 195   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 196   int flag_ok = 0;
 197
 198   #ifdef TEST_STAGE
 199       printf(":c: event func. 'onMgrDelete()' called.. \n");
 200   #endif
 201
 202   do
 203   {
 204 // ///////////////////////////////// SPOLECNA CAST //
 205     if(domain_events_cont->jvm == 0)
 206     {
 207      #ifdef TEST_STAGE
 208        printf(":!c: jvm = NULL! \n");
 209      #endif
 210      break;
 211     }
 212     jvm = domain_events_cont->jvm;
 213     // get env
 214     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 215     if(env == 0)
 216     {
 217      #ifdef TEST_STAGE
 218        printf(":!c: env = NULL! \n");
 219      #endif
 220      break;
 221     }
 222     // find class
 223     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 224     if(cls == 0)
 225     {
 226      #ifdef TEST_STAGE
 227        printf(":!c: cls = NULL! \n");
 228      #endif
 229      break;
 230     }
 231     // create AppInfo instance
 232     obj_ainfo = createAppInfo(env, appInfo);
 233     if(obj_ainfo == 0)
 234     {
 235      #ifdef TEST_STAGE
 236        printf(":!c: obj_ainfo = NULL! \n");
 237      #endif
 238      break;
 239     }
 240 // ///////////////////////////////// SPOLECNA CAST //
 241     // get method ID
 242     mid = (*env)->GetMethodID(env,
 243                               cls,
 244                               "onMgrDelete",
 245                               "(Lorg/ocera/orte/types/AppInfo;)V");
 246     if(mid == 0)
 247     {
 248      #ifdef TEST_STAGE
 249        printf(":!c: mid = NULL! \n");
 250      #endif
 251      break;
 252     }
 253     // call method
 254     (*env)->CallVoidMethod(env,
 255                            domain_events_cont->obj_de,
 256                            mid,
 257                            obj_ainfo);
 258     flag_ok = 1;
 259   } while(0);
 260   // while broken
 261   if(flag_ok)
 262   {
 263     if((*jvm)->DetachCurrentThread(jvm) != 0)
 264     {
 265       printf(":c!: DetachCurrentThread fault! \n");
 266       return  ORTE_FALSE;
 267     }
 268   }
 269
 270   return ORTE_TRUE;
 271 }
 272
 273
 274
 275 // /////////////////////////////////////////////////////////////////////
 276 //  Event - onAppRemoteNew
 277 // /////////////////////////////////////////////////////////////////////
 278 Boolean
 279 onAppRemoteNew(const struct ORTEAppInfo *appInfo, void *param)
 280 {
 281 // ///////////////////////////////// SPOLECNA CAST //
 282   JavaVM          *jvm = NULL;
 283   JNIEnv          *env = NULL; // local reference
 284   jclass           cls;
 285   jobject          obj_ainfo;
 286   jmethodID        mid;
 287   //
 288   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 289   int flag_ok = 0;
 290
 291   #ifdef TEST_STAGE
 292       printf(":c: event func. 'onAppRemoteNew()' called.. \n");
 293   #endif
 294
 295   do
 296   {
 297 // ///////////////////////////////// SPOLECNA CAST //
 298     if(domain_events_cont->jvm == 0)
 299     {
 300      #ifdef TEST_STAGE
 301        printf(":!c: jvm = NULL! \n");
 302      #endif
 303      break;
 304     }
 305     jvm = domain_events_cont->jvm;
 306     // get env
 307     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 308     if(env == 0)
 309     {
 310      #ifdef TEST_STAGE
 311        printf(":!c: env = NULL! \n");
 312      #endif
 313      break;
 314     }
 315     // find class
 316     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 317     if(cls == 0)
 318     {
 319      #ifdef TEST_STAGE
 320        printf(":!c: cls = NULL! \n");
 321      #endif
 322      break;
 323     }
 324     // create AppInfo instance
 325     obj_ainfo = createAppInfo(env, appInfo);
 326     if(obj_ainfo == 0)
 327     {
 328      #ifdef TEST_STAGE
 329        printf(":!c: obj_ainfo = NULL! \n");
 330      #endif
 331      break;
 332     }
 333 // ///////////////////////////////// SPOLECNA CAST //
 334
 335     // get method ID
 336     mid = (*env)->GetMethodID(env,
 337                               cls,
 338                               "onAppRemoteNew",
 339                               "(Lorg/ocera/orte/types/AppInfo;)V");
 340     if(mid == 0)
 341     {
 342      #ifdef TEST_STAGE
 343        printf(":!c: mid = NULL! \n");
 344      #endif
 345      break;
 346     }
 347     // call method
 348     (*env)->CallVoidMethod(env,
 349                            domain_events_cont->obj_de,
 350                            mid,
 351                            obj_ainfo);
 352     flag_ok = 1;
 353   } while(0);
 354   // while broken
 355   if(flag_ok)
 356   {
 357     if((*jvm)->DetachCurrentThread(jvm) != 0)
 358     {
 359       printf(":c!: DetachCurrentThread fault! \n");
 360       return  ORTE_FALSE;
 361     }
 362   }
 363
 364   return ORTE_TRUE;
 365 }
 366
 367
 368 // /////////////////////////////////////////////////////////////////////
 369 //  public void onAppDelete() { }
 370 // /////////////////////////////////////////////////////////////////////
 371 Boolean
 372 onAppDelete(const struct ORTEAppInfo *appInfo, void *param)
 373 {
 374 // ///////////////////////////////// SPOLECNA CAST //
 375   JavaVM          *jvm = NULL;
 376   JNIEnv          *env = NULL; // local reference
 377   jclass           cls;
 378   jobject          obj_ainfo;
 379   jmethodID        mid;
 380   //
 381   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 382   int flag_ok = 0;
 383
 384   #ifdef TEST_STAGE
 385       printf(":c: event func. 'onAppDelete()' called.. \n");
 386   #endif
 387
 388   do
 389   {
 390 // ///////////////////////////////// SPOLECNA CAST //
 391     if(domain_events_cont->jvm == 0)
 392     {
 393      #ifdef TEST_STAGE
 394        printf(":!c: jvm = NULL! \n");
 395      #endif
 396      break;
 397     }
 398     jvm = domain_events_cont->jvm;
 399     // get env
 400     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 401     if(env == 0)
 402     {
 403      #ifdef TEST_STAGE
 404        printf(":!c: env = NULL! \n");
 405      #endif
 406      break;
 407     }
 408     // find class
 409     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 410     if(cls == 0)
 411     {
 412      #ifdef TEST_STAGE
 413        printf(":!c: cls = NULL! \n");
 414      #endif
 415      break;
 416     }
 417     // create AppInfo instance
 418     obj_ainfo = createAppInfo(env, appInfo);
 419     if(obj_ainfo == 0)
 420     {
 421      #ifdef TEST_STAGE
 422        printf(":!c: obj_ainfo = NULL! \n");
 423      #endif
 424      break;
 425     }
 426 // ///////////////////////////////// SPOLECNA CAST //
 427     // get method ID
 428     mid = (*env)->GetMethodID(env,
 429                               cls,
 430                               "onAppDelete",
 431                               "(Lorg/ocera/orte/types/AppInfo;)V");
 432     if(mid == 0)
 433     {
 434      #ifdef TEST_STAGE
 435        printf(":!c: mid = NULL! \n");
 436      #endif
 437      break;
 438     }
 439     // call method
 440     (*env)->CallVoidMethod(env,
 441                            domain_events_cont->obj_de,
 442                            mid,
 443                            obj_ainfo);
 444     flag_ok = 1;
 445   } while(0);
 446   // while broken
 447   if(flag_ok)
 448   {
 449     if((*jvm)->DetachCurrentThread(jvm) != 0)
 450     {
 451       printf(":c!: DetachCurrentThread fault! \n");
 452       return  ORTE_FALSE;
 453     }
 454   }
 455
 456   return ORTE_TRUE;
 457 }
 458
 459
 460 // /////////////////////////////////////////////////////////////////////
 461 //  public void onPubRemoteNew()
 462 // /////////////////////////////////////////////////////////////////////
 463 Boolean
 464 onPubRemoteNew(const struct ORTEAppInfo *appInfo,
 465                const struct ORTEPubInfo *pubInfo,
 466                void *param)
 467 {
 468 // ///////////////////////////////// SPOLECNA CAST //
 469   JavaVM          *jvm = NULL;
 470   JNIEnv          *env = NULL; // local reference
 471   jclass           cls;
 472   jobject          obj_ainfo;
 473   jobject          obj_pinfo;
 474   jmethodID        mid;
 475   //
 476   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 477   int flag_ok = 0;
 478
 479   #ifdef TEST_STAGE
 480       printf(":c: event func. 'onPubRemoteNew()' called.. \n");
 481   #endif
 482
 483   do
 484   {
 485 // ///////////////////////////////// SPOLECNA CAST //
 486     if(domain_events_cont->jvm == 0)
 487     {
 488      #ifdef TEST_STAGE
 489        printf(":!c: jvm = NULL! \n");
 490      #endif
 491      break;
 492     }
 493     jvm = domain_events_cont->jvm;
 494     // get env
 495     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 496     if(env == 0)
 497     {
 498      #ifdef TEST_STAGE
 499        printf(":!c: env = NULL! \n");
 500      #endif
 501      break;
 502     }
 503     // find class
 504     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 505     if(cls == 0)
 506     {
 507      #ifdef TEST_STAGE
 508        printf(":!c: cls = NULL! \n");
 509      #endif
 510      break;
 511     }
 512     // create AppInfo instance
 513     obj_ainfo = createAppInfo(env, appInfo);
 514     if(obj_ainfo == 0)
 515     {
 516      #ifdef TEST_STAGE
 517        printf(":!c: obj_ainfo = NULL! \n");
 518      #endif
 519      break;
 520     }
 521     // create PubInfo instance
 522     obj_pinfo = createPubInfo(env, pubInfo);
 523     if(obj_pinfo == 0)
 524     {
 525      #ifdef TEST_STAGE
 526        printf(":!c: obj_pinfo = NULL! \n");
 527      #endif
 528      break;
 529     }
 530 // ///////////////////////////////// SPOLECNA CAST //
 531     // get method ID
 532     mid = (*env)->GetMethodID(env,
 533                               cls,
 534                               "onPubRemoteNew",
 535                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 536     if(mid == 0)
 537     {
 538      #ifdef TEST_STAGE
 539        printf(":!c: mid = NULL! \n");
 540      #endif
 541      break;
 542     }
 543     // call method
 544     (*env)->CallVoidMethod(env,
 545                            domain_events_cont->obj_de,
 546                            mid,
 547                            obj_ainfo,
 548                            obj_pinfo);
 549     flag_ok = 1;
 550   } while(0);
 551   // while broken
 552   if(flag_ok)
 553   {
 554     if((*jvm)->DetachCurrentThread(jvm) != 0)
 555     {
 556       printf(":c!: DetachCurrentThread fault! \n");
 557       return  ORTE_FALSE;
 558     }
 559   }
 560
 561   return ORTE_TRUE;
 562 }
 563
 564
 565 // /////////////////////////////////////////////////////////////////////
 566 //public void onPubRemoteChanged()
 567 // /////////////////////////////////////////////////////////////////////
 568 Boolean
 569 onPubRemoteChanged(const struct ORTEAppInfo *appInfo,
 570                    const struct ORTEPubInfo *pubInfo,
 571                    void *param)
 572 {
 573 // ///////////////////////////////// SPOLECNA CAST //
 574   JavaVM          *jvm = NULL;
 575   JNIEnv          *env = NULL; // local reference
 576   jclass           cls;
 577   jobject          obj_ainfo;
 578   jobject          obj_pinfo;
 579   jmethodID        mid;
 580   //
 581   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 582   int flag_ok = 0;
 583
 584   #ifdef TEST_STAGE
 585       printf(":c: event func. 'onPubRemoteChanged()' called.. \n");
 586   #endif
 587
 588   do
 589   {
 590 // ///////////////////////////////// SPOLECNA CAST //
 591     if(domain_events_cont->jvm == 0)
 592     {
 593      #ifdef TEST_STAGE
 594        printf(":!c: jvm = NULL! \n");
 595      #endif
 596      break;
 597     }
 598     jvm = domain_events_cont->jvm;
 599     // get env
 600     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 601     if(env == 0)
 602     {
 603      #ifdef TEST_STAGE
 604        printf(":!c: env = NULL! \n");
 605      #endif
 606      break;
 607     }
 608     // find class
 609     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 610     if(cls == 0)
 611     {
 612      #ifdef TEST_STAGE
 613        printf(":!c: cls = NULL! \n");
 614      #endif
 615      break;
 616     }
 617     // create AppInfo instance
 618     obj_ainfo = createAppInfo(env, appInfo);
 619     if(obj_ainfo == 0)
 620     {
 621      #ifdef TEST_STAGE
 622        printf(":!c: obj_ainfo = NULL! \n");
 623      #endif
 624      break;
 625     }
 626     // create PubInfo instance
 627     obj_pinfo = createPubInfo(env, pubInfo);
 628     if(obj_pinfo == 0)
 629     {
 630      #ifdef TEST_STAGE
 631        printf(":!c: obj_pinfo = NULL! \n");
 632      #endif
 633      break;
 634     }
 635 // ///////////////////////////////// SPOLECNA CAST //
 636     // get method ID
 637     mid = (*env)->GetMethodID(env,
 638                               cls,
 639                               "onPubRemoteChanged",
 640                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 641     if(mid == 0)
 642     {
 643      #ifdef TEST_STAGE
 644        printf(":!c: mid = NULL! \n");
 645      #endif
 646      break;
 647     }
 648     // call method
 649     (*env)->CallVoidMethod(env,
 650                            domain_events_cont->obj_de,
 651                            mid,
 652                            obj_ainfo,
 653                            obj_pinfo);
 654     flag_ok = 1;
 655   } while(0);
 656   // while broken
 657   if(flag_ok)
 658   {
 659     if((*jvm)->DetachCurrentThread(jvm) != 0)
 660     {
 661       printf(":c!: DetachCurrentThread fault! \n");
 662       return  ORTE_FALSE;
 663     }
 664   }
 665
 666   return ORTE_TRUE;
 667 }
 668
 669
 670
 671
 672 // /////////////////////////////////////////////////////////////////////
 673 //  public void onPubDelete()
 674 // /////////////////////////////////////////////////////////////////////
 675 Boolean
 676 onPubDelete(const struct ORTEAppInfo *appInfo,
 677             const struct ORTEPubInfo *pubInfo,
 678             void *param)
 679 {
 680 // ///////////////////////////////// SPOLECNA CAST //
 681   JavaVM          *jvm = NULL;
 682   JNIEnv          *env = NULL; // local reference
 683   jclass           cls;
 684   jobject          obj_ainfo;
 685   jobject          obj_pinfo;
 686   jmethodID        mid;
 687   //
 688   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 689   int flag_ok = 0;
 690
 691   #ifdef TEST_STAGE
 692       printf(":c: event func. 'onPubDelete()' called.. \n");
 693   #endif
 694
 695   do
 696   {
 697 // ///////////////////////////////// SPOLECNA CAST //
 698     if(domain_events_cont->jvm == 0)
 699     {
 700      #ifdef TEST_STAGE
 701        printf(":!c: jvm = NULL! \n");
 702      #endif
 703      break;
 704     }
 705     jvm = domain_events_cont->jvm;
 706     // get env
 707     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 708     if(env == 0)
 709     {
 710      #ifdef TEST_STAGE
 711        printf(":!c: env = NULL! \n");
 712      #endif
 713      break;
 714     }
 715     // find class
 716     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 717     if(cls == 0)
 718     {
 719      #ifdef TEST_STAGE
 720        printf(":!c: cls = NULL! \n");
 721      #endif
 722      break;
 723     }
 724     // create AppInfo instance
 725     obj_ainfo = createAppInfo(env, appInfo);
 726     if(obj_ainfo == 0)
 727     {
 728      #ifdef TEST_STAGE
 729        printf(":!c: obj_ainfo = NULL! \n");
 730      #endif
 731      break;
 732     }
 733     // create PubInfo instance
 734     obj_pinfo = createPubInfo(env, pubInfo);
 735     if(obj_pinfo == 0)
 736     {
 737      #ifdef TEST_STAGE
 738        printf(":!c: obj_pinfo = NULL! \n");
 739      #endif
 740      break;
 741     }
 742 // ///////////////////////////////// SPOLECNA CAST //
 743     // get method ID
 744     mid = (*env)->GetMethodID(env,
 745                               cls,
 746                               "onPubDelete",
 747                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/PubInfo;)V");
 748     if(mid == 0)
 749     {
 750      #ifdef TEST_STAGE
 751        printf(":!c: mid = NULL! \n");
 752      #endif
 753      break;
 754     }
 755     // call method
 756     (*env)->CallVoidMethod(env,
 757                            domain_events_cont->obj_de,
 758                            mid,
 759                            obj_ainfo,
 760                            obj_pinfo);
 761     flag_ok = 1;
 762   } while(0);
 763   // while broken
 764   if(flag_ok)
 765   {
 766     if((*jvm)->DetachCurrentThread(jvm) != 0)
 767     {
 768       printf(":c!: DetachCurrentThread fault! \n");
 769       return  ORTE_FALSE;
 770     }
 771   }
 772
 773   return ORTE_TRUE;
 774 }
 775
 776
 777 // /////////////////////////////////////////////////////////////////////
 778 //  Event - onSubRemoteNew
 779 // /////////////////////////////////////////////////////////////////////
 780 Boolean
 781 onSubRemoteNew(const struct ORTEAppInfo *appInfo,
 782                const struct ORTESubInfo *subInfo,
 783                void *param)
 784 {
 785 // ///////////////////////////////// SPOLECNA CAST //
 786   JavaVM          *jvm = NULL;
 787   JNIEnv          *env = NULL; // local reference
 788   jobject          obj_ainfo;
 789   jobject          obj_sinfo;
 790   jclass           cls;
 791   jmethodID        mid;
 792   //
 793   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 794   int flag_ok = 0;
 795
 796   #ifdef TEST_STAGE
 797       printf(":c: event func. 'onSubRemoteNew()' called.. \n");
 798   #endif
 799
 800   do
 801   {
 802 // ///////////////////////////////// SPOLECNA CAST //
 803     if(domain_events_cont->jvm == 0)
 804     {
 805      #ifdef TEST_STAGE
 806        printf(":!c: jvm = NULL! \n");
 807      #endif
 808      break;
 809     }
 810     jvm = domain_events_cont->jvm;
 811     // get env
 812     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 813     if(env == 0)
 814     {
 815      #ifdef TEST_STAGE
 816        printf(":!c: env = NULL! \n");
 817      #endif
 818      break;
 819     }
 820     // find class
 821     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 822     if(cls == 0)
 823     {
 824      #ifdef TEST_STAGE
 825        printf(":!c: cls = NULL! \n");
 826      #endif
 827      break;
 828     }
 829     // create AppInfo instance
 830     obj_ainfo = createAppInfo(env, appInfo);
 831     if(obj_ainfo == 0)
 832     {
 833      #ifdef TEST_STAGE
 834        printf(":!c: obj_ainfo = NULL! \n");
 835      #endif
 836      break;
 837     }
 838     // create SubInfo instance
 839     obj_sinfo = createSubInfo(env, subInfo);
 840     if(obj_sinfo == 0)
 841     {
 842      #ifdef TEST_STAGE
 843        printf(":!c: obj_sinfo = NULL! \n");
 844      #endif
 845      break;
 846     }
 847 // ///////////////////////////////// SPOLECNA CAST //
 848     // get method ID
 849     mid = (*env)->GetMethodID(env,
 850                               cls,
 851                               "onSubRemoteNew",
 852                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
 853     if(mid == 0)
 854     {
 855      #ifdef TEST_STAGE
 856        printf(":!c: mid = NULL! \n");
 857      #endif
 858      break;
 859     }
 860     // call method
 861     (*env)->CallVoidMethod(env,
 862                            domain_events_cont->obj_de,
 863                            mid,
 864                            obj_ainfo,
 865                            obj_sinfo);
 866     flag_ok = 1;
 867   } while(0);
 868   // while broken
 869   if(flag_ok)
 870   {
 871     if((*jvm)->DetachCurrentThread(jvm) != 0)
 872     {
 873       printf(":c!: DetachCurrentThread fault! \n");
 874       return  ORTE_FALSE;
 875     }
 876   }
 877
 878   return ORTE_TRUE;
 879 }
 880
 881
 882 // /////////////////////////////////////////////////////////////////////
 883 //  public void onSubRemoteChanged() { }
 884 // /////////////////////////////////////////////////////////////////////
 885 Boolean
 886 onSubRemoteChanged(const struct ORTEAppInfo *appInfo,
 887                    const struct ORTESubInfo *subInfo,
 888                    void *param)
 889 {
 890 // ///////////////////////////////// SPOLECNA CAST //
 891   JavaVM          *jvm = NULL;
 892   JNIEnv          *env = NULL; // local reference
 893   jclass           cls;
 894   jobject          obj_ainfo;
 895   jobject          obj_sinfo;
 896   jmethodID        mid;
 897   //
 898   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
 899   int flag_ok = 0;
 900
 901   #ifdef TEST_STAGE
 902       printf(":c: event func. 'onSubRemoteChanged()' called.. \n");
 903   #endif
 904
 905   do
 906   {
 907 // ///////////////////////////////// SPOLECNA CAST //
 908     if(domain_events_cont->jvm == 0)
 909     {
 910      #ifdef TEST_STAGE
 911        printf(":!c: jvm = NULL! \n");
 912      #endif
 913      break;
 914     }
 915     jvm = domain_events_cont->jvm;
 916     // get env
 917     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
 918     if(env == 0)
 919     {
 920      #ifdef TEST_STAGE
 921        printf(":!c: env = NULL! \n");
 922      #endif
 923      break;
 924     }
 925     // find class
 926     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
 927     if(cls == 0)
 928     {
 929      #ifdef TEST_STAGE
 930        printf(":!c: cls = NULL! \n");
 931      #endif
 932      break;
 933     }
 934     // create AppInfo instance
 935     obj_ainfo = createAppInfo(env, appInfo);
 936     if(obj_ainfo == 0)
 937     {
 938      #ifdef TEST_STAGE
 939        printf(":!c: obj_ainfo = NULL! \n");
 940      #endif
 941      break;
 942     }
 943     // create SubInfo instance
 944     obj_sinfo = createSubInfo(env, subInfo);
 945     if(obj_sinfo == 0)
 946     {
 947      #ifdef TEST_STAGE
 948        printf(":!c: obj_sinfo = NULL! \n");
 949      #endif
 950      break;
 951     }
 952 // ///////////////////////////////// SPOLECNA CAST //
 953     // get method ID
 954     mid = (*env)->GetMethodID(env,
 955                               cls,
 956                               "onSubRemoteChanged",
 957                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
 958     if(mid == 0)
 959     {
 960      #ifdef TEST_STAGE
 961        printf(":!c: mid = NULL! \n");
 962      #endif
 963      break;
 964     }
 965     // call method
 966     (*env)->CallVoidMethod(env,
 967                            domain_events_cont->obj_de,
 968                            mid,
 969                            obj_ainfo,
 970                            obj_sinfo);
 971     flag_ok = 1;
 972   } while(0);
 973   // while broken
 974   if(flag_ok)
 975   {
 976     if((*jvm)->DetachCurrentThread(jvm) != 0)
 977     {
 978       printf(":c!: DetachCurrentThread fault! \n");
 979       return  ORTE_FALSE;
 980     }
 981   }
 982
 983   return ORTE_TRUE;
 984 }
 985
 986
 987 // /////////////////////////////////////////////////////////////////////
 988 //  public void onSubDelete() { }
 989 // /////////////////////////////////////////////////////////////////////
 990 Boolean
 991 onSubDelete(const struct ORTEAppInfo *appInfo,
 992             const struct ORTESubInfo *subInfo,
 993             void *param)
 994 {
 995 // ///////////////////////////////// SPOLECNA CAST //
 996   JavaVM          *jvm = NULL;
 997   JNIEnv          *env = NULL; // local reference
 998   jclass           cls;
 999   jobject          obj_ainfo;
1000   jobject          obj_sinfo;
1001   jmethodID        mid;
1002   //
1003   JORTEDomainEventsContext_t   *domain_events_cont = (JORTEDomainEventsContext_t*) param;
1004   int flag_ok = 0;
1005
1006   #ifdef TEST_STAGE
1007       printf(":c: event func. 'onSubDelete()' called.. \n");
1008   #endif
1009
1010   do
1011   {
1012 // ///////////////////////////////// SPOLECNA CAST //
1013     if(domain_events_cont->jvm == 0)
1014     {
1015      #ifdef TEST_STAGE
1016        printf(":!c: jvm = NULL! \n");
1017      #endif
1018      break;
1019     }
1020     jvm = domain_events_cont->jvm;
1021     // get env
1022     (*jvm)->AttachCurrentThread(jvm, (void **)&env, NULL);
1023     if(env == 0)
1024     {
1025      #ifdef TEST_STAGE
1026        printf(":!c: env = NULL! \n");
1027      #endif
1028      break;
1029     }
1030     // find class
1031     cls = findClass(env, "org.ocera.orte.types.DomainEvents");
1032     if(cls == 0)
1033     {
1034      #ifdef TEST_STAGE
1035        printf(":!c: cls = NULL! \n");
1036      #endif
1037      break;
1038     }
1039     // create AppInfo instance
1040     obj_ainfo = createAppInfo(env, appInfo);
1041     if(obj_ainfo == 0)
1042     {
1043      #ifdef TEST_STAGE
1044        printf(":!c: obj_ainfo = NULL! \n");
1045      #endif
1046      break;
1047     }
1048     // create SubInfo instance
1049     obj_sinfo = createSubInfo(env, subInfo);
1050     if(obj_sinfo == 0)
1051     {
1052      #ifdef TEST_STAGE
1053        printf(":!c: obj_sinfo = NULL! \n");
1054      #endif
1055      break;
1056     }
1057 // ///////////////////////////////// SPOLECNA CAST //
1058     // get method ID
1059     mid = (*env)->GetMethodID(env,
1060                               cls,
1061                               "onSubDelete",
1062                               "(Lorg/ocera/orte/types/AppInfo;Lorg/ocera/orte/types/SubInfo;)V");
1063     if(mid == 0)
1064     {
1065      #ifdef TEST_STAGE
1066        printf(":!c: mid = NULL! \n");
1067      #endif
1068      break;
1069     }
1070     // call method
1071     (*env)->CallVoidMethod(env,
1072                            domain_events_cont->obj_de,
1073                            mid,
1074                            obj_ainfo,
1075                            obj_sinfo);
1076     flag_ok = 1;
1077   } while(0);
1078   // while broken
1079   if(flag_ok)
1080   {
1081     if((*jvm)->DetachCurrentThread(jvm) != 0)
1082     {
1083       printf(":c!: DetachCurrentThread fault! \n");
1084       return  ORTE_FALSE;
1085     }
1086   }
1087
1088   return ORTE_TRUE;
1089 }