001/* 002 * BridJ - Dynamic and blazing-fast native interop for Java. 003 * http://bridj.googlecode.com/ 004 * 005 * Copyright (c) 2010-2013, Olivier Chafik (http://ochafik.com/) 006 * All rights reserved. 007 * 008 * Redistribution and use in source and binary forms, with or without 009 * modification, are permitted provided that the following conditions are met: 010 * 011 * * Redistributions of source code must retain the above copyright 012 * notice, this list of conditions and the following disclaimer. 013 * * Redistributions in binary form must reproduce the above copyright 014 * notice, this list of conditions and the following disclaimer in the 015 * documentation and/or other materials provided with the distribution. 016 * * Neither the name of Olivier Chafik nor the 017 * names of its contributors may be used to endorse or promote products 018 * derived from this software without specific prior written permission. 019 * 020 * THIS SOFTWARE IS PROVIDED BY OLIVIER CHAFIK AND CONTRIBUTORS ``AS IS'' AND ANY 021 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 022 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 023 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY 024 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 025 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 026 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 027 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 028 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 029 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 030 */ 031package org.bridj.cpp.com; 032 033import org.bridj.CRuntime; 034import org.bridj.Pointer; 035import org.bridj.StructObject; 036import org.bridj.ValuedEnum; 037import org.bridj.ann.CLong; 038import org.bridj.ann.Field; 039import org.bridj.ann.Library; 040import org.bridj.ann.Union; 041import org.bridj.ann.Runtime; 042 043/** 044 * Represents an object that can be interpreted as more than one type. 045 */ 046@Runtime(COMRuntime.class) 047public class VARIANT extends StructObject { 048 049 public VARIANT(Object value) { 050 super(); 051 setValue(value); 052 } 053 054 public VARIANT() { 055 super(); 056 } 057 058 public VARIANT clone() { 059 return COMRuntime.clone(this); 060 } 061 /// C type : __VARIANT_NAME_1_union 062 063 @Field(0) 064 public VARIANT.__VARIANT_NAME_1_union __VARIANT_NAME_1() { 065 return this.io.getNativeObjectField(this, 0); 066 } 067 /// <i>native declaration : line 107</i> 068 069 @Union 070 public static class __VARIANT_NAME_1_union extends StructObject { 071 072 public __VARIANT_NAME_1_union() { 073 super(); 074 } 075// public __VARIANT_NAME_1_union(Pointer pointer) { 076// super(pointer); 077// } 078 /// C type : __tagVARIANT 079 080 @Field(0) 081 public VARIANT.__VARIANT_NAME_1_union.__tagVARIANT __VARIANT_NAME_2() { 082 return this.io.getNativeObjectField(this, 0); 083 } 084 /// C type : DECIMAL 085 086 @Field(1) 087 public DECIMAL decVal() { 088 return this.io.getNativeObjectField(this, 1); 089 } 090 /// <i>native declaration : line 109</i> 091 092 public static class __tagVARIANT extends StructObject { 093 094 public __tagVARIANT() { 095 super(); 096 } 097// public __tagVARIANT(Pointer pointer) { 098// super(pointer); 099// } 100 /// C type : VARTYPE 101 102 @Field(0) 103 public short vt() { 104 return this.io.getShortField(this, 0); 105 } 106 /// C type : VARTYPE 107 108 @Field(0) 109 public __tagVARIANT vt(short vt) { 110 this.io.setShortField(this, 0, vt); 111 return this; 112 } 113 /// C type : VARTYPE 114 115 public final short vt_$eq(short vt) { 116 vt(vt); 117 return vt; 118 } 119 120 @Field(1) 121 public short wReserved1() { 122 return this.io.getShortField(this, 1); 123 } 124 125 @Field(1) 126 public __tagVARIANT wReserved1(short wReserved1) { 127 this.io.setShortField(this, 1, wReserved1); 128 return this; 129 } 130 131 public final short wReserved1_$eq(short wReserved1) { 132 wReserved1(wReserved1); 133 return wReserved1; 134 } 135 136 @Field(2) 137 public short wReserved2() { 138 return this.io.getShortField(this, 2); 139 } 140 141 @Field(2) 142 public __tagVARIANT wReserved2(short wReserved2) { 143 this.io.setShortField(this, 2, wReserved2); 144 return this; 145 } 146 147 public final short wReserved2_$eq(short wReserved2) { 148 wReserved2(wReserved2); 149 return wReserved2; 150 } 151 152 @Field(3) 153 public short wReserved3() { 154 return this.io.getShortField(this, 3); 155 } 156 157 @Field(3) 158 public __tagVARIANT wReserved3(short wReserved3) { 159 this.io.setShortField(this, 3, wReserved3); 160 return this; 161 } 162 163 public final short wReserved3_$eq(short wReserved3) { 164 wReserved3(wReserved3); 165 return wReserved3; 166 } 167 /// C type : __VARIANT_NAME_3_union 168 169 @Field(4) 170 public VARIANT.__VARIANT_NAME_1_union.__tagVARIANT.__VARIANT_NAME_3_union __VARIANT_NAME_3() { 171 return this.io.getNativeObjectField(this, 4); 172 } 173 /// <i>native declaration : line 115</i> 174 175 @Union 176 public static class __VARIANT_NAME_3_union extends StructObject { 177 178 public __VARIANT_NAME_3_union() { 179 super(); 180 } 181// public __VARIANT_NAME_3_union(Pointer pointer) { 182// super(pointer); 183// } 184 /// VT_I8 185 186 @Field(0) 187 public long llval() { 188 return this.io.getLongField(this, 0); 189 } 190 /// VT_I8 191 192 @Field(0) 193 public __VARIANT_NAME_3_union llval(long llval) { 194 this.io.setLongField(this, 0, llval); 195 return this; 196 } 197 198 public final long llval_$eq(long llval) { 199 llval(llval); 200 return llval; 201 } 202 /// VT_I4 203 204 @CLong 205 @Field(1) 206 public long lVal() { 207 return this.io.getCLongField(this, 1); 208 } 209 /// VT_I4 210 211 @CLong 212 @Field(1) 213 public __VARIANT_NAME_3_union lVal(long lVal) { 214 this.io.setCLongField(this, 1, lVal); 215 return this; 216 } 217 218 public final long lVal_$eq(long lVal) { 219 lVal(lVal); 220 return lVal; 221 } 222 /// VT_UI1 223 224 @Field(2) 225 public byte bVal() { 226 return this.io.getByteField(this, 2); 227 } 228 /// VT_UI1 229 230 @Field(2) 231 public __VARIANT_NAME_3_union bVal(byte bVal) { 232 this.io.setByteField(this, 2, bVal); 233 return this; 234 } 235 236 public final byte bVal_$eq(byte bVal) { 237 bVal(bVal); 238 return bVal; 239 } 240 241 /** 242 * VT_I2<br> 243 * C type : SHORT 244 */ 245 @Field(3) 246 public short iVal() { 247 return this.io.getShortField(this, 3); 248 } 249 250 /** 251 * VT_I2<br> 252 * C type : SHORT 253 */ 254 @Field(3) 255 public __VARIANT_NAME_3_union iVal(short iVal) { 256 this.io.setShortField(this, 3, iVal); 257 return this; 258 } 259 /// C type : SHORT 260 261 public final short iVal_$eq(short iVal) { 262 iVal(iVal); 263 return iVal; 264 } 265 266 /** 267 * VT_R4<br> 268 * C type : FLOAT 269 */ 270 @Field(4) 271 public float fltVal() { 272 return this.io.getFloatField(this, 4); 273 } 274 275 /** 276 * VT_R4<br> 277 * C type : FLOAT 278 */ 279 @Field(4) 280 public __VARIANT_NAME_3_union fltVal(float fltVal) { 281 this.io.setFloatField(this, 4, fltVal); 282 return this; 283 } 284 /// C type : FLOAT 285 286 public final float fltVal_$eq(float fltVal) { 287 fltVal(fltVal); 288 return fltVal; 289 } 290 291 /** 292 * VT_R8<br> 293 * C type : DOUBLE 294 */ 295 @Field(5) 296 public double dblVal() { 297 return this.io.getDoubleField(this, 5); 298 } 299 300 /** 301 * VT_R8<br> 302 * C type : DOUBLE 303 */ 304 @Field(5) 305 public __VARIANT_NAME_3_union dblVal(double dblVal) { 306 this.io.setDoubleField(this, 5, dblVal); 307 return this; 308 } 309 /// C type : DOUBLE 310 311 public final double dblVal_$eq(double dblVal) { 312 dblVal(dblVal); 313 return dblVal; 314 } 315 316 /** 317 * VT_BOOL<br> 318 * C type : VARIANT_BOOL 319 */ 320 @Field(6) 321 public int boolVal() { 322 return this.io.getIntField(this, 6); 323 } 324 325 /** 326 * VT_BOOL<br> 327 * C type : VARIANT_BOOL 328 */ 329 @Field(6) 330 public __VARIANT_NAME_3_union boolVal(int boolVal) { 331 this.io.setIntField(this, 6, boolVal); 332 return this; 333 } 334 /// C type : VARIANT_BOOL 335 336 public final int boolVal_$eq(int boolVal) { 337 boolVal(boolVal); 338 return boolVal; 339 } 340 /// C type : _VARIANT_BOOL 341 342 @Field(7) 343 public int bool() { 344 return this.io.getIntField(this, 7); 345 } 346 /// C type : _VARIANT_BOOL 347 348 @Field(7) 349 public __VARIANT_NAME_3_union bool(int bool) { 350 this.io.setIntField(this, 7, bool); 351 return this; 352 } 353 /// C type : _VARIANT_BOOL 354 355 public final int bool_$eq(int bool) { 356 bool(bool); 357 return bool; 358 } 359 360 /** 361 * VT_ERROR<br> 362 * C type : SCODE 363 */ 364 @Field(8) 365 public int scode() { 366 return this.io.getIntField(this, 8); 367 } 368 369 /** 370 * VT_ERROR<br> 371 * C type : SCODE 372 */ 373 @Field(8) 374 public __VARIANT_NAME_3_union scode(int scode) { 375 this.io.setIntField(this, 8, scode); 376 return this; 377 } 378 /// C type : SCODE 379 380 public final int scode_$eq(int scode) { 381 scode(scode); 382 return scode; 383 } 384 385 /** 386 * VT_CY<br> 387 * C type : CY 388 */ 389 @Field(9) 390 public CY cyVal() { 391 return this.io.getNativeObjectField(this, 9); 392 } 393 394 /** 395 * VT_DATE<br> 396 * C type : DATE 397 */ 398 @Field(10) 399 public double date() { 400 return this.io.getDoubleField(this, 10); 401 } 402 403 /** 404 * VT_DATE<br> 405 * C type : DATE 406 */ 407 @Field(10) 408 public __VARIANT_NAME_3_union date(double date) { 409 this.io.setDoubleField(this, 10, date); 410 return this; 411 } 412 /// C type : DATE 413 414 public final double date_$eq(double date) { 415 date(date); 416 return date; 417 } 418 419 /** 420 * VT_BSTR<br> 421 * C type : BSTR 422 */ 423 @Field(11) 424 public Pointer<Byte> bstrVal() { 425 return this.io.getPointerField(this, 11); 426 } 427 428 /** 429 * VT_BSTR<br> 430 * C type : BSTR 431 */ 432 @Field(11) 433 public __VARIANT_NAME_3_union bstrVal(Pointer<Byte> bstrVal) { 434 this.io.setPointerField(this, 11, bstrVal); 435 return this; 436 } 437 /// C type : BSTR 438 439 public final Pointer<Byte> bstrVal_$eq(Pointer<Byte> bstrVal) { 440 bstrVal(bstrVal); 441 return bstrVal; 442 } 443 444 /** 445 * VT_UNKNOWN<br> 446 * C type : IUnknown* 447 */ 448 @Field(12) 449 public Pointer<IUnknown> punkVal() { 450 return this.io.getPointerField(this, 12); 451 } 452 453 /** 454 * VT_UNKNOWN<br> 455 * C type : IUnknown* 456 */ 457 @Field(12) 458 public __VARIANT_NAME_3_union punkVal(Pointer<IUnknown> punkVal) { 459 this.io.setPointerField(this, 12, punkVal); 460 return this; 461 } 462 /// C type : IUnknown* 463 464 public final Pointer<IUnknown> punkVal_$eq(Pointer<IUnknown> punkVal) { 465 punkVal(punkVal); 466 return punkVal; 467 } 468 469 /** 470 * VT_DISPATCH<br> 471 * C type : IDispatch* 472 */ 473 @Field(13) 474 public Pointer<IDispatch> pdispVal() { 475 return this.io.getPointerField(this, 13); 476 } 477 478 /** 479 * VT_DISPATCH<br> 480 * C type : IDispatch* 481 */ 482 @Field(13) 483 public __VARIANT_NAME_3_union pdispVal(Pointer<IDispatch> pdispVal) { 484 this.io.setPointerField(this, 13, pdispVal); 485 return this; 486 } 487 /// C type : IDispatch* 488 489 public final Pointer<IDispatch> pdispVal_$eq(Pointer<IDispatch> pdispVal) { 490 pdispVal(pdispVal); 491 return pdispVal; 492 } 493 494 /** 495 * VT_ARRAY|*<br> 496 * C type : SAFEARRAY* 497 */ 498 @Field(14) 499 public Pointer<SAFEARRAY> parray() { 500 return this.io.getPointerField(this, 14); 501 } 502 503 /** 504 * VT_ARRAY|*<br> 505 * C type : SAFEARRAY* 506 */ 507 @Field(14) 508 public __VARIANT_NAME_3_union parray(Pointer<SAFEARRAY> parray) { 509 this.io.setPointerField(this, 14, parray); 510 return this; 511 } 512 /// C type : SAFEARRAY* 513 514 public final Pointer<SAFEARRAY> parray_$eq(Pointer<SAFEARRAY> parray) { 515 parray(parray); 516 return parray; 517 } 518 519 /** 520 * VT_BYREF|VT_UI1<br> 521 * C type : BYTE* 522 */ 523 @Field(15) 524 public Pointer<Byte> pbVal() { 525 return this.io.getPointerField(this, 15); 526 } 527 528 /** 529 * VT_BYREF|VT_UI1<br> 530 * C type : BYTE* 531 */ 532 @Field(15) 533 public __VARIANT_NAME_3_union pbVal(Pointer<Byte> pbVal) { 534 this.io.setPointerField(this, 15, pbVal); 535 return this; 536 } 537 /// C type : BYTE* 538 539 public final Pointer<Byte> pbVal_$eq(Pointer<Byte> pbVal) { 540 pbVal(pbVal); 541 return pbVal; 542 } 543 544 /** 545 * VT_BYREF|VT_I2<br> 546 * C type : SHORT* 547 */ 548 @Field(16) 549 public Pointer<Short> piVal() { 550 return this.io.getPointerField(this, 16); 551 } 552 553 /** 554 * VT_BYREF|VT_I2<br> 555 * C type : SHORT* 556 */ 557 @Field(16) 558 public __VARIANT_NAME_3_union piVal(Pointer<Short> piVal) { 559 this.io.setPointerField(this, 16, piVal); 560 return this; 561 } 562 /// C type : SHORT* 563 564 public final Pointer<Short> piVal_$eq(Pointer<Short> piVal) { 565 piVal(piVal); 566 return piVal; 567 } 568 569 /** 570 * VT_BYREF|VT_I4<br> 571 * C type : LONG* 572 */ 573 @Field(17) 574 public Pointer<CLong> plVal() { 575 return this.io.getPointerField(this, 17); 576 } 577 578 /** 579 * VT_BYREF|VT_I4<br> 580 * C type : LONG* 581 */ 582 @Field(17) 583 public __VARIANT_NAME_3_union plVal(Pointer<CLong> plVal) { 584 this.io.setPointerField(this, 17, plVal); 585 return this; 586 } 587 /// C type : LONG* 588 589 public final Pointer<CLong> plVal_$eq(Pointer<CLong> plVal) { 590 plVal(plVal); 591 return plVal; 592 } 593 594 /** 595 * VT_BYREF|VT_I8<br> 596 * C type : LONGLONG* 597 */ 598 @Field(18) 599 public Pointer<Long> pllVal() { 600 return this.io.getPointerField(this, 18); 601 } 602 603 /** 604 * VT_BYREF|VT_I8<br> 605 * C type : LONGLONG* 606 */ 607 @Field(18) 608 public __VARIANT_NAME_3_union pllVal(Pointer<Long> pllVal) { 609 this.io.setPointerField(this, 18, pllVal); 610 return this; 611 } 612 /// C type : LONGLONG* 613 614 public final Pointer<Long> pllVal_$eq(Pointer<Long> pllVal) { 615 pllVal(pllVal); 616 return pllVal; 617 } 618 619 /** 620 * VT_BYREF|VT_R4<br> 621 * C type : FLOAT* 622 */ 623 @Field(19) 624 public Pointer<Float> pfltVal() { 625 return this.io.getPointerField(this, 19); 626 } 627 628 /** 629 * VT_BYREF|VT_R4<br> 630 * C type : FLOAT* 631 */ 632 @Field(19) 633 public __VARIANT_NAME_3_union pfltVal(Pointer<Float> pfltVal) { 634 this.io.setPointerField(this, 19, pfltVal); 635 return this; 636 } 637 /// C type : FLOAT* 638 639 public final Pointer<Float> pfltVal_$eq(Pointer<Float> pfltVal) { 640 pfltVal(pfltVal); 641 return pfltVal; 642 } 643 644 /** 645 * VT_BYREF|VT_R8<br> 646 * C type : DOUBLE* 647 */ 648 @Field(20) 649 public Pointer<Double> pdblVal() { 650 return this.io.getPointerField(this, 20); 651 } 652 653 /** 654 * VT_BYREF|VT_R8<br> 655 * C type : DOUBLE* 656 */ 657 @Field(20) 658 public __VARIANT_NAME_3_union pdblVal(Pointer<Double> pdblVal) { 659 this.io.setPointerField(this, 20, pdblVal); 660 return this; 661 } 662 /// C type : DOUBLE* 663 664 public final Pointer<Double> pdblVal_$eq(Pointer<Double> pdblVal) { 665 pdblVal(pdblVal); 666 return pdblVal; 667 } 668 669 /** 670 * VT_BYREF|VT_BOOL<br> 671 * C type : VARIANT_BOOL* 672 */ 673 @Field(21) 674 public Pointer<Integer> pboolVal() { 675 return this.io.getPointerField(this, 21); 676 } 677 678 /** 679 * VT_BYREF|VT_BOOL<br> 680 * C type : VARIANT_BOOL* 681 */ 682 @Field(21) 683 public __VARIANT_NAME_3_union pboolVal(Pointer<Integer> pboolVal) { 684 this.io.setPointerField(this, 21, pboolVal); 685 return this; 686 } 687 /// C type : VARIANT_BOOL* 688 689 public final Pointer<Integer> pboolVal_$eq(Pointer<Integer> pboolVal) { 690 pboolVal(pboolVal); 691 return pboolVal; 692 } 693 /// C type : _VARIANT_BOOL* 694 695 @Field(22) 696 public Pointer<Integer> pbool() { 697 return this.io.getPointerField(this, 22); 698 } 699 /// C type : _VARIANT_BOOL* 700 701 @Field(22) 702 public __VARIANT_NAME_3_union pbool(Pointer<Integer> pbool) { 703 this.io.setPointerField(this, 22, pbool); 704 return this; 705 } 706 /// C type : _VARIANT_BOOL* 707 708 public final Pointer<Integer> pbool_$eq(Pointer<Integer> pbool) { 709 pbool(pbool); 710 return pbool; 711 } 712 713 /** 714 * VT_BYREF|VT_ERROR<br> 715 * C type : SCODE* 716 */ 717 @Field(23) 718 public Pointer<Integer> pscode() { 719 return this.io.getPointerField(this, 23); 720 } 721 722 /** 723 * VT_BYREF|VT_ERROR<br> 724 * C type : SCODE* 725 */ 726 @Field(23) 727 public __VARIANT_NAME_3_union pscode(Pointer<Integer> pscode) { 728 this.io.setPointerField(this, 23, pscode); 729 return this; 730 } 731 /// C type : SCODE* 732 733 public final Pointer<Integer> pscode_$eq(Pointer<Integer> pscode) { 734 pscode(pscode); 735 return pscode; 736 } 737 738 /** 739 * VT_BYREF|VT_CY<br> 740 * C type : CY* 741 */ 742 @Field(24) 743 public Pointer<CY> pcyVal() { 744 return this.io.getPointerField(this, 24); 745 } 746 747 /** 748 * VT_BYREF|VT_CY<br> 749 * C type : CY* 750 */ 751 @Field(24) 752 public __VARIANT_NAME_3_union pcyVal(Pointer<CY> pcyVal) { 753 this.io.setPointerField(this, 24, pcyVal); 754 return this; 755 } 756 /// C type : CY* 757 758 public final Pointer<CY> pcyVal_$eq(Pointer<CY> pcyVal) { 759 pcyVal(pcyVal); 760 return pcyVal; 761 } 762 763 /** 764 * VT_BYREF|VT_DATE<br> 765 * C type : DATE* 766 */ 767 @Field(25) 768 public Pointer<Double> pdate() { 769 return this.io.getPointerField(this, 25); 770 } 771 772 /** 773 * VT_BYREF|VT_DATE<br> 774 * C type : DATE* 775 */ 776 @Field(25) 777 public __VARIANT_NAME_3_union pdate(Pointer<Double> pdate) { 778 this.io.setPointerField(this, 25, pdate); 779 return this; 780 } 781 /// C type : DATE* 782 783 public final Pointer<Double> pdate_$eq(Pointer<Double> pdate) { 784 pdate(pdate); 785 return pdate; 786 } 787 788 /** 789 * VT_BYREF|VT_BSTR<br> 790 * C type : BSTR* 791 */ 792 @Field(26) 793 public Pointer<Pointer<Byte>> pbstrVal() { 794 return this.io.getPointerField(this, 26); 795 } 796 797 /** 798 * VT_BYREF|VT_BSTR<br> 799 * C type : BSTR* 800 */ 801 @Field(26) 802 public __VARIANT_NAME_3_union pbstrVal(Pointer<Pointer<Byte>> pbstrVal) { 803 this.io.setPointerField(this, 26, pbstrVal); 804 return this; 805 } 806 /// C type : BSTR* 807 808 public final Pointer<Pointer<Byte>> pbstrVal_$eq(Pointer<Pointer<Byte>> pbstrVal) { 809 pbstrVal(pbstrVal); 810 return pbstrVal; 811 } 812 813 /** 814 * VT_BYREF|VT_UNKNOWN<br> 815 * C type : IUnknown** 816 */ 817 @Field(27) 818 public Pointer<Pointer<IUnknown>> ppunkVal() { 819 return this.io.getPointerField(this, 27); 820 } 821 822 /** 823 * VT_BYREF|VT_UNKNOWN<br> 824 * C type : IUnknown** 825 */ 826 @Field(27) 827 public __VARIANT_NAME_3_union ppunkVal(Pointer<Pointer<IUnknown>> ppunkVal) { 828 this.io.setPointerField(this, 27, ppunkVal); 829 return this; 830 } 831 /// C type : IUnknown** 832 833 public final Pointer<Pointer<IUnknown>> ppunkVal_$eq(Pointer<Pointer<IUnknown>> ppunkVal) { 834 ppunkVal(ppunkVal); 835 return ppunkVal; 836 } 837 838 /** 839 * VT_BYREF|VT_DISPATCH<br> 840 * C type : IDispatch** 841 */ 842 @Field(28) 843 public Pointer<Pointer<IDispatch>> ppdispVal() { 844 return this.io.getPointerField(this, 28); 845 } 846 847 /** 848 * VT_BYREF|VT_DISPATCH<br> 849 * C type : IDispatch** 850 */ 851 @Field(28) 852 public __VARIANT_NAME_3_union ppdispVal(Pointer<Pointer<IDispatch>> ppdispVal) { 853 this.io.setPointerField(this, 28, ppdispVal); 854 return this; 855 } 856 /// C type : IDispatch** 857 858 public final Pointer<Pointer<IDispatch>> ppdispVal_$eq(Pointer<Pointer<IDispatch>> ppdispVal) { 859 ppdispVal(ppdispVal); 860 return ppdispVal; 861 } 862 863 /** 864 * VT_BYREF|VT_ARRAY<br> 865 * C type : SAFEARRAY** 866 */ 867 @Field(29) 868 public Pointer<Pointer<SAFEARRAY>> pparray() { 869 return this.io.getPointerField(this, 29); 870 } 871 872 /** 873 * VT_BYREF|VT_ARRAY<br> 874 * C type : SAFEARRAY** 875 */ 876 @Field(29) 877 public __VARIANT_NAME_3_union pparray(Pointer<Pointer<SAFEARRAY>> pparray) { 878 this.io.setPointerField(this, 29, pparray); 879 return this; 880 } 881 /// C type : SAFEARRAY** 882 883 public final Pointer<Pointer<SAFEARRAY>> pparray_$eq(Pointer<Pointer<SAFEARRAY>> pparray) { 884 pparray(pparray); 885 return pparray; 886 } 887 888 /** 889 * VT_BYREF|VT_VARIANT<br> 890 * C type : VARIANT* 891 */ 892 @Field(30) 893 public Pointer<VARIANT> pvarVal() { 894 return this.io.getPointerField(this, 30); 895 } 896 897 /** 898 * VT_BYREF|VT_VARIANT<br> 899 * C type : VARIANT* 900 */ 901 @Field(30) 902 public __VARIANT_NAME_3_union pvarVal(Pointer<VARIANT> pvarVal) { 903 this.io.setPointerField(this, 30, pvarVal); 904 return this; 905 } 906 /// C type : VARIANT* 907 908 public final Pointer<VARIANT> pvarVal_$eq(Pointer<VARIANT> pvarVal) { 909 pvarVal(pvarVal); 910 return pvarVal; 911 } 912 913 /** 914 * Generic ByRef<br> 915 * C type : PVOID* 916 */ 917 @Field(31) 918 public Pointer<Pointer<?>> byref() { 919 return this.io.getPointerField(this, 31); 920 } 921 922 /** 923 * Generic ByRef<br> 924 * C type : PVOID* 925 */ 926 @Field(31) 927 public __VARIANT_NAME_3_union byref(Pointer<Pointer<?>> byref) { 928 this.io.setPointerField(this, 31, byref); 929 return this; 930 } 931 /// C type : PVOID* 932 933 public final Pointer<Pointer<?>> byref_$eq(Pointer<Pointer<?>> byref) { 934 byref(byref); 935 return byref; 936 } 937 938 /** 939 * VT_I1<br> 940 * C type : CHAR 941 */ 942 @Field(32) 943 public byte cVal() { 944 return this.io.getByteField(this, 32); 945 } 946 947 /** 948 * VT_I1<br> 949 * C type : CHAR 950 */ 951 @Field(32) 952 public __VARIANT_NAME_3_union cVal(byte cVal) { 953 this.io.setByteField(this, 32, cVal); 954 return this; 955 } 956 /// C type : CHAR 957 958 public final byte cVal_$eq(byte cVal) { 959 cVal(cVal); 960 return cVal; 961 } 962 963 /** 964 * VT_UI2<br> 965 * C type : USHORT 966 */ 967 @Field(33) 968 public short uiVal() { 969 return this.io.getShortField(this, 33); 970 } 971 972 /** 973 * VT_UI2<br> 974 * C type : USHORT 975 */ 976 @Field(33) 977 public __VARIANT_NAME_3_union uiVal(short uiVal) { 978 this.io.setShortField(this, 33, uiVal); 979 return this; 980 } 981 /// C type : USHORT 982 983 public final short uiVal_$eq(short uiVal) { 984 uiVal(uiVal); 985 return uiVal; 986 } 987 988 /** 989 * VT_UI4<br> 990 * C type : ULONG 991 */ 992 @Field(34) 993 public int ulVal() { 994 return this.io.getIntField(this, 34); 995 } 996 997 /** 998 * VT_UI4<br> 999 * C type : ULONG 1000 */ 1001 @Field(34) 1002 public __VARIANT_NAME_3_union ulVal(int ulVal) { 1003 this.io.setIntField(this, 34, ulVal); 1004 return this; 1005 } 1006 /// C type : ULONG 1007 1008 public final int ulVal_$eq(int ulVal) { 1009 ulVal(ulVal); 1010 return ulVal; 1011 } 1012 /// VT_UI8 1013 1014 @Field(35) 1015 public long ullVal() { 1016 return this.io.getLongField(this, 35); 1017 } 1018 /// VT_UI8 1019 1020 @Field(35) 1021 public __VARIANT_NAME_3_union ullVal(long ullVal) { 1022 this.io.setLongField(this, 35, ullVal); 1023 return this; 1024 } 1025 1026 public final long ullVal_$eq(long ullVal) { 1027 ullVal(ullVal); 1028 return ullVal; 1029 } 1030 1031 /** 1032 * VT_INT<br> 1033 * C type : INT 1034 */ 1035 @Field(36) 1036 public int intVal() { 1037 return this.io.getIntField(this, 36); 1038 } 1039 1040 /** 1041 * VT_INT<br> 1042 * C type : INT 1043 */ 1044 @Field(36) 1045 public __VARIANT_NAME_3_union intVal(int intVal) { 1046 this.io.setIntField(this, 36, intVal); 1047 return this; 1048 } 1049 /// C type : INT 1050 1051 public final int intVal_$eq(int intVal) { 1052 intVal(intVal); 1053 return intVal; 1054 } 1055 1056 /** 1057 * VT_UINT<br> 1058 * C type : UINT 1059 */ 1060 @Field(37) 1061 public int uintVal() { 1062 return this.io.getIntField(this, 37); 1063 } 1064 1065 /** 1066 * VT_UINT<br> 1067 * C type : UINT 1068 */ 1069 @Field(37) 1070 public __VARIANT_NAME_3_union uintVal(int uintVal) { 1071 this.io.setIntField(this, 37, uintVal); 1072 return this; 1073 } 1074 /// C type : UINT 1075 1076 public final int uintVal_$eq(int uintVal) { 1077 uintVal(uintVal); 1078 return uintVal; 1079 } 1080 1081 /** 1082 * VT_BYREF|VT_DECIMAL<br> 1083 * C type : DECIMAL* 1084 */ 1085 @Field(38) 1086 public Pointer<DECIMAL> pdecVal() { 1087 return this.io.getPointerField(this, 38); 1088 } 1089 1090 /** 1091 * VT_BYREF|VT_DECIMAL<br> 1092 * C type : DECIMAL* 1093 */ 1094 @Field(38) 1095 public __VARIANT_NAME_3_union pdecVal(Pointer<DECIMAL> pdecVal) { 1096 this.io.setPointerField(this, 38, pdecVal); 1097 return this; 1098 } 1099 /// C type : DECIMAL* 1100 1101 public final Pointer<DECIMAL> pdecVal_$eq(Pointer<DECIMAL> pdecVal) { 1102 pdecVal(pdecVal); 1103 return pdecVal; 1104 } 1105 1106 /** 1107 * VT_BYREF|VT_I1<br> 1108 * C type : CHAR* 1109 */ 1110 @Field(39) 1111 public Pointer<Byte> pcVal() { 1112 return this.io.getPointerField(this, 39); 1113 } 1114 1115 /** 1116 * VT_BYREF|VT_I1<br> 1117 * C type : CHAR* 1118 */ 1119 @Field(39) 1120 public __VARIANT_NAME_3_union pcVal(Pointer<Byte> pcVal) { 1121 this.io.setPointerField(this, 39, pcVal); 1122 return this; 1123 } 1124 /// C type : CHAR* 1125 1126 public final Pointer<Byte> pcVal_$eq(Pointer<Byte> pcVal) { 1127 pcVal(pcVal); 1128 return pcVal; 1129 } 1130 1131 /** 1132 * VT_BYREF|VT_UI2<br> 1133 * C type : USHORT* 1134 */ 1135 @Field(40) 1136 public Pointer<Short> puiVal() { 1137 return this.io.getPointerField(this, 40); 1138 } 1139 1140 /** 1141 * VT_BYREF|VT_UI2<br> 1142 * C type : USHORT* 1143 */ 1144 @Field(40) 1145 public __VARIANT_NAME_3_union puiVal(Pointer<Short> puiVal) { 1146 this.io.setPointerField(this, 40, puiVal); 1147 return this; 1148 } 1149 /// C type : USHORT* 1150 1151 public final Pointer<Short> puiVal_$eq(Pointer<Short> puiVal) { 1152 puiVal(puiVal); 1153 return puiVal; 1154 } 1155 1156 /** 1157 * VT_BYREF|VT_UI4<br> 1158 * C type : ULONG* 1159 */ 1160 @Field(41) 1161 public Pointer<Integer> pulVal() { 1162 return this.io.getPointerField(this, 41); 1163 } 1164 1165 /** 1166 * VT_BYREF|VT_UI4<br> 1167 * C type : ULONG* 1168 */ 1169 @Field(41) 1170 public __VARIANT_NAME_3_union pulVal(Pointer<Integer> pulVal) { 1171 this.io.setPointerField(this, 41, pulVal); 1172 return this; 1173 } 1174 /// C type : ULONG* 1175 1176 public final Pointer<Integer> pulVal_$eq(Pointer<Integer> pulVal) { 1177 pulVal(pulVal); 1178 return pulVal; 1179 } 1180 1181 /** 1182 * VT_BYREF|VT_UI8<br> 1183 * C type : ULONGLONG* 1184 */ 1185 @Field(42) 1186 public Pointer<Long> pullVal() { 1187 return this.io.getPointerField(this, 42); 1188 } 1189 1190 /** 1191 * VT_BYREF|VT_UI8<br> 1192 * C type : ULONGLONG* 1193 */ 1194 @Field(42) 1195 public __VARIANT_NAME_3_union pullVal(Pointer<Long> pullVal) { 1196 this.io.setPointerField(this, 42, pullVal); 1197 return this; 1198 } 1199 /// C type : ULONGLONG* 1200 1201 public final Pointer<Long> pullVal_$eq(Pointer<Long> pullVal) { 1202 pullVal(pullVal); 1203 return pullVal; 1204 } 1205 1206 /** 1207 * VT_BYREF|VT_INT<br> 1208 * C type : INT* 1209 */ 1210 @Field(43) 1211 public Pointer<Integer> pintVal() { 1212 return this.io.getPointerField(this, 43); 1213 } 1214 1215 /** 1216 * VT_BYREF|VT_INT<br> 1217 * C type : INT* 1218 */ 1219 @Field(43) 1220 public __VARIANT_NAME_3_union pintVal(Pointer<Integer> pintVal) { 1221 this.io.setPointerField(this, 43, pintVal); 1222 return this; 1223 } 1224 /// C type : INT* 1225 1226 public final Pointer<Integer> pintVal_$eq(Pointer<Integer> pintVal) { 1227 pintVal(pintVal); 1228 return pintVal; 1229 } 1230 1231 /** 1232 * VT_BYREF|VT_UINT<br> 1233 * C type : UINT* 1234 */ 1235 @Field(44) 1236 public Pointer<Integer> puintVal() { 1237 return this.io.getPointerField(this, 44); 1238 } 1239 1240 /** 1241 * VT_BYREF|VT_UINT<br> 1242 * C type : UINT* 1243 */ 1244 @Field(44) 1245 public __VARIANT_NAME_3_union puintVal(Pointer<Integer> puintVal) { 1246 this.io.setPointerField(this, 44, puintVal); 1247 return this; 1248 } 1249 /// C type : UINT* 1250 1251 public final Pointer<Integer> puintVal_$eq(Pointer<Integer> puintVal) { 1252 puintVal(puintVal); 1253 return puintVal; 1254 } 1255 /// C type : __tagBRECORD 1256 1257 @Field(45) 1258 public VARIANT.__VARIANT_NAME_1_union.__tagVARIANT.__VARIANT_NAME_3_union.__tagBRECORD __VARIANT_NAME_4() { 1259 return this.io.getNativeObjectField(this, 45); 1260 } 1261 /// <i>native declaration : line 162</i> 1262 1263 public static class __tagBRECORD extends StructObject { 1264 1265 public __tagBRECORD() { 1266 super(); 1267 } 1268// public __tagBRECORD(Pointer pointer) { 1269// super(pointer); 1270// } 1271 /// C type : PVOID 1272 1273 @Field(0) 1274 public Pointer<?> pvRecord() { 1275 return this.io.getPointerField(this, 0); 1276 } 1277 /// C type : PVOID 1278 1279 @Field(0) 1280 public __tagBRECORD pvRecord(Pointer<?> pvRecord) { 1281 this.io.setPointerField(this, 0, pvRecord); 1282 return this; 1283 } 1284 /// C type : PVOID 1285 1286 public final Pointer<?> pvRecord_$eq(Pointer<?> pvRecord) { 1287 pvRecord(pvRecord); 1288 return pvRecord; 1289 } 1290 /// C type : IRecordInfo* 1291 1292 @Field(1) 1293 public Pointer<IRecordInfo> pRecInfo() { 1294 return this.io.getPointerField(this, 1); 1295 } 1296 /// C type : IRecordInfo* 1297 1298 @Field(1) 1299 public __tagBRECORD pRecInfo(Pointer<IRecordInfo> pRecInfo) { 1300 this.io.setPointerField(this, 1, pRecInfo); 1301 return this; 1302 } 1303 /// C type : IRecordInfo* 1304 1305 public final Pointer<IRecordInfo> pRecInfo_$eq(Pointer<IRecordInfo> pRecInfo) { 1306 pRecInfo(pRecInfo); 1307 return pRecInfo; 1308 } 1309 }; 1310 }; 1311 }; 1312 }; 1313 1314 public Object getValue() { 1315 return COMRuntime.getValue(this); 1316 } 1317 1318 public VARIANT setValue(Object value) { 1319 return COMRuntime.setValue(this, value); 1320 } 1321 1322 @Override 1323 public String toString() { 1324 return COMRuntime.toString(this); 1325 } 1326}