1 // Generated code, do not modify 2 3 package run; 4 5 6 /** Skeleton class for remote class 'run.ModelCluster_instance_impl' */ 7 public final class ModelCluster_instance_impl_KSkel extends uka.karmi.rmi.RemoteSkeleton { 8 /** reference to the implementation object */ 9 run.ModelCluster_instance_impl impl; 10 11 /** Set the implementation object of this skeleton */ setRemoteObject(uka.karmi.rmi.Remote object)12 public final void setRemoteObject(uka.karmi.rmi.Remote object) { 13 this.impl = (run.ModelCluster_instance_impl) object; 14 } 15 getRemoteObject()16 protected final uka.karmi.rmi.Remote getRemoteObject() { 17 return this.impl; 18 } 19 20 /** Direct marshaling protocol: Generic invocation */ doApplicationCall(uka.karmi.rmi.ServerConnection c)21 public final void doApplicationCall(uka.karmi.rmi.ServerConnection c) 22 throws java.io.IOException, ClassNotFoundException 23 { 24 switch(c.mid) { 25 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_get_$: { 26 // unmarshal parameters 27 c.closeReceiveCall(); 28 29 int result; 30 try { 31 // call the implementation 32 result = impl.run_ModelCluster_number_of_elements_get_(); 33 } catch (Throwable ex) { 34 // marshal the server-side exception 35 c.openSendResult(false); 36 c.sendObject(ex); 37 return; 38 } 39 40 // marshal the return value 41 c.openSendResult(true); 42 c.sendSingleInt(result); 43 return; 44 } 45 46 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_set_$int: { 47 // unmarshal parameters 48 c.openReceivePrimitive(4); 49 int p0 = c.receiveInt(); 50 c.closeReceivePrimitive(4); 51 c.closeReceiveCall(); 52 53 int result; 54 try { 55 // call the implementation 56 result = impl.run_ModelCluster_number_of_elements_set_(p0); 57 } catch (Throwable ex) { 58 // marshal the server-side exception 59 c.openSendResult(false); 60 c.sendObject(ex); 61 return; 62 } 63 64 // marshal the return value 65 c.openSendResult(true); 66 c.sendSingleInt(result); 67 return; 68 } 69 70 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_elements_inc_$int$boolean: { 71 // unmarshal parameters 72 c.openReceivePrimitive(5); 73 int p0 = c.receiveInt(); 74 boolean p1 = c.receiveBoolean(); 75 c.closeReceivePrimitive(5); 76 c.closeReceiveCall(); 77 78 int result; 79 try { 80 // call the implementation 81 result = impl.run_ModelCluster_number_of_elements_inc_(p0, p1); 82 } catch (Throwable ex) { 83 // marshal the server-side exception 84 c.openSendResult(false); 85 c.sendObject(ex); 86 return; 87 } 88 89 // marshal the return value 90 c.openSendResult(true); 91 c.sendSingleInt(result); 92 return; 93 } 94 95 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_get_$: { 96 // unmarshal parameters 97 c.closeReceiveCall(); 98 99 int result; 100 try { 101 // call the implementation 102 result = impl.run_ModelCluster_number_of_trackers_get_(); 103 } catch (Throwable ex) { 104 // marshal the server-side exception 105 c.openSendResult(false); 106 c.sendObject(ex); 107 return; 108 } 109 110 // marshal the return value 111 c.openSendResult(true); 112 c.sendSingleInt(result); 113 return; 114 } 115 116 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_set_$int: { 117 // unmarshal parameters 118 c.openReceivePrimitive(4); 119 int p0 = c.receiveInt(); 120 c.closeReceivePrimitive(4); 121 c.closeReceiveCall(); 122 123 int result; 124 try { 125 // call the implementation 126 result = impl.run_ModelCluster_number_of_trackers_set_(p0); 127 } catch (Throwable ex) { 128 // marshal the server-side exception 129 c.openSendResult(false); 130 c.sendObject(ex); 131 return; 132 } 133 134 // marshal the return value 135 c.openSendResult(true); 136 c.sendSingleInt(result); 137 return; 138 } 139 140 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_trackers_inc_$int$boolean: { 141 // unmarshal parameters 142 c.openReceivePrimitive(5); 143 int p0 = c.receiveInt(); 144 boolean p1 = c.receiveBoolean(); 145 c.closeReceivePrimitive(5); 146 c.closeReceiveCall(); 147 148 int result; 149 try { 150 // call the implementation 151 result = impl.run_ModelCluster_number_of_trackers_inc_(p0, p1); 152 } catch (Throwable ex) { 153 // marshal the server-side exception 154 c.openSendResult(false); 155 c.sendObject(ex); 156 return; 157 } 158 159 // marshal the return value 160 c.openSendResult(true); 161 c.sendSingleInt(result); 162 return; 163 } 164 165 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_get_$: { 166 // unmarshal parameters 167 c.closeReceiveCall(); 168 169 int result; 170 try { 171 // call the implementation 172 result = impl.run_ModelCluster_number_of_nodes_get_(); 173 } catch (Throwable ex) { 174 // marshal the server-side exception 175 c.openSendResult(false); 176 c.sendObject(ex); 177 return; 178 } 179 180 // marshal the return value 181 c.openSendResult(true); 182 c.sendSingleInt(result); 183 return; 184 } 185 186 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_set_$int: { 187 // unmarshal parameters 188 c.openReceivePrimitive(4); 189 int p0 = c.receiveInt(); 190 c.closeReceivePrimitive(4); 191 c.closeReceiveCall(); 192 193 int result; 194 try { 195 // call the implementation 196 result = impl.run_ModelCluster_number_of_nodes_set_(p0); 197 } catch (Throwable ex) { 198 // marshal the server-side exception 199 c.openSendResult(false); 200 c.sendObject(ex); 201 return; 202 } 203 204 // marshal the return value 205 c.openSendResult(true); 206 c.sendSingleInt(result); 207 return; 208 } 209 210 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_nodes_inc_$int$boolean: { 211 // unmarshal parameters 212 c.openReceivePrimitive(5); 213 int p0 = c.receiveInt(); 214 boolean p1 = c.receiveBoolean(); 215 c.closeReceivePrimitive(5); 216 c.closeReceiveCall(); 217 218 int result; 219 try { 220 // call the implementation 221 result = impl.run_ModelCluster_number_of_nodes_inc_(p0, p1); 222 } catch (Throwable ex) { 223 // marshal the server-side exception 224 c.openSendResult(false); 225 c.sendObject(ex); 226 return; 227 } 228 229 // marshal the return value 230 c.openSendResult(true); 231 c.sendSingleInt(result); 232 return; 233 } 234 235 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_get_$: { 236 // unmarshal parameters 237 c.closeReceiveCall(); 238 239 int result; 240 try { 241 // call the implementation 242 result = impl.run_ModelCluster_number_of_materials_get_(); 243 } catch (Throwable ex) { 244 // marshal the server-side exception 245 c.openSendResult(false); 246 c.sendObject(ex); 247 return; 248 } 249 250 // marshal the return value 251 c.openSendResult(true); 252 c.sendSingleInt(result); 253 return; 254 } 255 256 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_set_$int: { 257 // unmarshal parameters 258 c.openReceivePrimitive(4); 259 int p0 = c.receiveInt(); 260 c.closeReceivePrimitive(4); 261 c.closeReceiveCall(); 262 263 int result; 264 try { 265 // call the implementation 266 result = impl.run_ModelCluster_number_of_materials_set_(p0); 267 } catch (Throwable ex) { 268 // marshal the server-side exception 269 c.openSendResult(false); 270 c.sendObject(ex); 271 return; 272 } 273 274 // marshal the return value 275 c.openSendResult(true); 276 c.sendSingleInt(result); 277 return; 278 } 279 280 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_materials_inc_$int$boolean: { 281 // unmarshal parameters 282 c.openReceivePrimitive(5); 283 int p0 = c.receiveInt(); 284 boolean p1 = c.receiveBoolean(); 285 c.closeReceivePrimitive(5); 286 c.closeReceiveCall(); 287 288 int result; 289 try { 290 // call the implementation 291 result = impl.run_ModelCluster_number_of_materials_inc_(p0, p1); 292 } catch (Throwable ex) { 293 // marshal the server-side exception 294 c.openSendResult(false); 295 c.sendObject(ex); 296 return; 297 } 298 299 // marshal the return value 300 c.openSendResult(true); 301 c.sendSingleInt(result); 302 return; 303 } 304 305 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_get_$: { 306 // unmarshal parameters 307 c.closeReceiveCall(); 308 309 int result; 310 try { 311 // call the implementation 312 result = impl.run_ModelCluster_number_of_controls_get_(); 313 } catch (Throwable ex) { 314 // marshal the server-side exception 315 c.openSendResult(false); 316 c.sendObject(ex); 317 return; 318 } 319 320 // marshal the return value 321 c.openSendResult(true); 322 c.sendSingleInt(result); 323 return; 324 } 325 326 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_set_$int: { 327 // unmarshal parameters 328 c.openReceivePrimitive(4); 329 int p0 = c.receiveInt(); 330 c.closeReceivePrimitive(4); 331 c.closeReceiveCall(); 332 333 int result; 334 try { 335 // call the implementation 336 result = impl.run_ModelCluster_number_of_controls_set_(p0); 337 } catch (Throwable ex) { 338 // marshal the server-side exception 339 c.openSendResult(false); 340 c.sendObject(ex); 341 return; 342 } 343 344 // marshal the return value 345 c.openSendResult(true); 346 c.sendSingleInt(result); 347 return; 348 } 349 350 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_controls_inc_$int$boolean: { 351 // unmarshal parameters 352 c.openReceivePrimitive(5); 353 int p0 = c.receiveInt(); 354 boolean p1 = c.receiveBoolean(); 355 c.closeReceivePrimitive(5); 356 c.closeReceiveCall(); 357 358 int result; 359 try { 360 // call the implementation 361 result = impl.run_ModelCluster_number_of_controls_inc_(p0, p1); 362 } catch (Throwable ex) { 363 // marshal the server-side exception 364 c.openSendResult(false); 365 c.sendObject(ex); 366 return; 367 } 368 369 // marshal the return value 370 c.openSendResult(true); 371 c.sendSingleInt(result); 372 return; 373 } 374 375 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_get_$: { 376 // unmarshal parameters 377 c.closeReceiveCall(); 378 379 int result; 380 try { 381 // call the implementation 382 result = impl.run_ModelCluster_number_of_constraints_get_(); 383 } catch (Throwable ex) { 384 // marshal the server-side exception 385 c.openSendResult(false); 386 c.sendObject(ex); 387 return; 388 } 389 390 // marshal the return value 391 c.openSendResult(true); 392 c.sendSingleInt(result); 393 return; 394 } 395 396 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_set_$int: { 397 // unmarshal parameters 398 c.openReceivePrimitive(4); 399 int p0 = c.receiveInt(); 400 c.closeReceivePrimitive(4); 401 c.closeReceiveCall(); 402 403 int result; 404 try { 405 // call the implementation 406 result = impl.run_ModelCluster_number_of_constraints_set_(p0); 407 } catch (Throwable ex) { 408 // marshal the server-side exception 409 c.openSendResult(false); 410 c.sendObject(ex); 411 return; 412 } 413 414 // marshal the return value 415 c.openSendResult(true); 416 c.sendSingleInt(result); 417 return; 418 } 419 420 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_constraints_inc_$int$boolean: { 421 // unmarshal parameters 422 c.openReceivePrimitive(5); 423 int p0 = c.receiveInt(); 424 boolean p1 = c.receiveBoolean(); 425 c.closeReceivePrimitive(5); 426 c.closeReceiveCall(); 427 428 int result; 429 try { 430 // call the implementation 431 result = impl.run_ModelCluster_number_of_constraints_inc_(p0, p1); 432 } catch (Throwable ex) { 433 // marshal the server-side exception 434 c.openSendResult(false); 435 c.sendObject(ex); 436 return; 437 } 438 439 // marshal the return value 440 c.openSendResult(true); 441 c.sendSingleInt(result); 442 return; 443 } 444 445 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_get_$: { 446 // unmarshal parameters 447 c.closeReceiveCall(); 448 449 int result; 450 try { 451 // call the implementation 452 result = impl.run_ModelCluster_number_of_loads_get_(); 453 } catch (Throwable ex) { 454 // marshal the server-side exception 455 c.openSendResult(false); 456 c.sendObject(ex); 457 return; 458 } 459 460 // marshal the return value 461 c.openSendResult(true); 462 c.sendSingleInt(result); 463 return; 464 } 465 466 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_set_$int: { 467 // unmarshal parameters 468 c.openReceivePrimitive(4); 469 int p0 = c.receiveInt(); 470 c.closeReceivePrimitive(4); 471 c.closeReceiveCall(); 472 473 int result; 474 try { 475 // call the implementation 476 result = impl.run_ModelCluster_number_of_loads_set_(p0); 477 } catch (Throwable ex) { 478 // marshal the server-side exception 479 c.openSendResult(false); 480 c.sendObject(ex); 481 return; 482 } 483 484 // marshal the return value 485 c.openSendResult(true); 486 c.sendSingleInt(result); 487 return; 488 } 489 490 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_number_of_loads_inc_$int$boolean: { 491 // unmarshal parameters 492 c.openReceivePrimitive(5); 493 int p0 = c.receiveInt(); 494 boolean p1 = c.receiveBoolean(); 495 c.closeReceivePrimitive(5); 496 c.closeReceiveCall(); 497 498 int result; 499 try { 500 // call the implementation 501 result = impl.run_ModelCluster_number_of_loads_inc_(p0, p1); 502 } catch (Throwable ex) { 503 // marshal the server-side exception 504 c.openSendResult(false); 505 c.sendObject(ex); 506 return; 507 } 508 509 // marshal the return value 510 c.openSendResult(true); 511 c.sendSingleInt(result); 512 return; 513 } 514 515 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_constraintlist_get_$: { 516 // unmarshal parameters 517 c.closeReceiveCall(); 518 519 run.RplVector result; 520 try { 521 // call the implementation 522 result = impl.run_ModelCluster_constraintlist_get_(); 523 } catch (Throwable ex) { 524 // marshal the server-side exception 525 c.openSendResult(false); 526 c.sendObject(ex); 527 return; 528 } 529 530 // marshal the return value 531 c.openSendResult(true); 532 c.sendObject(result); 533 return; 534 } 535 536 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_constraintlist_set_$run_RplVector: { 537 // unmarshal parameters 538 run.RplVector p0 = (run.RplVector) c.receiveObject(); 539 c.closeReceiveCall(); 540 541 run.RplVector result; 542 try { 543 // call the implementation 544 result = impl.run_ModelCluster_constraintlist_set_(p0); 545 } catch (Throwable ex) { 546 // marshal the server-side exception 547 c.openSendResult(false); 548 c.sendObject(ex); 549 return; 550 } 551 552 // marshal the return value 553 c.openSendResult(true); 554 c.sendObject(result); 555 return; 556 } 557 558 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_loadlist_get_$: { 559 // unmarshal parameters 560 c.closeReceiveCall(); 561 562 run.RplVector result; 563 try { 564 // call the implementation 565 result = impl.run_ModelCluster_loadlist_get_(); 566 } catch (Throwable ex) { 567 // marshal the server-side exception 568 c.openSendResult(false); 569 c.sendObject(ex); 570 return; 571 } 572 573 // marshal the return value 574 c.openSendResult(true); 575 c.sendObject(result); 576 return; 577 } 578 579 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_loadlist_set_$run_RplVector: { 580 // unmarshal parameters 581 run.RplVector p0 = (run.RplVector) c.receiveObject(); 582 c.closeReceiveCall(); 583 584 run.RplVector result; 585 try { 586 // call the implementation 587 result = impl.run_ModelCluster_loadlist_set_(p0); 588 } catch (Throwable ex) { 589 // marshal the server-side exception 590 c.openSendResult(false); 591 c.sendObject(ex); 592 return; 593 } 594 595 // marshal the return value 596 c.openSendResult(true); 597 c.sendObject(result); 598 return; 599 } 600 601 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodelist_get_$: { 602 // unmarshal parameters 603 c.closeReceiveCall(); 604 605 run.RplVector result; 606 try { 607 // call the implementation 608 result = impl.run_ModelCluster_nodelist_get_(); 609 } catch (Throwable ex) { 610 // marshal the server-side exception 611 c.openSendResult(false); 612 c.sendObject(ex); 613 return; 614 } 615 616 // marshal the return value 617 c.openSendResult(true); 618 c.sendObject(result); 619 return; 620 } 621 622 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodelist_set_$run_RplVector: { 623 // unmarshal parameters 624 run.RplVector p0 = (run.RplVector) c.receiveObject(); 625 c.closeReceiveCall(); 626 627 run.RplVector result; 628 try { 629 // call the implementation 630 result = impl.run_ModelCluster_nodelist_set_(p0); 631 } catch (Throwable ex) { 632 // marshal the server-side exception 633 c.openSendResult(false); 634 c.sendObject(ex); 635 return; 636 } 637 638 // marshal the return value 639 c.openSendResult(true); 640 c.sendObject(result); 641 return; 642 } 643 644 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodetable_get_$: { 645 // unmarshal parameters 646 c.closeReceiveCall(); 647 648 java.util.Hashtable result; 649 try { 650 // call the implementation 651 result = impl.run_ModelCluster_nodetable_get_(); 652 } catch (Throwable ex) { 653 // marshal the server-side exception 654 c.openSendResult(false); 655 c.sendObject(ex); 656 return; 657 } 658 659 // marshal the return value 660 c.openSendResult(true); 661 c.sendObject(result); 662 return; 663 } 664 665 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodetable_set_$java_util_Hashtable: { 666 // unmarshal parameters 667 java.util.Hashtable p0 = (java.util.Hashtable) c.receiveObject(); 668 c.closeReceiveCall(); 669 670 java.util.Hashtable result; 671 try { 672 // call the implementation 673 result = impl.run_ModelCluster_nodetable_set_(p0); 674 } catch (Throwable ex) { 675 // marshal the server-side exception 676 c.openSendResult(false); 677 c.sendObject(ex); 678 return; 679 } 680 681 // marshal the return value 682 c.openSendResult(true); 683 c.sendObject(result); 684 return; 685 } 686 687 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementlist_get_$: { 688 // unmarshal parameters 689 c.closeReceiveCall(); 690 691 run.RplVector result; 692 try { 693 // call the implementation 694 result = impl.run_ModelCluster_elementlist_get_(); 695 } catch (Throwable ex) { 696 // marshal the server-side exception 697 c.openSendResult(false); 698 c.sendObject(ex); 699 return; 700 } 701 702 // marshal the return value 703 c.openSendResult(true); 704 c.sendObject(result); 705 return; 706 } 707 708 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementlist_set_$run_RplVector: { 709 // unmarshal parameters 710 run.RplVector p0 = (run.RplVector) c.receiveObject(); 711 c.closeReceiveCall(); 712 713 run.RplVector result; 714 try { 715 // call the implementation 716 result = impl.run_ModelCluster_elementlist_set_(p0); 717 } catch (Throwable ex) { 718 // marshal the server-side exception 719 c.openSendResult(false); 720 c.sendObject(ex); 721 return; 722 } 723 724 // marshal the return value 725 c.openSendResult(true); 726 c.sendObject(result); 727 return; 728 } 729 730 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackerlist_get_$: { 731 // unmarshal parameters 732 c.closeReceiveCall(); 733 734 run.RplVector result; 735 try { 736 // call the implementation 737 result = impl.run_ModelCluster_trackerlist_get_(); 738 } catch (Throwable ex) { 739 // marshal the server-side exception 740 c.openSendResult(false); 741 c.sendObject(ex); 742 return; 743 } 744 745 // marshal the return value 746 c.openSendResult(true); 747 c.sendObject(result); 748 return; 749 } 750 751 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackerlist_set_$run_RplVector: { 752 // unmarshal parameters 753 run.RplVector p0 = (run.RplVector) c.receiveObject(); 754 c.closeReceiveCall(); 755 756 run.RplVector result; 757 try { 758 // call the implementation 759 result = impl.run_ModelCluster_trackerlist_set_(p0); 760 } catch (Throwable ex) { 761 // marshal the server-side exception 762 c.openSendResult(false); 763 c.sendObject(ex); 764 return; 765 } 766 767 // marshal the return value 768 c.openSendResult(true); 769 c.sendObject(result); 770 return; 771 } 772 773 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_materiallist_get_$: { 774 // unmarshal parameters 775 c.closeReceiveCall(); 776 777 run.RplVector result; 778 try { 779 // call the implementation 780 result = impl.run_ModelCluster_materiallist_get_(); 781 } catch (Throwable ex) { 782 // marshal the server-side exception 783 c.openSendResult(false); 784 c.sendObject(ex); 785 return; 786 } 787 788 // marshal the return value 789 c.openSendResult(true); 790 c.sendObject(result); 791 return; 792 } 793 794 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_materiallist_set_$run_RplVector: { 795 // unmarshal parameters 796 run.RplVector p0 = (run.RplVector) c.receiveObject(); 797 c.closeReceiveCall(); 798 799 run.RplVector result; 800 try { 801 // call the implementation 802 result = impl.run_ModelCluster_materiallist_set_(p0); 803 } catch (Throwable ex) { 804 // marshal the server-side exception 805 c.openSendResult(false); 806 c.sendObject(ex); 807 return; 808 } 809 810 // marshal the return value 811 c.openSendResult(true); 812 c.sendObject(result); 813 return; 814 } 815 816 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_shareddata_get_$: { 817 // unmarshal parameters 818 c.closeReceiveCall(); 819 820 run.SharedData result; 821 try { 822 // call the implementation 823 result = impl.run_ModelCluster_shareddata_get_(); 824 } catch (Throwable ex) { 825 // marshal the server-side exception 826 c.openSendResult(false); 827 c.sendObject(ex); 828 return; 829 } 830 831 // marshal the return value 832 c.openSendResult(true); 833 c.sendObject(result); 834 return; 835 } 836 837 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_shareddata_set_$run_SharedData: { 838 // unmarshal parameters 839 run.SharedData p0 = (run.SharedData) c.receiveObject(); 840 c.closeReceiveCall(); 841 842 run.SharedData result; 843 try { 844 // call the implementation 845 result = impl.run_ModelCluster_shareddata_set_(p0); 846 } catch (Throwable ex) { 847 // marshal the server-side exception 848 c.openSendResult(false); 849 c.sendObject(ex); 850 return; 851 } 852 853 // marshal the return value 854 c.openSendResult(true); 855 c.sendObject(result); 856 return; 857 } 858 859 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_get_$: { 860 // unmarshal parameters 861 c.closeReceiveCall(); 862 863 double result; 864 try { 865 // call the implementation 866 result = impl.run_ModelCluster_time_get_(); 867 } catch (Throwable ex) { 868 // marshal the server-side exception 869 c.openSendResult(false); 870 c.sendObject(ex); 871 return; 872 } 873 874 // marshal the return value 875 c.openSendResult(true); 876 c.sendSingleDouble(result); 877 return; 878 } 879 880 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_set_$double: { 881 // unmarshal parameters 882 c.openReceivePrimitive(8); 883 double p0 = c.receiveDouble(); 884 c.closeReceivePrimitive(8); 885 c.closeReceiveCall(); 886 887 double result; 888 try { 889 // call the implementation 890 result = impl.run_ModelCluster_time_set_(p0); 891 } catch (Throwable ex) { 892 // marshal the server-side exception 893 c.openSendResult(false); 894 c.sendObject(ex); 895 return; 896 } 897 898 // marshal the return value 899 c.openSendResult(true); 900 c.sendSingleDouble(result); 901 return; 902 } 903 904 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_time_inc_$double$boolean: { 905 // unmarshal parameters 906 c.openReceivePrimitive(9); 907 double p0 = c.receiveDouble(); 908 boolean p1 = c.receiveBoolean(); 909 c.closeReceivePrimitive(9); 910 c.closeReceiveCall(); 911 912 double result; 913 try { 914 // call the implementation 915 result = impl.run_ModelCluster_time_inc_(p0, p1); 916 } catch (Throwable ex) { 917 // marshal the server-side exception 918 c.openSendResult(false); 919 c.sendObject(ex); 920 return; 921 } 922 923 // marshal the return value 924 c.openSendResult(true); 925 c.sendSingleDouble(result); 926 return; 927 } 928 929 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_get_$: { 930 // unmarshal parameters 931 c.closeReceiveCall(); 932 933 double result; 934 try { 935 // call the implementation 936 result = impl.run_ModelCluster_ttemp_get_(); 937 } catch (Throwable ex) { 938 // marshal the server-side exception 939 c.openSendResult(false); 940 c.sendObject(ex); 941 return; 942 } 943 944 // marshal the return value 945 c.openSendResult(true); 946 c.sendSingleDouble(result); 947 return; 948 } 949 950 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_set_$double: { 951 // unmarshal parameters 952 c.openReceivePrimitive(8); 953 double p0 = c.receiveDouble(); 954 c.closeReceivePrimitive(8); 955 c.closeReceiveCall(); 956 957 double result; 958 try { 959 // call the implementation 960 result = impl.run_ModelCluster_ttemp_set_(p0); 961 } catch (Throwable ex) { 962 // marshal the server-side exception 963 c.openSendResult(false); 964 c.sendObject(ex); 965 return; 966 } 967 968 // marshal the return value 969 c.openSendResult(true); 970 c.sendSingleDouble(result); 971 return; 972 } 973 974 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_ttemp_inc_$double$boolean: { 975 // unmarshal parameters 976 c.openReceivePrimitive(9); 977 double p0 = c.receiveDouble(); 978 boolean p1 = c.receiveBoolean(); 979 c.closeReceivePrimitive(9); 980 c.closeReceiveCall(); 981 982 double result; 983 try { 984 // call the implementation 985 result = impl.run_ModelCluster_ttemp_inc_(p0, p1); 986 } catch (Throwable ex) { 987 // marshal the server-side exception 988 c.openSendResult(false); 989 c.sendObject(ex); 990 return; 991 } 992 993 // marshal the return value 994 c.openSendResult(true); 995 c.sendSingleDouble(result); 996 return; 997 } 998 999 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_get_$: { 1000 // unmarshal parameters 1001 c.closeReceiveCall(); 1002 1003 double result; 1004 try { 1005 // call the implementation 1006 result = impl.run_ModelCluster_exported_ttemp_get_(); 1007 } catch (Throwable ex) { 1008 // marshal the server-side exception 1009 c.openSendResult(false); 1010 c.sendObject(ex); 1011 return; 1012 } 1013 1014 // marshal the return value 1015 c.openSendResult(true); 1016 c.sendSingleDouble(result); 1017 return; 1018 } 1019 1020 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_set_$double: { 1021 // unmarshal parameters 1022 c.openReceivePrimitive(8); 1023 double p0 = c.receiveDouble(); 1024 c.closeReceivePrimitive(8); 1025 c.closeReceiveCall(); 1026 1027 double result; 1028 try { 1029 // call the implementation 1030 result = impl.run_ModelCluster_exported_ttemp_set_(p0); 1031 } catch (Throwable ex) { 1032 // marshal the server-side exception 1033 c.openSendResult(false); 1034 c.sendObject(ex); 1035 return; 1036 } 1037 1038 // marshal the return value 1039 c.openSendResult(true); 1040 c.sendSingleDouble(result); 1041 return; 1042 } 1043 1044 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exported_ttemp_inc_$double$boolean: { 1045 // unmarshal parameters 1046 c.openReceivePrimitive(9); 1047 double p0 = c.receiveDouble(); 1048 boolean p1 = c.receiveBoolean(); 1049 c.closeReceivePrimitive(9); 1050 c.closeReceiveCall(); 1051 1052 double result; 1053 try { 1054 // call the implementation 1055 result = impl.run_ModelCluster_exported_ttemp_inc_(p0, p1); 1056 } catch (Throwable ex) { 1057 // marshal the server-side exception 1058 c.openSendResult(false); 1059 c.sendObject(ex); 1060 return; 1061 } 1062 1063 // marshal the return value 1064 c.openSendResult(true); 1065 c.sendSingleDouble(result); 1066 return; 1067 } 1068 1069 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_get_$: { 1070 // unmarshal parameters 1071 c.closeReceiveCall(); 1072 1073 int result; 1074 try { 1075 // call the implementation 1076 result = impl.run_ModelCluster_i_get_(); 1077 } catch (Throwable ex) { 1078 // marshal the server-side exception 1079 c.openSendResult(false); 1080 c.sendObject(ex); 1081 return; 1082 } 1083 1084 // marshal the return value 1085 c.openSendResult(true); 1086 c.sendSingleInt(result); 1087 return; 1088 } 1089 1090 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_set_$int: { 1091 // unmarshal parameters 1092 c.openReceivePrimitive(4); 1093 int p0 = c.receiveInt(); 1094 c.closeReceivePrimitive(4); 1095 c.closeReceiveCall(); 1096 1097 int result; 1098 try { 1099 // call the implementation 1100 result = impl.run_ModelCluster_i_set_(p0); 1101 } catch (Throwable ex) { 1102 // marshal the server-side exception 1103 c.openSendResult(false); 1104 c.sendObject(ex); 1105 return; 1106 } 1107 1108 // marshal the return value 1109 c.openSendResult(true); 1110 c.sendSingleInt(result); 1111 return; 1112 } 1113 1114 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_i_inc_$int$boolean: { 1115 // unmarshal parameters 1116 c.openReceivePrimitive(5); 1117 int p0 = c.receiveInt(); 1118 boolean p1 = c.receiveBoolean(); 1119 c.closeReceivePrimitive(5); 1120 c.closeReceiveCall(); 1121 1122 int result; 1123 try { 1124 // call the implementation 1125 result = impl.run_ModelCluster_i_inc_(p0, p1); 1126 } catch (Throwable ex) { 1127 // marshal the server-side exception 1128 c.openSendResult(false); 1129 c.sendObject(ex); 1130 return; 1131 } 1132 1133 // marshal the return value 1134 c.openSendResult(true); 1135 c.sendSingleInt(result); 1136 return; 1137 } 1138 1139 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_controlset_get_$: { 1140 // unmarshal parameters 1141 c.closeReceiveCall(); 1142 1143 run.Controlset result; 1144 try { 1145 // call the implementation 1146 result = impl.run_ModelCluster_controlset_get_(); 1147 } catch (Throwable ex) { 1148 // marshal the server-side exception 1149 c.openSendResult(false); 1150 c.sendObject(ex); 1151 return; 1152 } 1153 1154 // marshal the return value 1155 c.openSendResult(true); 1156 c.sendObject(result); 1157 return; 1158 } 1159 1160 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_controlset_set_$run_Controlset: { 1161 // unmarshal parameters 1162 run.Controlset p0 = (run.Controlset) c.receiveObject(); 1163 c.closeReceiveCall(); 1164 1165 run.Controlset result; 1166 try { 1167 // call the implementation 1168 result = impl.run_ModelCluster_controlset_set_(p0); 1169 } catch (Throwable ex) { 1170 // marshal the server-side exception 1171 c.openSendResult(false); 1172 c.sendObject(ex); 1173 return; 1174 } 1175 1176 // marshal the return value 1177 c.openSendResult(true); 1178 c.sendObject(result); 1179 return; 1180 } 1181 1182 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_element_get_$: { 1183 // unmarshal parameters 1184 c.closeReceiveCall(); 1185 1186 run.Element result; 1187 try { 1188 // call the implementation 1189 result = impl.run_ModelCluster_temporary_element_get_(); 1190 } catch (Throwable ex) { 1191 // marshal the server-side exception 1192 c.openSendResult(false); 1193 c.sendObject(ex); 1194 return; 1195 } 1196 1197 // marshal the return value 1198 c.openSendResult(true); 1199 c.sendObject(result); 1200 return; 1201 } 1202 1203 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_element_set_$run_Element: { 1204 // unmarshal parameters 1205 run.Element p0 = (run.Element) c.receiveObject(); 1206 c.closeReceiveCall(); 1207 1208 run.Element result; 1209 try { 1210 // call the implementation 1211 result = impl.run_ModelCluster_temporary_element_set_(p0); 1212 } catch (Throwable ex) { 1213 // marshal the server-side exception 1214 c.openSendResult(false); 1215 c.sendObject(ex); 1216 return; 1217 } 1218 1219 // marshal the return value 1220 c.openSendResult(true); 1221 c.sendObject(result); 1222 return; 1223 } 1224 1225 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_tracker_get_$: { 1226 // unmarshal parameters 1227 c.closeReceiveCall(); 1228 1229 run.Tracker result; 1230 try { 1231 // call the implementation 1232 result = impl.run_ModelCluster_temporary_tracker_get_(); 1233 } catch (Throwable ex) { 1234 // marshal the server-side exception 1235 c.openSendResult(false); 1236 c.sendObject(ex); 1237 return; 1238 } 1239 1240 // marshal the return value 1241 c.openSendResult(true); 1242 c.sendObject(result); 1243 return; 1244 } 1245 1246 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_tracker_set_$run_Tracker: { 1247 // unmarshal parameters 1248 run.Tracker p0 = (run.Tracker) c.receiveObject(); 1249 c.closeReceiveCall(); 1250 1251 run.Tracker result; 1252 try { 1253 // call the implementation 1254 result = impl.run_ModelCluster_temporary_tracker_set_(p0); 1255 } catch (Throwable ex) { 1256 // marshal the server-side exception 1257 c.openSendResult(false); 1258 c.sendObject(ex); 1259 return; 1260 } 1261 1262 // marshal the return value 1263 c.openSendResult(true); 1264 c.sendObject(result); 1265 return; 1266 } 1267 1268 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_constraint_get_$: { 1269 // unmarshal parameters 1270 c.closeReceiveCall(); 1271 1272 run.Constraint result; 1273 try { 1274 // call the implementation 1275 result = impl.run_ModelCluster_temporary_constraint_get_(); 1276 } catch (Throwable ex) { 1277 // marshal the server-side exception 1278 c.openSendResult(false); 1279 c.sendObject(ex); 1280 return; 1281 } 1282 1283 // marshal the return value 1284 c.openSendResult(true); 1285 c.sendObject(result); 1286 return; 1287 } 1288 1289 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_constraint_set_$run_Constraint: { 1290 // unmarshal parameters 1291 run.Constraint p0 = (run.Constraint) c.receiveObject(); 1292 c.closeReceiveCall(); 1293 1294 run.Constraint result; 1295 try { 1296 // call the implementation 1297 result = impl.run_ModelCluster_temporary_constraint_set_(p0); 1298 } catch (Throwable ex) { 1299 // marshal the server-side exception 1300 c.openSendResult(false); 1301 c.sendObject(ex); 1302 return; 1303 } 1304 1305 // marshal the return value 1306 c.openSendResult(true); 1307 c.sendObject(result); 1308 return; 1309 } 1310 1311 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_node_get_$: { 1312 // unmarshal parameters 1313 c.closeReceiveCall(); 1314 1315 run.Node result; 1316 try { 1317 // call the implementation 1318 result = impl.run_ModelCluster_temporary_node_get_(); 1319 } catch (Throwable ex) { 1320 // marshal the server-side exception 1321 c.openSendResult(false); 1322 c.sendObject(ex); 1323 return; 1324 } 1325 1326 // marshal the return value 1327 c.openSendResult(true); 1328 c.sendObject(result); 1329 return; 1330 } 1331 1332 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_temporary_node_set_$run_Node: { 1333 // unmarshal parameters 1334 run.Node p0 = (run.Node) c.receiveObject(); 1335 c.closeReceiveCall(); 1336 1337 run.Node result; 1338 try { 1339 // call the implementation 1340 result = impl.run_ModelCluster_temporary_node_set_(p0); 1341 } catch (Throwable ex) { 1342 // marshal the server-side exception 1343 c.openSendResult(false); 1344 c.sendObject(ex); 1345 return; 1346 } 1347 1348 // marshal the return value 1349 c.openSendResult(true); 1350 c.sendObject(result); 1351 return; 1352 } 1353 1354 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_resultwriter_get_$: { 1355 // unmarshal parameters 1356 c.closeReceiveCall(); 1357 1358 run.Writer result; 1359 try { 1360 // call the implementation 1361 result = impl.run_ModelCluster_resultwriter_get_(); 1362 } catch (Throwable ex) { 1363 // marshal the server-side exception 1364 c.openSendResult(false); 1365 c.sendObject(ex); 1366 return; 1367 } 1368 1369 // marshal the return value 1370 c.openSendResult(true); 1371 c.sendObject(result); 1372 return; 1373 } 1374 1375 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_resultwriter_set_$run_Writer: { 1376 // unmarshal parameters 1377 run.Writer p0 = (run.Writer) c.receiveObject(); 1378 c.closeReceiveCall(); 1379 1380 run.Writer result; 1381 try { 1382 // call the implementation 1383 result = impl.run_ModelCluster_resultwriter_set_(p0); 1384 } catch (Throwable ex) { 1385 // marshal the server-side exception 1386 c.openSendResult(false); 1387 c.sendObject(ex); 1388 return; 1389 } 1390 1391 // marshal the return value 1392 c.openSendResult(true); 1393 c.sendObject(result); 1394 return; 1395 } 1396 1397 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackwriter_get_$: { 1398 // unmarshal parameters 1399 c.closeReceiveCall(); 1400 1401 run.TrackWriter result; 1402 try { 1403 // call the implementation 1404 result = impl.run_ModelCluster_trackwriter_get_(); 1405 } catch (Throwable ex) { 1406 // marshal the server-side exception 1407 c.openSendResult(false); 1408 c.sendObject(ex); 1409 return; 1410 } 1411 1412 // marshal the return value 1413 c.openSendResult(true); 1414 c.sendObject(result); 1415 return; 1416 } 1417 1418 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_trackwriter_set_$run_TrackWriter: { 1419 // unmarshal parameters 1420 run.TrackWriter p0 = (run.TrackWriter) c.receiveObject(); 1421 c.closeReceiveCall(); 1422 1423 run.TrackWriter result; 1424 try { 1425 // call the implementation 1426 result = impl.run_ModelCluster_trackwriter_set_(p0); 1427 } catch (Throwable ex) { 1428 // marshal the server-side exception 1429 c.openSendResult(false); 1430 c.sendObject(ex); 1431 return; 1432 } 1433 1434 // marshal the return value 1435 c.openSendResult(true); 1436 c.sendObject(result); 1437 return; 1438 } 1439 1440 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_filename_get_$: { 1441 // unmarshal parameters 1442 c.closeReceiveCall(); 1443 1444 java.lang.String result; 1445 try { 1446 // call the implementation 1447 result = impl.run_ModelCluster_filename_get_(); 1448 } catch (Throwable ex) { 1449 // marshal the server-side exception 1450 c.openSendResult(false); 1451 c.sendObject(ex); 1452 return; 1453 } 1454 1455 // marshal the return value 1456 c.openSendResult(true); 1457 c.sendObject(result); 1458 return; 1459 } 1460 1461 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_filename_set_$java_lang_String: { 1462 // unmarshal parameters 1463 java.lang.String p0 = (java.lang.String) c.receiveObject(); 1464 c.closeReceiveCall(); 1465 1466 java.lang.String result; 1467 try { 1468 // call the implementation 1469 result = impl.run_ModelCluster_filename_set_(p0); 1470 } catch (Throwable ex) { 1471 // marshal the server-side exception 1472 c.openSendResult(false); 1473 c.sendObject(ex); 1474 return; 1475 } 1476 1477 // marshal the return value 1478 c.openSendResult(true); 1479 c.sendObject(result); 1480 return; 1481 } 1482 1483 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_get_$: { 1484 // unmarshal parameters 1485 c.closeReceiveCall(); 1486 1487 double result; 1488 try { 1489 // call the implementation 1490 result = impl.run_ModelCluster_timestep_get_(); 1491 } catch (Throwable ex) { 1492 // marshal the server-side exception 1493 c.openSendResult(false); 1494 c.sendObject(ex); 1495 return; 1496 } 1497 1498 // marshal the return value 1499 c.openSendResult(true); 1500 c.sendSingleDouble(result); 1501 return; 1502 } 1503 1504 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_set_$double: { 1505 // unmarshal parameters 1506 c.openReceivePrimitive(8); 1507 double p0 = c.receiveDouble(); 1508 c.closeReceivePrimitive(8); 1509 c.closeReceiveCall(); 1510 1511 double result; 1512 try { 1513 // call the implementation 1514 result = impl.run_ModelCluster_timestep_set_(p0); 1515 } catch (Throwable ex) { 1516 // marshal the server-side exception 1517 c.openSendResult(false); 1518 c.sendObject(ex); 1519 return; 1520 } 1521 1522 // marshal the return value 1523 c.openSendResult(true); 1524 c.sendSingleDouble(result); 1525 return; 1526 } 1527 1528 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_timestep_inc_$double$boolean: { 1529 // unmarshal parameters 1530 c.openReceivePrimitive(9); 1531 double p0 = c.receiveDouble(); 1532 boolean p1 = c.receiveBoolean(); 1533 c.closeReceivePrimitive(9); 1534 c.closeReceiveCall(); 1535 1536 double result; 1537 try { 1538 // call the implementation 1539 result = impl.run_ModelCluster_timestep_inc_(p0, p1); 1540 } catch (Throwable ex) { 1541 // marshal the server-side exception 1542 c.openSendResult(false); 1543 c.sendObject(ex); 1544 return; 1545 } 1546 1547 // marshal the return value 1548 c.openSendResult(true); 1549 c.sendSingleDouble(result); 1550 return; 1551 } 1552 1553 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_failure_is_set_get_$: { 1554 // unmarshal parameters 1555 c.closeReceiveCall(); 1556 1557 boolean result; 1558 try { 1559 // call the implementation 1560 result = impl.run_ModelCluster_failure_is_set_get_(); 1561 } catch (Throwable ex) { 1562 // marshal the server-side exception 1563 c.openSendResult(false); 1564 c.sendObject(ex); 1565 return; 1566 } 1567 1568 // marshal the return value 1569 c.openSendResult(true); 1570 c.sendSingleBoolean(result); 1571 return; 1572 } 1573 1574 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_failure_is_set_set_$boolean: { 1575 // unmarshal parameters 1576 c.openReceivePrimitive(1); 1577 boolean p0 = c.receiveBoolean(); 1578 c.closeReceivePrimitive(1); 1579 c.closeReceiveCall(); 1580 1581 boolean result; 1582 try { 1583 // call the implementation 1584 result = impl.run_ModelCluster_failure_is_set_set_(p0); 1585 } catch (Throwable ex) { 1586 // marshal the server-side exception 1587 c.openSendResult(false); 1588 c.sendObject(ex); 1589 return; 1590 } 1591 1592 // marshal the return value 1593 c.openSendResult(true); 1594 c.sendSingleBoolean(result); 1595 return; 1596 } 1597 1598 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_autostep_get_$: { 1599 // unmarshal parameters 1600 c.closeReceiveCall(); 1601 1602 boolean result; 1603 try { 1604 // call the implementation 1605 result = impl.run_ModelCluster_autostep_get_(); 1606 } catch (Throwable ex) { 1607 // marshal the server-side exception 1608 c.openSendResult(false); 1609 c.sendObject(ex); 1610 return; 1611 } 1612 1613 // marshal the return value 1614 c.openSendResult(true); 1615 c.sendSingleBoolean(result); 1616 return; 1617 } 1618 1619 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_autostep_set_$boolean: { 1620 // unmarshal parameters 1621 c.openReceivePrimitive(1); 1622 boolean p0 = c.receiveBoolean(); 1623 c.closeReceivePrimitive(1); 1624 c.closeReceiveCall(); 1625 1626 boolean result; 1627 try { 1628 // call the implementation 1629 result = impl.run_ModelCluster_autostep_set_(p0); 1630 } catch (Throwable ex) { 1631 // marshal the server-side exception 1632 c.openSendResult(false); 1633 c.sendObject(ex); 1634 return; 1635 } 1636 1637 // marshal the return value 1638 c.openSendResult(true); 1639 c.sendSingleBoolean(result); 1640 return; 1641 } 1642 1643 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_get_$: { 1644 // unmarshal parameters 1645 c.closeReceiveCall(); 1646 1647 int result; 1648 try { 1649 // call the implementation 1650 result = impl.run_ModelCluster_nr_of_CPUs_get_(); 1651 } catch (Throwable ex) { 1652 // marshal the server-side exception 1653 c.openSendResult(false); 1654 c.sendObject(ex); 1655 return; 1656 } 1657 1658 // marshal the return value 1659 c.openSendResult(true); 1660 c.sendSingleInt(result); 1661 return; 1662 } 1663 1664 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_set_$int: { 1665 // unmarshal parameters 1666 c.openReceivePrimitive(4); 1667 int p0 = c.receiveInt(); 1668 c.closeReceivePrimitive(4); 1669 c.closeReceiveCall(); 1670 1671 int result; 1672 try { 1673 // call the implementation 1674 result = impl.run_ModelCluster_nr_of_CPUs_set_(p0); 1675 } catch (Throwable ex) { 1676 // marshal the server-side exception 1677 c.openSendResult(false); 1678 c.sendObject(ex); 1679 return; 1680 } 1681 1682 // marshal the return value 1683 c.openSendResult(true); 1684 c.sendSingleInt(result); 1685 return; 1686 } 1687 1688 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nr_of_CPUs_inc_$int$boolean: { 1689 // unmarshal parameters 1690 c.openReceivePrimitive(5); 1691 int p0 = c.receiveInt(); 1692 boolean p1 = c.receiveBoolean(); 1693 c.closeReceivePrimitive(5); 1694 c.closeReceiveCall(); 1695 1696 int result; 1697 try { 1698 // call the implementation 1699 result = impl.run_ModelCluster_nr_of_CPUs_inc_(p0, p1); 1700 } catch (Throwable ex) { 1701 // marshal the server-side exception 1702 c.openSendResult(false); 1703 c.sendObject(ex); 1704 return; 1705 } 1706 1707 // marshal the return value 1708 c.openSendResult(true); 1709 c.sendSingleInt(result); 1710 return; 1711 } 1712 1713 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_get_$: { 1714 // unmarshal parameters 1715 c.closeReceiveCall(); 1716 1717 int result; 1718 try { 1719 // call the implementation 1720 result = impl.run_ModelCluster_client_nr_get_(); 1721 } catch (Throwable ex) { 1722 // marshal the server-side exception 1723 c.openSendResult(false); 1724 c.sendObject(ex); 1725 return; 1726 } 1727 1728 // marshal the return value 1729 c.openSendResult(true); 1730 c.sendSingleInt(result); 1731 return; 1732 } 1733 1734 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_set_$int: { 1735 // unmarshal parameters 1736 c.openReceivePrimitive(4); 1737 int p0 = c.receiveInt(); 1738 c.closeReceivePrimitive(4); 1739 c.closeReceiveCall(); 1740 1741 int result; 1742 try { 1743 // call the implementation 1744 result = impl.run_ModelCluster_client_nr_set_(p0); 1745 } catch (Throwable ex) { 1746 // marshal the server-side exception 1747 c.openSendResult(false); 1748 c.sendObject(ex); 1749 return; 1750 } 1751 1752 // marshal the return value 1753 c.openSendResult(true); 1754 c.sendSingleInt(result); 1755 return; 1756 } 1757 1758 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_client_nr_inc_$int$boolean: { 1759 // unmarshal parameters 1760 c.openReceivePrimitive(5); 1761 int p0 = c.receiveInt(); 1762 boolean p1 = c.receiveBoolean(); 1763 c.closeReceivePrimitive(5); 1764 c.closeReceiveCall(); 1765 1766 int result; 1767 try { 1768 // call the implementation 1769 result = impl.run_ModelCluster_client_nr_inc_(p0, p1); 1770 } catch (Throwable ex) { 1771 // marshal the server-side exception 1772 c.openSendResult(false); 1773 c.sendObject(ex); 1774 return; 1775 } 1776 1777 // marshal the return value 1778 c.openSendResult(true); 1779 c.sendSingleInt(result); 1780 return; 1781 } 1782 1783 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_get_$: { 1784 // unmarshal parameters 1785 c.closeReceiveCall(); 1786 1787 run.ModelCluster[] result; 1788 try { 1789 // call the implementation 1790 result = impl.run_ModelCluster_cluster_nodes_get_(); 1791 } catch (Throwable ex) { 1792 // marshal the server-side exception 1793 c.openSendResult(false); 1794 c.sendObject(ex); 1795 return; 1796 } 1797 1798 // marshal the return value 1799 c.openSendResult(true); 1800 c.sendObject(result); 1801 return; 1802 } 1803 1804 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_set_$_run_ModelCluster: { 1805 // unmarshal parameters 1806 run.ModelCluster[] p0 = (run.ModelCluster[]) c.receiveObject(); 1807 c.closeReceiveCall(); 1808 1809 run.ModelCluster[] result; 1810 try { 1811 // call the implementation 1812 result = impl.run_ModelCluster_cluster_nodes_set_(p0); 1813 } catch (Throwable ex) { 1814 // marshal the server-side exception 1815 c.openSendResult(false); 1816 c.sendObject(ex); 1817 return; 1818 } 1819 1820 // marshal the return value 1821 c.openSendResult(true); 1822 c.sendObject(result); 1823 return; 1824 } 1825 1826 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_get_$int: { 1827 // unmarshal parameters 1828 c.openReceivePrimitive(4); 1829 int p0 = c.receiveInt(); 1830 c.closeReceivePrimitive(4); 1831 c.closeReceiveCall(); 1832 1833 run.ModelCluster result; 1834 try { 1835 // call the implementation 1836 result = impl.run_ModelCluster_cluster_nodes_get_(p0); 1837 } catch (Throwable ex) { 1838 // marshal the server-side exception 1839 c.openSendResult(false); 1840 c.sendObject(ex); 1841 return; 1842 } 1843 1844 // marshal the return value 1845 c.openSendResult(true); 1846 c.sendObject(result); 1847 return; 1848 } 1849 1850 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_cluster_nodes_set_$int$run_ModelCluster: { 1851 // unmarshal parameters 1852 c.openReceivePrimitive(4); 1853 int p0 = c.receiveInt(); 1854 c.closeReceivePrimitive(4); 1855 run.ModelCluster p1 = (run.ModelCluster) c.receiveObject(); 1856 c.closeReceiveCall(); 1857 1858 run.ModelCluster result; 1859 try { 1860 // call the implementation 1861 result = impl.run_ModelCluster_cluster_nodes_set_(p0, p1); 1862 } catch (Throwable ex) { 1863 // marshal the server-side exception 1864 c.openSendResult(false); 1865 c.sendObject(ex); 1866 return; 1867 } 1868 1869 // marshal the return value 1870 c.openSendResult(true); 1871 c.sendObject(result); 1872 return; 1873 } 1874 1875 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_get_$: { 1876 // unmarshal parameters 1877 c.closeReceiveCall(); 1878 1879 int[] result; 1880 try { 1881 // call the implementation 1882 result = impl.run_ModelCluster_nodeindicies_get_(); 1883 } catch (Throwable ex) { 1884 // marshal the server-side exception 1885 c.openSendResult(false); 1886 c.sendObject(ex); 1887 return; 1888 } 1889 1890 // marshal the return value 1891 c.openSendResult(true); 1892 c.sendObject(result); 1893 return; 1894 } 1895 1896 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_set_$_int: { 1897 // unmarshal parameters 1898 int[] p0 = (int[]) c.receiveObject(); 1899 c.closeReceiveCall(); 1900 1901 int[] result; 1902 try { 1903 // call the implementation 1904 result = impl.run_ModelCluster_nodeindicies_set_(p0); 1905 } catch (Throwable ex) { 1906 // marshal the server-side exception 1907 c.openSendResult(false); 1908 c.sendObject(ex); 1909 return; 1910 } 1911 1912 // marshal the return value 1913 c.openSendResult(true); 1914 c.sendObject(result); 1915 return; 1916 } 1917 1918 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_get_$int: { 1919 // unmarshal parameters 1920 c.openReceivePrimitive(4); 1921 int p0 = c.receiveInt(); 1922 c.closeReceivePrimitive(4); 1923 c.closeReceiveCall(); 1924 1925 int result; 1926 try { 1927 // call the implementation 1928 result = impl.run_ModelCluster_nodeindicies_get_(p0); 1929 } catch (Throwable ex) { 1930 // marshal the server-side exception 1931 c.openSendResult(false); 1932 c.sendObject(ex); 1933 return; 1934 } 1935 1936 // marshal the return value 1937 c.openSendResult(true); 1938 c.sendSingleInt(result); 1939 return; 1940 } 1941 1942 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_set_$int$int: { 1943 // unmarshal parameters 1944 c.openReceivePrimitive(8); 1945 int p0 = c.receiveInt(); 1946 int p1 = c.receiveInt(); 1947 c.closeReceivePrimitive(8); 1948 c.closeReceiveCall(); 1949 1950 int result; 1951 try { 1952 // call the implementation 1953 result = impl.run_ModelCluster_nodeindicies_set_(p0, p1); 1954 } catch (Throwable ex) { 1955 // marshal the server-side exception 1956 c.openSendResult(false); 1957 c.sendObject(ex); 1958 return; 1959 } 1960 1961 // marshal the return value 1962 c.openSendResult(true); 1963 c.sendSingleInt(result); 1964 return; 1965 } 1966 1967 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_nodeindicies_inc_$int$int$boolean: { 1968 // unmarshal parameters 1969 c.openReceivePrimitive(9); 1970 int p0 = c.receiveInt(); 1971 int p1 = c.receiveInt(); 1972 boolean p2 = c.receiveBoolean(); 1973 c.closeReceivePrimitive(9); 1974 c.closeReceiveCall(); 1975 1976 int result; 1977 try { 1978 // call the implementation 1979 result = impl.run_ModelCluster_nodeindicies_inc_(p0, p1, p2); 1980 } catch (Throwable ex) { 1981 // marshal the server-side exception 1982 c.openSendResult(false); 1983 c.sendObject(ex); 1984 return; 1985 } 1986 1987 // marshal the return value 1988 c.openSendResult(true); 1989 c.sendSingleInt(result); 1990 return; 1991 } 1992 1993 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_get_$: { 1994 // unmarshal parameters 1995 c.closeReceiveCall(); 1996 1997 int[] result; 1998 try { 1999 // call the implementation 2000 result = impl.run_ModelCluster_elementindicies_get_(); 2001 } catch (Throwable ex) { 2002 // marshal the server-side exception 2003 c.openSendResult(false); 2004 c.sendObject(ex); 2005 return; 2006 } 2007 2008 // marshal the return value 2009 c.openSendResult(true); 2010 c.sendObject(result); 2011 return; 2012 } 2013 2014 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_set_$_int: { 2015 // unmarshal parameters 2016 int[] p0 = (int[]) c.receiveObject(); 2017 c.closeReceiveCall(); 2018 2019 int[] result; 2020 try { 2021 // call the implementation 2022 result = impl.run_ModelCluster_elementindicies_set_(p0); 2023 } catch (Throwable ex) { 2024 // marshal the server-side exception 2025 c.openSendResult(false); 2026 c.sendObject(ex); 2027 return; 2028 } 2029 2030 // marshal the return value 2031 c.openSendResult(true); 2032 c.sendObject(result); 2033 return; 2034 } 2035 2036 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_get_$int: { 2037 // unmarshal parameters 2038 c.openReceivePrimitive(4); 2039 int p0 = c.receiveInt(); 2040 c.closeReceivePrimitive(4); 2041 c.closeReceiveCall(); 2042 2043 int result; 2044 try { 2045 // call the implementation 2046 result = impl.run_ModelCluster_elementindicies_get_(p0); 2047 } catch (Throwable ex) { 2048 // marshal the server-side exception 2049 c.openSendResult(false); 2050 c.sendObject(ex); 2051 return; 2052 } 2053 2054 // marshal the return value 2055 c.openSendResult(true); 2056 c.sendSingleInt(result); 2057 return; 2058 } 2059 2060 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_set_$int$int: { 2061 // unmarshal parameters 2062 c.openReceivePrimitive(8); 2063 int p0 = c.receiveInt(); 2064 int p1 = c.receiveInt(); 2065 c.closeReceivePrimitive(8); 2066 c.closeReceiveCall(); 2067 2068 int result; 2069 try { 2070 // call the implementation 2071 result = impl.run_ModelCluster_elementindicies_set_(p0, p1); 2072 } catch (Throwable ex) { 2073 // marshal the server-side exception 2074 c.openSendResult(false); 2075 c.sendObject(ex); 2076 return; 2077 } 2078 2079 // marshal the return value 2080 c.openSendResult(true); 2081 c.sendSingleInt(result); 2082 return; 2083 } 2084 2085 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_elementindicies_inc_$int$int$boolean: { 2086 // unmarshal parameters 2087 c.openReceivePrimitive(9); 2088 int p0 = c.receiveInt(); 2089 int p1 = c.receiveInt(); 2090 boolean p2 = c.receiveBoolean(); 2091 c.closeReceivePrimitive(9); 2092 c.closeReceiveCall(); 2093 2094 int result; 2095 try { 2096 // call the implementation 2097 result = impl.run_ModelCluster_elementindicies_inc_(p0, p1, p2); 2098 } catch (Throwable ex) { 2099 // marshal the server-side exception 2100 c.openSendResult(false); 2101 c.sendObject(ex); 2102 return; 2103 } 2104 2105 // marshal the return value 2106 c.openSendResult(true); 2107 c.sendSingleInt(result); 2108 return; 2109 } 2110 2111 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_get_$: { 2112 // unmarshal parameters 2113 c.closeReceiveCall(); 2114 2115 long result; 2116 try { 2117 // call the implementation 2118 result = impl.run_ModelCluster_benchmark_get_(); 2119 } catch (Throwable ex) { 2120 // marshal the server-side exception 2121 c.openSendResult(false); 2122 c.sendObject(ex); 2123 return; 2124 } 2125 2126 // marshal the return value 2127 c.openSendResult(true); 2128 c.sendSingleLong(result); 2129 return; 2130 } 2131 2132 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_set_$long: { 2133 // unmarshal parameters 2134 c.openReceivePrimitive(8); 2135 long p0 = c.receiveLong(); 2136 c.closeReceivePrimitive(8); 2137 c.closeReceiveCall(); 2138 2139 long result; 2140 try { 2141 // call the implementation 2142 result = impl.run_ModelCluster_benchmark_set_(p0); 2143 } catch (Throwable ex) { 2144 // marshal the server-side exception 2145 c.openSendResult(false); 2146 c.sendObject(ex); 2147 return; 2148 } 2149 2150 // marshal the return value 2151 c.openSendResult(true); 2152 c.sendSingleLong(result); 2153 return; 2154 } 2155 2156 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_benchmark_inc_$long$boolean: { 2157 // unmarshal parameters 2158 c.openReceivePrimitive(9); 2159 long p0 = c.receiveLong(); 2160 boolean p1 = c.receiveBoolean(); 2161 c.closeReceivePrimitive(9); 2162 c.closeReceiveCall(); 2163 2164 long result; 2165 try { 2166 // call the implementation 2167 result = impl.run_ModelCluster_benchmark_inc_(p0, p1); 2168 } catch (Throwable ex) { 2169 // marshal the server-side exception 2170 c.openSendResult(false); 2171 c.sendObject(ex); 2172 return; 2173 } 2174 2175 // marshal the return value 2176 c.openSendResult(true); 2177 c.sendSingleLong(result); 2178 return; 2179 } 2180 2181 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_barrier_get_$: { 2182 // unmarshal parameters 2183 c.closeReceiveCall(); 2184 2185 jp.sync.Barrier result; 2186 try { 2187 // call the implementation 2188 result = impl.run_ModelCluster_barrier_get_(); 2189 } catch (Throwable ex) { 2190 // marshal the server-side exception 2191 c.openSendResult(false); 2192 c.sendObject(ex); 2193 return; 2194 } 2195 2196 // marshal the return value 2197 c.openSendResult(true); 2198 c.sendObject(result); 2199 return; 2200 } 2201 2202 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_barrier_set_$jp_sync_Barrier: { 2203 // unmarshal parameters 2204 jp.sync.Barrier p0 = (jp.sync.Barrier) c.receiveObject(); 2205 c.closeReceiveCall(); 2206 2207 jp.sync.Barrier result; 2208 try { 2209 // call the implementation 2210 result = impl.run_ModelCluster_barrier_set_(p0); 2211 } catch (Throwable ex) { 2212 // marshal the server-side exception 2213 c.openSendResult(false); 2214 c.sendObject(ex); 2215 return; 2216 } 2217 2218 // marshal the return value 2219 c.openSendResult(true); 2220 c.sendObject(result); 2221 return; 2222 } 2223 2224 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exception_listeners_get_$: { 2225 // unmarshal parameters 2226 c.closeReceiveCall(); 2227 2228 java.util.Set result; 2229 try { 2230 // call the implementation 2231 result = impl.run_ModelCluster_exception_listeners_get_(); 2232 } catch (Throwable ex) { 2233 // marshal the server-side exception 2234 c.openSendResult(false); 2235 c.sendObject(ex); 2236 return; 2237 } 2238 2239 // marshal the return value 2240 c.openSendResult(true); 2241 c.sendObject(result); 2242 return; 2243 } 2244 2245 case run.ModelCluster_instance_impl_KStub.ID_run_ModelCluster_exception_listeners_set_$java_util_Set: { 2246 // unmarshal parameters 2247 java.util.Set p0 = (java.util.Set) c.receiveObject(); 2248 c.closeReceiveCall(); 2249 2250 java.util.Set result; 2251 try { 2252 // call the implementation 2253 result = impl.run_ModelCluster_exception_listeners_set_(p0); 2254 } catch (Throwable ex) { 2255 // marshal the server-side exception 2256 c.openSendResult(false); 2257 c.sendObject(ex); 2258 return; 2259 } 2260 2261 // marshal the return value 2262 c.openSendResult(true); 2263 c.sendObject(result); 2264 return; 2265 } 2266 2267 case run.ModelCluster_instance_impl_KStub.ID_assembleMassMatrix$: { 2268 // unmarshal parameters 2269 c.closeReceiveCall(); 2270 2271 try { 2272 // call the implementation 2273 impl.assembleMassMatrix(); 2274 } catch (Throwable ex) { 2275 // marshal the server-side exception 2276 c.openSendResult(false); 2277 c.sendObject(ex); 2278 return; 2279 } 2280 2281 // marshal the return value 2282 c.openSendResult(true); 2283 return; 2284 } 2285 2286 case run.ModelCluster_instance_impl_KStub.ID_initialize$: { 2287 // unmarshal parameters 2288 c.closeReceiveCall(); 2289 2290 try { 2291 // call the implementation 2292 impl.initialize(); 2293 } catch (Throwable ex) { 2294 // marshal the server-side exception 2295 c.openSendResult(false); 2296 c.sendObject(ex); 2297 return; 2298 } 2299 2300 // marshal the return value 2301 c.openSendResult(true); 2302 return; 2303 } 2304 2305 case run.ModelCluster_instance_impl_KStub.ID_post$: { 2306 // unmarshal parameters 2307 c.closeReceiveCall(); 2308 2309 try { 2310 // call the implementation 2311 impl.post(); 2312 } catch (Throwable ex) { 2313 // marshal the server-side exception 2314 c.openSendResult(false); 2315 c.sendObject(ex); 2316 return; 2317 } 2318 2319 // marshal the return value 2320 c.openSendResult(true); 2321 return; 2322 } 2323 2324 case run.ModelCluster_instance_impl_KStub.ID_print$: { 2325 // unmarshal parameters 2326 c.closeReceiveCall(); 2327 2328 try { 2329 // call the implementation 2330 impl.print(); 2331 } catch (Throwable ex) { 2332 // marshal the server-side exception 2333 c.openSendResult(false); 2334 c.sendObject(ex); 2335 return; 2336 } 2337 2338 // marshal the return value 2339 c.openSendResult(true); 2340 return; 2341 } 2342 2343 case run.ModelCluster_instance_impl_KStub.ID_setInitialConditions$: { 2344 // unmarshal parameters 2345 c.closeReceiveCall(); 2346 2347 try { 2348 // call the implementation 2349 impl.setInitialConditions(); 2350 } catch (Throwable ex) { 2351 // marshal the server-side exception 2352 c.openSendResult(false); 2353 c.sendObject(ex); 2354 return; 2355 } 2356 2357 // marshal the return value 2358 c.openSendResult(true); 2359 return; 2360 } 2361 2362 case run.ModelCluster_instance_impl_KStub.ID_solve$jp_sync_Barrier: { 2363 // unmarshal parameters 2364 jp.sync.Barrier p0 = (jp.sync.Barrier) c.receiveObject(); 2365 c.closeReceiveCall(); 2366 2367 try { 2368 // call the implementation 2369 impl.solve(p0); 2370 } catch (Throwable ex) { 2371 // marshal the server-side exception 2372 c.openSendResult(false); 2373 c.sendObject(ex); 2374 return; 2375 } 2376 2377 // marshal the return value 2378 c.openSendResult(true); 2379 return; 2380 } 2381 2382 case run.ModelCluster_instance_impl_KStub.ID_passReferences$: { 2383 // unmarshal parameters 2384 c.closeReceiveCall(); 2385 2386 try { 2387 // call the implementation 2388 impl.passReferences(); 2389 } catch (Throwable ex) { 2390 // marshal the server-side exception 2391 c.openSendResult(false); 2392 c.sendObject(ex); 2393 return; 2394 } 2395 2396 // marshal the return value 2397 c.openSendResult(true); 2398 return; 2399 } 2400 2401 case run.ModelCluster_instance_impl_KStub.ID_setReferences$run_SharedData: { 2402 // unmarshal parameters 2403 run.SharedData p0 = (run.SharedData) c.receiveObject(); 2404 c.closeReceiveCall(); 2405 2406 try { 2407 // call the implementation 2408 impl.setReferences(p0); 2409 } catch (Throwable ex) { 2410 // marshal the server-side exception 2411 c.openSendResult(false); 2412 c.sendObject(ex); 2413 return; 2414 } 2415 2416 // marshal the return value 2417 c.openSendResult(true); 2418 return; 2419 } 2420 2421 case run.ModelCluster_instance_impl_KStub.ID_getTtemp$: { 2422 // unmarshal parameters 2423 c.closeReceiveCall(); 2424 2425 double result; 2426 try { 2427 // call the implementation 2428 result = impl.getTtemp(); 2429 } catch (Throwable ex) { 2430 // marshal the server-side exception 2431 c.openSendResult(false); 2432 c.sendObject(ex); 2433 return; 2434 } 2435 2436 // marshal the return value 2437 c.openSendResult(true); 2438 c.sendSingleDouble(result); 2439 return; 2440 } 2441 2442 case run.ModelCluster_instance_impl_KStub.ID_determineDistribution$: { 2443 // unmarshal parameters 2444 c.closeReceiveCall(); 2445 2446 try { 2447 // call the implementation 2448 impl.determineDistribution(); 2449 } catch (Throwable ex) { 2450 // marshal the server-side exception 2451 c.openSendResult(false); 2452 c.sendObject(ex); 2453 return; 2454 } 2455 2456 // marshal the return value 2457 c.openSendResult(true); 2458 return; 2459 } 2460 2461 case run.ModelCluster_instance_impl_KStub.ID_referenceNodes$: { 2462 // unmarshal parameters 2463 c.closeReceiveCall(); 2464 2465 try { 2466 // call the implementation 2467 impl.referenceNodes(); 2468 } catch (Throwable ex) { 2469 // marshal the server-side exception 2470 c.openSendResult(false); 2471 c.sendObject(ex); 2472 return; 2473 } 2474 2475 // marshal the return value 2476 c.openSendResult(true); 2477 return; 2478 } 2479 2480 case run.ModelCluster_instance_impl_KStub.ID_optimize$: { 2481 // unmarshal parameters 2482 c.closeReceiveCall(); 2483 2484 try { 2485 // call the implementation 2486 impl.optimize(); 2487 } catch (Throwable ex) { 2488 // marshal the server-side exception 2489 c.openSendResult(false); 2490 c.sendObject(ex); 2491 return; 2492 } 2493 2494 // marshal the return value 2495 c.openSendResult(true); 2496 return; 2497 } 2498 2499 case run.ModelCluster_instance_impl_KStub.ID_getBenchmark$: { 2500 // unmarshal parameters 2501 c.closeReceiveCall(); 2502 2503 long result; 2504 try { 2505 // call the implementation 2506 result = impl.getBenchmark(); 2507 } catch (Throwable ex) { 2508 // marshal the server-side exception 2509 c.openSendResult(false); 2510 c.sendObject(ex); 2511 return; 2512 } 2513 2514 // marshal the return value 2515 c.openSendResult(true); 2516 c.sendSingleLong(result); 2517 return; 2518 } 2519 2520 case run.ModelCluster_instance_impl_KStub.ID_run$: { 2521 // unmarshal parameters 2522 c.closeReceiveCall(); 2523 2524 try { 2525 // call the implementation 2526 impl.run(); 2527 } catch (Throwable ex) { 2528 // marshal the server-side exception 2529 c.openSendResult(false); 2530 c.sendObject(ex); 2531 return; 2532 } 2533 2534 // marshal the return value 2535 c.openSendResult(true); 2536 return; 2537 } 2538 2539 case run.ModelCluster_instance_impl_KStub.ID_stopThreads$: { 2540 // unmarshal parameters 2541 c.closeReceiveCall(); 2542 2543 try { 2544 // call the implementation 2545 impl.stopThreads(); 2546 } catch (Throwable ex) { 2547 // marshal the server-side exception 2548 c.openSendResult(false); 2549 c.sendObject(ex); 2550 return; 2551 } 2552 2553 // marshal the return value 2554 c.openSendResult(true); 2555 return; 2556 } 2557 2558 case run.ModelCluster_instance_impl_KStub.ID_sendException$java_lang_Exception: { 2559 // unmarshal parameters 2560 java.lang.Exception p0 = (java.lang.Exception) c.receiveObject(); 2561 c.closeReceiveCall(); 2562 2563 try { 2564 // call the implementation 2565 impl.sendException(p0); 2566 } catch (Throwable ex) { 2567 // marshal the server-side exception 2568 c.openSendResult(false); 2569 c.sendObject(ex); 2570 return; 2571 } 2572 2573 // marshal the return value 2574 c.openSendResult(true); 2575 return; 2576 } 2577 2578 case run.ModelCluster_instance_impl_KStub.ID_addExceptionListener$run_ExceptionListener: { 2579 // unmarshal parameters 2580 run.ExceptionListener p0 = (run.ExceptionListener) c.receiveObject(); 2581 c.closeReceiveCall(); 2582 2583 try { 2584 // call the implementation 2585 impl.addExceptionListener(p0); 2586 } catch (Throwable ex) { 2587 // marshal the server-side exception 2588 c.openSendResult(false); 2589 c.sendObject(ex); 2590 return; 2591 } 2592 2593 // marshal the return value 2594 c.openSendResult(true); 2595 return; 2596 } 2597 2598 case run.ModelCluster_instance_impl_KStub.ID_setCluster_nodes$_run_ModelCluster: { 2599 // unmarshal parameters 2600 run.ModelCluster[] p0 = (run.ModelCluster[]) c.receiveObject(); 2601 c.closeReceiveCall(); 2602 2603 try { 2604 // call the implementation 2605 impl.setCluster_nodes(p0); 2606 } catch (Throwable ex) { 2607 // marshal the server-side exception 2608 c.openSendResult(false); 2609 c.sendObject(ex); 2610 return; 2611 } 2612 2613 // marshal the return value 2614 c.openSendResult(true); 2615 return; 2616 } 2617 2618 case run.ModelCluster_instance_impl_KStub.ID__wait$: { 2619 // unmarshal parameters 2620 c.closeReceiveCall(); 2621 2622 try { 2623 // call the implementation 2624 impl._wait(); 2625 } catch (Throwable ex) { 2626 // marshal the server-side exception 2627 c.openSendResult(false); 2628 c.sendObject(ex); 2629 return; 2630 } 2631 2632 // marshal the return value 2633 c.openSendResult(true); 2634 return; 2635 } 2636 2637 case run.ModelCluster_instance_impl_KStub.ID__wait$long: { 2638 // unmarshal parameters 2639 c.openReceivePrimitive(8); 2640 long p0 = c.receiveLong(); 2641 c.closeReceivePrimitive(8); 2642 c.closeReceiveCall(); 2643 2644 try { 2645 // call the implementation 2646 impl._wait(p0); 2647 } catch (Throwable ex) { 2648 // marshal the server-side exception 2649 c.openSendResult(false); 2650 c.sendObject(ex); 2651 return; 2652 } 2653 2654 // marshal the return value 2655 c.openSendResult(true); 2656 return; 2657 } 2658 2659 case run.ModelCluster_instance_impl_KStub.ID__wait$long$int: { 2660 // unmarshal parameters 2661 c.openReceivePrimitive(12); 2662 long p0 = c.receiveLong(); 2663 int p1 = c.receiveInt(); 2664 c.closeReceivePrimitive(12); 2665 c.closeReceiveCall(); 2666 2667 try { 2668 // call the implementation 2669 impl._wait(p0, p1); 2670 } catch (Throwable ex) { 2671 // marshal the server-side exception 2672 c.openSendResult(false); 2673 c.sendObject(ex); 2674 return; 2675 } 2676 2677 // marshal the return value 2678 c.openSendResult(true); 2679 return; 2680 } 2681 2682 case run.ModelCluster_instance_impl_KStub.ID__notify$: { 2683 // unmarshal parameters 2684 c.closeReceiveCall(); 2685 2686 try { 2687 // call the implementation 2688 impl._notify(); 2689 } catch (Throwable ex) { 2690 // marshal the server-side exception 2691 c.openSendResult(false); 2692 c.sendObject(ex); 2693 return; 2694 } 2695 2696 // marshal the return value 2697 c.openSendResult(true); 2698 return; 2699 } 2700 2701 case run.ModelCluster_instance_impl_KStub.ID__notifyAll$: { 2702 // unmarshal parameters 2703 c.closeReceiveCall(); 2704 2705 try { 2706 // call the implementation 2707 impl._notifyAll(); 2708 } catch (Throwable ex) { 2709 // marshal the server-side exception 2710 c.openSendResult(false); 2711 c.sendObject(ex); 2712 return; 2713 } 2714 2715 // marshal the return value 2716 c.openSendResult(true); 2717 return; 2718 } 2719 2720 case run.ModelCluster_instance_impl_KStub.ID__equals$java_lang_Object: { 2721 // unmarshal parameters 2722 java.lang.Object p0 = (java.lang.Object) c.receiveObject(); 2723 c.closeReceiveCall(); 2724 2725 boolean result; 2726 try { 2727 // call the implementation 2728 result = impl._equals(p0); 2729 } catch (Throwable ex) { 2730 // marshal the server-side exception 2731 c.openSendResult(false); 2732 c.sendObject(ex); 2733 return; 2734 } 2735 2736 // marshal the return value 2737 c.openSendResult(true); 2738 c.sendSingleBoolean(result); 2739 return; 2740 } 2741 2742 case run.ModelCluster_instance_impl_KStub.ID__location$: { 2743 // unmarshal parameters 2744 c.closeReceiveCall(); 2745 2746 int result; 2747 try { 2748 // call the implementation 2749 result = impl._location(); 2750 } catch (Throwable ex) { 2751 // marshal the server-side exception 2752 c.openSendResult(false); 2753 c.sendObject(ex); 2754 return; 2755 } 2756 2757 // marshal the return value 2758 c.openSendResult(true); 2759 c.sendSingleInt(result); 2760 return; 2761 } 2762 2763 case run.ModelCluster_instance_impl_KStub.ID__migrateTo$jp_lang_VirtualMachine: { 2764 // unmarshal parameters 2765 jp.lang.VirtualMachine p0 = (jp.lang.VirtualMachine) c.receiveObject(); 2766 c.closeReceiveCall(); 2767 2768 java.lang.Object result; 2769 try { 2770 // call the implementation 2771 result = impl._migrateTo(p0); 2772 } catch (Throwable ex) { 2773 // marshal the server-side exception 2774 c.openSendResult(false); 2775 c.sendObject(ex); 2776 return; 2777 } 2778 2779 // marshal the return value 2780 c.openSendResult(true); 2781 c.sendObject(result); 2782 return; 2783 } 2784 2785 default: 2786 throw new InternalError("illegal method number (" + c.mid + ")"); 2787 } 2788 } 2789 } 2790