1 // 2 // Copyright (c) ZeroC, Inc. All rights reserved. 3 // 4 5 package test.Ice.operations; 6 7 import Ice.Current; 8 import test.Ice.operations.Test.*; 9 10 import java.util.*; 11 12 public final class MyDerivedClassI extends _MyDerivedClassDisp 13 { 14 private static void test(boolean b)15 test(boolean b) 16 { 17 if(!b) 18 { 19 throw new RuntimeException(); 20 } 21 } 22 23 // 24 // Override the Object "pseudo" operations to verify the operation mode. 25 // 26 27 @Override 28 public boolean ice_isA(String id, Ice.Current current)29 ice_isA(String id, Ice.Current current) 30 { 31 test(current.mode == Ice.OperationMode.Nonmutating); 32 return super.ice_isA(id, current); 33 } 34 35 @Override 36 public void ice_ping(Ice.Current current)37 ice_ping(Ice.Current current) 38 { 39 test(current.mode == Ice.OperationMode.Nonmutating); 40 super.ice_ping(current); 41 } 42 43 @Override 44 public String[] ice_ids(Ice.Current current)45 ice_ids(Ice.Current current) 46 { 47 test(current.mode == Ice.OperationMode.Nonmutating); 48 return super.ice_ids(current); 49 } 50 51 @Override 52 public String ice_id(Ice.Current current)53 ice_id(Ice.Current current) 54 { 55 test(current.mode == Ice.OperationMode.Nonmutating); 56 return super.ice_id(current); 57 } 58 59 @Override 60 public void shutdown(Ice.Current current)61 shutdown(Ice.Current current) 62 { 63 current.adapter.getCommunicator().shutdown(); 64 } 65 66 @Override 67 public boolean supportsCompress(Ice.Current current)68 supportsCompress(Ice.Current current) 69 { 70 return IceInternal.BZip2.supported(); 71 } 72 73 @Override 74 public void opVoid(Ice.Current current)75 opVoid(Ice.Current current) 76 { 77 test(current.mode == Ice.OperationMode.Normal); 78 } 79 80 @Override 81 public boolean opBool(boolean p1, boolean p2, Ice.BooleanHolder p3, Ice.Current current)82 opBool(boolean p1, boolean p2, 83 Ice.BooleanHolder p3, 84 Ice.Current current) 85 { 86 p3.value = p1; 87 return p2; 88 } 89 90 @Override 91 public boolean[] opBoolS(boolean[] p1, boolean[] p2, BoolSHolder p3, Ice.Current current)92 opBoolS(boolean[] p1, boolean[] p2, 93 BoolSHolder p3, 94 Ice.Current current) 95 { 96 p3.value = new boolean[p1.length + p2.length]; 97 System.arraycopy(p1, 0, p3.value, 0, p1.length); 98 System.arraycopy(p2, 0, p3.value, p1.length, p2.length); 99 100 boolean[] r = new boolean[p1.length]; 101 for(int i = 0; i < p1.length; i++) 102 { 103 r[i] = p1[p1.length - (i + 1)]; 104 } 105 return r; 106 } 107 108 @Override 109 public boolean[][] opBoolSS(boolean[][] p1, boolean[][] p2, BoolSSHolder p3, Ice.Current current)110 opBoolSS(boolean[][] p1, boolean[][] p2, 111 BoolSSHolder p3, 112 Ice.Current current) 113 { 114 p3.value = new boolean[p1.length + p2.length][]; 115 System.arraycopy(p1, 0, p3.value, 0, p1.length); 116 System.arraycopy(p2, 0, p3.value, p1.length, p2.length); 117 118 boolean[][] r = new boolean[p1.length][]; 119 for(int i = 0; i < p1.length; i++) 120 { 121 r[i] = p1[p1.length - (i + 1)]; 122 } 123 return r; 124 } 125 126 @Override 127 public byte opByte(byte p1, byte p2, Ice.ByteHolder p3, Ice.Current current)128 opByte(byte p1, byte p2, 129 Ice.ByteHolder p3, 130 Ice.Current current) 131 { 132 p3.value = (byte) (p1 ^ p2); 133 return p1; 134 } 135 136 @Override 137 public java.util.Map<Byte, Boolean> opByteBoolD(java.util.Map<Byte, Boolean> p1, java.util.Map<Byte, Boolean> p2, ByteBoolDHolder p3, Ice.Current current)138 opByteBoolD(java.util.Map<Byte, Boolean> p1, java.util.Map<Byte, Boolean> p2, ByteBoolDHolder p3, 139 Ice.Current current) 140 { 141 p3.value = p1; 142 java.util.Map<Byte, Boolean> r = new java.util.HashMap<Byte, Boolean>(); 143 r.putAll(p1); 144 r.putAll(p2); 145 return r; 146 } 147 148 @Override 149 public byte[] opByteS(byte[] p1, byte[] p2, ByteSHolder p3, Ice.Current current)150 opByteS(byte[] p1, byte[] p2, 151 ByteSHolder p3, 152 Ice.Current current) 153 { 154 p3.value = new byte[p1.length]; 155 for(int i = 0; i < p1.length; i++) 156 { 157 p3.value[i] = p1[p1.length - (i + 1)]; 158 } 159 160 byte[] r = new byte[p1.length + p2.length]; 161 System.arraycopy(p1, 0, r, 0, p1.length); 162 System.arraycopy(p2, 0, r, p1.length, p2.length); 163 return r; 164 } 165 166 @Override 167 public byte[][] opByteSS(byte[][] p1, byte[][] p2, ByteSSHolder p3, Ice.Current current)168 opByteSS(byte[][] p1, byte[][] p2, 169 ByteSSHolder p3, 170 Ice.Current current) 171 { 172 p3.value = new byte[p1.length][]; 173 for(int i = 0; i < p1.length; i++) 174 { 175 p3.value[i] = p1[p1.length - (i + 1)]; 176 } 177 178 byte[][] r = new byte[p1.length + p2.length][]; 179 System.arraycopy(p1, 0, r, 0, p1.length); 180 System.arraycopy(p2, 0, r, p1.length, p2.length); 181 return r; 182 } 183 184 @Override 185 public double opFloatDouble(float p1, double p2, Ice.FloatHolder p3, Ice.DoubleHolder p4, Ice.Current current)186 opFloatDouble(float p1, double p2, 187 Ice.FloatHolder p3, Ice.DoubleHolder p4, 188 Ice.Current current) 189 { 190 p3.value = p1; 191 p4.value = p2; 192 return p2; 193 } 194 195 @Override 196 public double[] opFloatDoubleS(float[] p1, double[] p2, FloatSHolder p3, DoubleSHolder p4, Ice.Current current)197 opFloatDoubleS(float[] p1, double[] p2, 198 FloatSHolder p3, DoubleSHolder p4, 199 Ice.Current current) 200 { 201 p3.value = p1; 202 p4.value = new double[p2.length]; 203 for(int i = 0; i < p2.length; i++) 204 { 205 p4.value[i] = p2[p2.length - (i + 1)]; 206 } 207 double[] r = new double[p2.length + p1.length]; 208 System.arraycopy(p2, 0, r, 0, p2.length); 209 for(int i = 0; i < p1.length; i++) 210 { 211 r[p2.length + i] = p1[i]; 212 } 213 return r; 214 } 215 216 @Override 217 public double[][] opFloatDoubleSS(float[][] p1, double[][] p2, FloatSSHolder p3, DoubleSSHolder p4, Ice.Current current)218 opFloatDoubleSS(float[][] p1, double[][] p2, 219 FloatSSHolder p3, DoubleSSHolder p4, 220 Ice.Current current) 221 { 222 p3.value = p1; 223 p4.value = new double[p2.length][]; 224 for(int i = 0; i < p2.length; i++) 225 { 226 p4.value[i] = p2[p2.length - (i + 1)]; 227 } 228 double[][] r = new double[p2.length * 2][]; 229 System.arraycopy(p2, 0, r, 0, p2.length); 230 System.arraycopy(p2, 0, r, p2.length, p2.length); 231 return r; 232 } 233 234 @Override 235 public java.util.Map<Long, Float> opLongFloatD(java.util.Map<Long, Float> p1, java.util.Map<Long, Float> p2, LongFloatDHolder p3, Ice.Current current)236 opLongFloatD(java.util.Map<Long, Float> p1, java.util.Map<Long, Float> p2, LongFloatDHolder p3, 237 Ice.Current current) 238 { 239 p3.value = p1; 240 java.util.Map<Long, Float> r = new java.util.HashMap<Long, Float>(); 241 r.putAll(p1); 242 r.putAll(p2); 243 return r; 244 } 245 246 @Override 247 public MyClassPrx opMyClass(MyClassPrx p1, MyClassPrxHolder p2, MyClassPrxHolder p3, Ice.Current current)248 opMyClass(MyClassPrx p1, 249 MyClassPrxHolder p2, MyClassPrxHolder p3, 250 Ice.Current current) 251 { 252 p2.value = p1; 253 p3.value = MyClassPrxHelper.uncheckedCast( 254 current.adapter.createProxy(Ice.Util.stringToIdentity("noSuchIdentity"))); 255 return MyClassPrxHelper.uncheckedCast(current.adapter.createProxy(current.id)); 256 } 257 258 @Override 259 public MyEnum opMyEnum(MyEnum p1, MyEnumHolder p2, Ice.Current current)260 opMyEnum(MyEnum p1, 261 MyEnumHolder p2, 262 Ice.Current current) 263 { 264 p2.value = p1; 265 return MyEnum.enum3; 266 } 267 268 @Override 269 public java.util.Map<Short, Integer> opShortIntD(java.util.Map<Short, Integer> p1, java.util.Map<Short, Integer> p2, ShortIntDHolder p3, Ice.Current current)270 opShortIntD(java.util.Map<Short, Integer> p1, java.util.Map<Short, Integer> p2, ShortIntDHolder p3, 271 Ice.Current current) 272 { 273 p3.value = p1; 274 java.util.Map<Short, Integer> r = new java.util.HashMap<Short, Integer>(); 275 r.putAll(p1); 276 r.putAll(p2); 277 return r; 278 } 279 280 @Override 281 public long opShortIntLong(short p1, int p2, long p3, Ice.ShortHolder p4, Ice.IntHolder p5, Ice.LongHolder p6, Ice.Current current)282 opShortIntLong(short p1, int p2, long p3, 283 Ice.ShortHolder p4, Ice.IntHolder p5, Ice.LongHolder p6, 284 Ice.Current current) 285 { 286 p4.value = p1; 287 p5.value = p2; 288 p6.value = p3; 289 return p3; 290 } 291 292 @Override 293 public long[] opShortIntLongS(short[] p1, int[] p2, long[] p3, ShortSHolder p4, IntSHolder p5, LongSHolder p6, Ice.Current current)294 opShortIntLongS(short[] p1, int[] p2, long[] p3, 295 ShortSHolder p4, IntSHolder p5, LongSHolder p6, 296 Ice.Current current) 297 { 298 p4.value = p1; 299 p5.value = new int[p2.length]; 300 for(int i = 0; i < p2.length; i++) 301 { 302 p5.value[i] = p2[p2.length - (i + 1)]; 303 } 304 p6.value = new long[p3.length * 2]; 305 System.arraycopy(p3, 0, p6.value, 0, p3.length); 306 System.arraycopy(p3, 0, p6.value, p3.length, p3.length); 307 return p3; 308 } 309 310 @Override 311 public long[][] opShortIntLongSS(short[][] p1, int[][] p2, long[][] p3, ShortSSHolder p4, IntSSHolder p5, LongSSHolder p6, Ice.Current current)312 opShortIntLongSS(short[][] p1, int[][] p2, long[][] p3, 313 ShortSSHolder p4, IntSSHolder p5, LongSSHolder p6, 314 Ice.Current current) 315 { 316 p4.value = p1; 317 p5.value = new int[p2.length][]; 318 for(int i = 0; i < p2.length; i++) 319 { 320 p5.value[i] = p2[p2.length - (i + 1)]; 321 } 322 p6.value = new long[p3.length * 2][]; 323 System.arraycopy(p3, 0, p6.value, 0, p3.length); 324 System.arraycopy(p3, 0, p6.value, p3.length, p3.length); 325 return p3; 326 } 327 328 @Override 329 public String opString(String p1, String p2, Ice.StringHolder p3, Ice.Current current)330 opString(String p1, String p2, 331 Ice.StringHolder p3, 332 Ice.Current current) 333 { 334 p3.value = p2 + " " + p1; 335 return p1 + " " + p2; 336 } 337 338 @Override 339 public java.util.Map<String, MyEnum> opStringMyEnumD(java.util.Map<String, MyEnum> p1, java.util.Map<String, MyEnum> p2, StringMyEnumDHolder p3, Ice.Current current)340 opStringMyEnumD(java.util.Map<String, MyEnum> p1, java.util.Map<String, MyEnum> p2, StringMyEnumDHolder p3, 341 Ice.Current current) 342 { 343 p3.value = p1; 344 java.util.Map<String, MyEnum> r = new java.util.HashMap<String, MyEnum>(); 345 r.putAll(p1); 346 r.putAll(p2); 347 return r; 348 } 349 350 @Override 351 public java.util.Map<MyEnum, String> opMyEnumStringD(java.util.Map<MyEnum, String> p1, java.util.Map<MyEnum, String> p2, MyEnumStringDHolder p3, Ice.Current current)352 opMyEnumStringD(java.util.Map<MyEnum, String> p1, java.util.Map<MyEnum, String> p2, MyEnumStringDHolder p3, 353 Ice.Current current) 354 { 355 p3.value = p1; 356 java.util.Map<MyEnum, String> r = new java.util.HashMap<MyEnum, String>(); 357 r.putAll(p1); 358 r.putAll(p2); 359 return r; 360 } 361 362 @Override 363 public java.util.Map<MyStruct, MyEnum> opMyStructMyEnumD(java.util.Map<MyStruct, MyEnum> p1, java.util.Map<MyStruct, MyEnum> p2, MyStructMyEnumDHolder p3, Ice.Current current)364 opMyStructMyEnumD(java.util.Map<MyStruct, MyEnum> p1, java.util.Map<MyStruct, MyEnum> p2, MyStructMyEnumDHolder p3, 365 Ice.Current current) 366 { 367 p3.value = p1; 368 java.util.Map<MyStruct, MyEnum> r = new java.util.HashMap<MyStruct, MyEnum>(); 369 r.putAll(p1); 370 r.putAll(p2); 371 return r; 372 } 373 374 @Override opByteBoolDS(List<Map<Byte, Boolean>> p1, List<Map<Byte, Boolean>> p2, ByteBoolDSHolder p3, Ice.Current current)375 public List<Map<Byte, Boolean>> opByteBoolDS(List<Map<Byte, Boolean>> p1, 376 List<Map<Byte, Boolean>> p2, 377 ByteBoolDSHolder p3, 378 Ice.Current current) 379 { 380 p3.value = new ArrayList<>(); 381 p3.value.addAll(p2); 382 p3.value.addAll(p1); 383 384 List<Map<Byte, Boolean>> r = new ArrayList<>(p1); 385 Collections.reverse(r); 386 387 return r; 388 } 389 390 @Override opShortIntDS(List<Map<Short, Integer>> p1, List<Map<Short, Integer>> p2, ShortIntDSHolder p3, Ice.Current current)391 public List<Map<Short, Integer>> opShortIntDS(List<Map<Short, Integer>> p1, 392 List<Map<Short, Integer>> p2, 393 ShortIntDSHolder p3, 394 Ice.Current current) 395 { 396 p3.value = new ArrayList<>(); 397 p3.value.addAll(p2); 398 p3.value.addAll(p1); 399 400 List<Map<Short, Integer>> r = new ArrayList<>(p1); 401 Collections.reverse(r); 402 403 return r; 404 } 405 406 @Override opLongFloatDS(List<Map<Long, Float>> p1, List<Map<Long, Float>> p2, LongFloatDSHolder p3, Ice.Current current)407 public List<Map<Long, Float>> opLongFloatDS(List<Map<Long, Float>> p1, 408 List<Map<Long, Float>> p2, 409 LongFloatDSHolder p3, 410 Ice.Current current) 411 { 412 p3.value = new ArrayList<>(); 413 p3.value.addAll(p2); 414 p3.value.addAll(p1); 415 416 List<Map<Long, Float>> r = new ArrayList<>(p1); 417 Collections.reverse(r); 418 419 return r; 420 } 421 422 @Override opStringStringDS(List<Map<String, String>> p1, List<Map<String, String>> p2, StringStringDSHolder p3, Ice.Current current)423 public List<Map<String, String>> opStringStringDS(List<Map<String, String>> p1, 424 List<Map<String, String>> p2, 425 StringStringDSHolder p3, 426 Ice.Current current) 427 { 428 p3.value = new ArrayList<>(); 429 p3.value.addAll(p2); 430 p3.value.addAll(p1); 431 432 List<Map<String, String>> r = new ArrayList<>(p1); 433 Collections.reverse(r); 434 435 return r; 436 } 437 438 @Override opStringMyEnumDS(List<Map<String, MyEnum>> p1, List<Map<String, MyEnum>> p2, StringMyEnumDSHolder p3, Ice.Current current)439 public List<Map<String, MyEnum>> opStringMyEnumDS(List<Map<String, MyEnum>> p1, 440 List<Map<String, MyEnum>> p2, 441 StringMyEnumDSHolder p3, 442 Ice.Current current) 443 { 444 p3.value = new ArrayList<>(); 445 p3.value.addAll(p2); 446 p3.value.addAll(p1); 447 448 List<Map<String, MyEnum>> r = new ArrayList<>(p1); 449 Collections.reverse(r); 450 451 return r; 452 } 453 454 @Override opMyEnumStringDS(List<Map<MyEnum, String>> p1, List<Map<MyEnum, String>> p2, MyEnumStringDSHolder p3, Ice.Current current)455 public List<Map<MyEnum, String>> opMyEnumStringDS(List<Map<MyEnum, String>> p1, 456 List<Map<MyEnum, String>> p2, 457 MyEnumStringDSHolder p3, 458 Ice.Current current) 459 { 460 p3.value = new ArrayList<>(); 461 p3.value.addAll(p2); 462 p3.value.addAll(p1); 463 464 List<Map<MyEnum, String>> r = new ArrayList<>(p1); 465 Collections.reverse(r); 466 467 return r; 468 } 469 470 @Override opMyStructMyEnumDS(List<Map<MyStruct, MyEnum>> p1, List<Map<MyStruct, MyEnum>> p2, MyStructMyEnumDSHolder p3, Ice.Current current)471 public List<Map<MyStruct, MyEnum>> opMyStructMyEnumDS(List<Map<MyStruct, MyEnum>> p1, 472 List<Map<MyStruct, MyEnum>> p2, 473 MyStructMyEnumDSHolder p3, 474 Ice.Current current) 475 { 476 p3.value = new ArrayList<>(); 477 p3.value.addAll(p2); 478 p3.value.addAll(p1); 479 480 List<Map<MyStruct, MyEnum>> r = new ArrayList<>(p1); 481 Collections.reverse(r); 482 483 return r; 484 } 485 486 @Override opByteByteSD(Map<Byte, byte[]> p1, Map<Byte, byte[]> p2, ByteByteSDHolder p3, Ice.Current current)487 public Map<Byte, byte[]> opByteByteSD(Map<Byte, byte[]> p1, 488 Map<Byte, byte[]> p2, 489 ByteByteSDHolder p3, 490 Ice.Current current) 491 { 492 p3.value = p2; 493 Map<Byte, byte[]> r = new HashMap<>(); 494 r.putAll(p1); 495 r.putAll(p2); 496 return r; 497 } 498 499 @Override opBoolBoolSD(Map<Boolean, boolean[]> p1, Map<Boolean, boolean[]> p2, BoolBoolSDHolder p3, Ice.Current current)500 public Map<Boolean, boolean[]> opBoolBoolSD(Map<Boolean, boolean[]> p1, 501 Map<Boolean, boolean[]> p2, 502 BoolBoolSDHolder p3, 503 Ice.Current current) 504 { 505 p3.value = p2; 506 Map<Boolean, boolean[]> r = new HashMap<>(); 507 r.putAll(p1); 508 r.putAll(p2); 509 return r; 510 } 511 512 @Override opShortShortSD(Map<Short, short[]> p1, Map<Short, short[]> p2, ShortShortSDHolder p3, Ice.Current current)513 public Map<Short, short[]> opShortShortSD(Map<Short, short[]> p1, 514 Map<Short, short[]> p2, 515 ShortShortSDHolder p3, 516 Ice.Current current) 517 { 518 p3.value = p2; 519 Map<Short, short[]> r = new HashMap<>(); 520 r.putAll(p1); 521 r.putAll(p2); 522 return r; 523 } 524 525 @Override opIntIntSD(Map<Integer, int[]> p1, Map<Integer, int[]> p2, IntIntSDHolder p3, Ice.Current current)526 public Map<Integer, int[]> opIntIntSD(Map<Integer, int[]> p1, 527 Map<Integer, int[]> p2, 528 IntIntSDHolder p3, 529 Ice.Current current) 530 { 531 p3.value = p2; 532 Map<Integer, int[]> r = new HashMap<>(); 533 r.putAll(p1); 534 r.putAll(p2); 535 return r; 536 } 537 538 @Override opLongLongSD(Map<Long, long[]> p1, Map<Long, long[]> p2, LongLongSDHolder p3, Ice.Current current)539 public Map<Long, long[]> opLongLongSD(Map<Long, long[]> p1, 540 Map<Long, long[]> p2, 541 LongLongSDHolder p3, 542 Ice.Current current) 543 { 544 p3.value = p2; 545 Map<Long, long[]> r = new HashMap<>(); 546 r.putAll(p1); 547 r.putAll(p2); 548 return r; 549 } 550 551 @Override opStringFloatSD(Map<String, float[]> p1, Map<String, float[]> p2, StringFloatSDHolder p3, Ice.Current current)552 public Map<String, float[]> opStringFloatSD(Map<String, float[]> p1, 553 Map<String, float[]> p2, 554 StringFloatSDHolder p3, 555 Ice.Current current) 556 { 557 p3.value = p2; 558 Map<String, float[]> r = new HashMap<>(); 559 r.putAll(p1); 560 r.putAll(p2); 561 return r; 562 } 563 564 @Override opStringDoubleSD(Map<String, double[]> p1, Map<String, double[]> p2, StringDoubleSDHolder p3, Ice.Current current)565 public Map<String, double[]> opStringDoubleSD(Map<String, double[]> p1, 566 Map<String, double[]> p2, 567 StringDoubleSDHolder p3, 568 Ice.Current current) 569 { 570 p3.value = p2; 571 Map<String, double[]> r = new HashMap<>(); 572 r.putAll(p1); 573 r.putAll(p2); 574 return r; 575 } 576 577 @Override opStringStringSD(Map<String, String[]> p1, Map<String, String[]> p2, StringStringSDHolder p3, Ice.Current current)578 public Map<String, String[]> opStringStringSD(Map<String, String[]> p1, 579 Map<String, String[]> p2, 580 StringStringSDHolder p3, 581 Ice.Current current) 582 { 583 p3.value = p2; 584 Map<String, String[]> r = new HashMap<>(); 585 r.putAll(p1); 586 r.putAll(p2); 587 return r; 588 } 589 590 @Override opMyEnumMyEnumSD(Map<MyEnum, MyEnum[]> p1, Map<MyEnum, MyEnum[]> p2, MyEnumMyEnumSDHolder p3, Ice.Current current)591 public Map<MyEnum, MyEnum[]> opMyEnumMyEnumSD(Map<MyEnum, MyEnum[]> p1, 592 Map<MyEnum, MyEnum[]> p2, 593 MyEnumMyEnumSDHolder p3, 594 Ice.Current current) 595 { 596 p3.value = p2; 597 Map<MyEnum, MyEnum[]> r = new HashMap<>(); 598 r.putAll(p1); 599 r.putAll(p2); 600 return r; 601 } 602 603 @Override 604 public int[] opIntS(int[] s, Ice.Current current)605 opIntS(int[] s, Ice.Current current) 606 { 607 int[] r = new int[s.length]; 608 for(int i = 0; i < r.length; ++i) 609 { 610 r[i] = -s[i]; 611 } 612 return r; 613 } 614 615 @Override 616 public synchronized void opByteSOneway(byte[] s, Ice.Current current)617 opByteSOneway(byte[] s, Ice.Current current) 618 { 619 ++_opByteSOnewayCallCount; 620 } 621 622 @Override 623 public synchronized int opByteSOnewayCallCount(Ice.Current current)624 opByteSOnewayCallCount(Ice.Current current) 625 { 626 int count = _opByteSOnewayCallCount; 627 _opByteSOnewayCallCount = 0; 628 return count; 629 } 630 631 @Override 632 public java.util.Map<String, String> opContext(Ice.Current current)633 opContext(Ice.Current current) 634 { 635 return current.ctx; 636 } 637 638 @Override 639 public void opDoubleMarshaling(double p1, double[] p2, Ice.Current current)640 opDoubleMarshaling(double p1, double[] p2, Ice.Current current) 641 { 642 double d = 1278312346.0 / 13.0; 643 test(p1 == d); 644 for(int i = 0; i < p2.length; ++i) 645 { 646 test(p2[i] == d); 647 } 648 } 649 650 @Override 651 public String[] opStringS(String[] p1, String[] p2, StringSHolder p3, Ice.Current current)652 opStringS(String[] p1, String[] p2, 653 StringSHolder p3, 654 Ice.Current current) 655 { 656 p3.value = new String[p1.length + p2.length]; 657 System.arraycopy(p1, 0, p3.value, 0, p1.length); 658 System.arraycopy(p2, 0, p3.value, p1.length, p2.length); 659 660 String[] r = new String[p1.length]; 661 for(int i = 0; i < p1.length; i++) 662 { 663 r[i] = p1[p1.length - (i + 1)]; 664 } 665 return r; 666 } 667 668 @Override 669 public String[][] opStringSS(String[][] p1, String[][] p2, StringSSHolder p3, Ice.Current current)670 opStringSS(String[][] p1, String[][] p2, 671 StringSSHolder p3, 672 Ice.Current current) 673 { 674 p3.value = new String[p1.length + p2.length][]; 675 System.arraycopy(p1, 0, p3.value, 0, p1.length); 676 System.arraycopy(p2, 0, p3.value, p1.length, p2.length); 677 678 String[][] r = new String[p2.length][]; 679 for(int i = 0; i < p2.length; i++) 680 { 681 r[i] = p2[p2.length - (i + 1)]; 682 } 683 return r; 684 } 685 686 @Override 687 public String[][][] opStringSSS(String[][][] p1, String[][][] p2, StringSSSHolder p3, Ice.Current current)688 opStringSSS(String[][][] p1, String[][][] p2, 689 StringSSSHolder p3, 690 Ice.Current current) 691 { 692 p3.value = new String[p1.length + p2.length][][]; 693 System.arraycopy(p1, 0, p3.value, 0, p1.length); 694 System.arraycopy(p2, 0, p3.value, p1.length, p2.length); 695 696 String[][][] r = new String[p2.length][][]; 697 for(int i = 0; i < p2.length; i++) 698 { 699 r[i] = p2[p2.length - (i + 1)]; 700 } 701 return r; 702 } 703 704 @Override 705 public java.util.Map<String, String> opStringStringD(java.util.Map<String, String> p1, java.util.Map<String, String> p2, StringStringDHolder p3, Ice.Current current)706 opStringStringD(java.util.Map<String, String> p1, java.util.Map<String, String> p2, StringStringDHolder p3, 707 Ice.Current current) 708 { 709 p3.value = p1; 710 java.util.Map<String, String> r = new java.util.HashMap<String, String>(); 711 r.putAll(p1); 712 r.putAll(p2); 713 return r; 714 } 715 716 @Override 717 public Structure opStruct(Structure p1, Structure p2, StructureHolder p3, Ice.Current current)718 opStruct(Structure p1, Structure p2, 719 StructureHolder p3, 720 Ice.Current current) 721 { 722 p3.value = p1; 723 p3.value.s.s = "a new string"; 724 return p2; 725 } 726 727 @Override 728 public void opIdempotent(Ice.Current current)729 opIdempotent(Ice.Current current) 730 { 731 test(current.mode == Ice.OperationMode.Idempotent); 732 } 733 734 @Override 735 public void opNonmutating(Ice.Current current)736 opNonmutating(Ice.Current current) 737 { 738 test(current.mode == Ice.OperationMode.Nonmutating); 739 } 740 741 @Override 742 public void opDerived(Ice.Current current)743 opDerived(Ice.Current current) 744 { 745 } 746 747 @Override opByte1(byte value, Ice.Current current)748 public byte opByte1(byte value, Ice.Current current) 749 { 750 return value; 751 } 752 753 @Override opShort1(short value, Ice.Current current)754 public short opShort1(short value, Ice.Current current) 755 { 756 return value; 757 } 758 759 @Override opInt1(int value, Ice.Current current)760 public int opInt1(int value, Ice.Current current) 761 { 762 return value; 763 } 764 765 @Override opLong1(long value, Ice.Current current)766 public long opLong1(long value, Ice.Current current) 767 { 768 return value; 769 } 770 771 @Override opFloat1(float value, Ice.Current current)772 public float opFloat1(float value, Ice.Current current) 773 { 774 return value; 775 } 776 777 @Override opDouble1(double value, Ice.Current current)778 public double opDouble1(double value, Ice.Current current) 779 { 780 return value; 781 } 782 783 @Override opString1(String value, Ice.Current current)784 public String opString1(String value, Ice.Current current) 785 { 786 return value; 787 } 788 789 @Override opStringS1(String[] value, Ice.Current current)790 public String[] opStringS1(String[] value, Ice.Current current) 791 { 792 return value; 793 } 794 795 @Override opByteBoolD1(Map<Byte, Boolean> value, Ice.Current current)796 public Map<Byte, Boolean> opByteBoolD1(Map<Byte, Boolean> value, Ice.Current current) 797 { 798 return value; 799 } 800 801 @Override opStringS2(String[] value, Ice.Current current)802 public String[] opStringS2(String[] value, Ice.Current current) 803 { 804 return value; 805 } 806 807 @Override opByteBoolD2(Map<Byte, Boolean> value, Ice.Current current)808 public Map<Byte, Boolean> opByteBoolD2(Map<Byte, Boolean> value, Ice.Current current) 809 { 810 return value; 811 } 812 813 @Override opMyClass1(MyClass1 value, Ice.Current current)814 public MyClass1 opMyClass1(MyClass1 value, Ice.Current current) 815 { 816 return value; 817 } 818 819 @Override opMyStruct1(MyStruct1 value, Ice.Current current)820 public MyStruct1 opMyStruct1(MyStruct1 value, Ice.Current current) 821 { 822 return value; 823 } 824 825 @Override opStringLiterals(Ice.Current current)826 public String[] opStringLiterals(Ice.Current current) 827 { 828 return new String[] 829 { 830 s0.value, 831 s1.value, 832 s2.value, 833 s3.value, 834 s4.value, 835 s5.value, 836 s6.value, 837 s7.value, 838 s8.value, 839 s9.value, 840 s10.value, 841 842 sw0.value, 843 sw1.value, 844 sw2.value, 845 sw3.value, 846 sw4.value, 847 sw5.value, 848 sw6.value, 849 sw7.value, 850 sw8.value, 851 sw9.value, 852 sw10.value, 853 854 ss0.value, 855 ss1.value, 856 ss2.value, 857 ss3.value, 858 ss4.value, 859 ss5.value, 860 861 su0.value, 862 su1.value, 863 su2.value 864 }; 865 } 866 867 @Override opWStringLiterals(Ice.Current current)868 public String[] opWStringLiterals(Ice.Current current) 869 { 870 return opStringLiterals(current); 871 } 872 873 @Override opMStruct1(Ice.Current current)874 public Structure opMStruct1(Ice.Current current) 875 { 876 return new Structure(); 877 } 878 879 @Override opMStruct2(Structure p1, StructureHolder p2, Ice.Current current)880 public Structure opMStruct2(Structure p1, StructureHolder p2, Ice.Current current) 881 { 882 p2.value = p1; 883 return p1; 884 } 885 886 @Override opMSeq1(Ice.Current current)887 public String[] opMSeq1(Ice.Current current) 888 { 889 return new String[0]; 890 } 891 892 @Override opMSeq2(String[] p1, StringSHolder p2, Ice.Current current)893 public String[] opMSeq2(String[] p1, StringSHolder p2, Ice.Current current) 894 { 895 p2.value = p1; 896 return p1; 897 } 898 899 @Override opMDict1(Ice.Current current)900 public Map<String, String> opMDict1(Ice.Current current) 901 { 902 return new HashMap<String, String>(); 903 } 904 905 @Override opMDict2(Map<String, String> p1, StringStringDHolder p2, Ice.Current current)906 public Map<String, String> opMDict2(Map<String, String> p1, StringStringDHolder p2, Ice.Current current) 907 { 908 p2.value = p1; 909 return p1; 910 } 911 912 private int _opByteSOnewayCallCount = 0; 913 } 914