1 // 2 // gccpdu.h 3 // 4 // Code automatically generated by asnparse. 5 // 6 7 #if ! H323_DISABLE_GCC 8 9 #ifndef __GCC_H 10 #define __GCC_H 11 12 #ifdef P_USE_PRAGMA 13 #pragma interface 14 #endif 15 16 #include <ptclib/asner.h> 17 18 // 19 // ChannelID 20 // 21 22 class GCC_ChannelID : public PASN_Integer 23 { 24 #ifndef PASN_LEANANDMEAN 25 PCLASSINFO(GCC_ChannelID, PASN_Integer); 26 #endif 27 public: 28 GCC_ChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 29 30 GCC_ChannelID & operator=(int v); 31 GCC_ChannelID & operator=(unsigned v); 32 PObject * Clone() const; 33 }; 34 35 36 // 37 // StaticChannelID 38 // 39 40 class GCC_StaticChannelID : public PASN_Integer 41 { 42 #ifndef PASN_LEANANDMEAN 43 PCLASSINFO(GCC_StaticChannelID, PASN_Integer); 44 #endif 45 public: 46 GCC_StaticChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 47 48 GCC_StaticChannelID & operator=(int v); 49 GCC_StaticChannelID & operator=(unsigned v); 50 PObject * Clone() const; 51 }; 52 53 54 // 55 // DynamicChannelID 56 // 57 58 class GCC_DynamicChannelID : public PASN_Integer 59 { 60 #ifndef PASN_LEANANDMEAN 61 PCLASSINFO(GCC_DynamicChannelID, PASN_Integer); 62 #endif 63 public: 64 GCC_DynamicChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 65 66 GCC_DynamicChannelID & operator=(int v); 67 GCC_DynamicChannelID & operator=(unsigned v); 68 PObject * Clone() const; 69 }; 70 71 72 // 73 // UserID 74 // 75 76 class GCC_UserID : public GCC_DynamicChannelID 77 { 78 #ifndef PASN_LEANANDMEAN 79 PCLASSINFO(GCC_UserID, GCC_DynamicChannelID); 80 #endif 81 public: 82 GCC_UserID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 83 84 GCC_UserID & operator=(int v); 85 GCC_UserID & operator=(unsigned v); 86 PObject * Clone() const; 87 }; 88 89 90 // 91 // TokenID 92 // 93 94 class GCC_TokenID : public PASN_Integer 95 { 96 #ifndef PASN_LEANANDMEAN 97 PCLASSINFO(GCC_TokenID, PASN_Integer); 98 #endif 99 public: 100 GCC_TokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 101 102 GCC_TokenID & operator=(int v); 103 GCC_TokenID & operator=(unsigned v); 104 PObject * Clone() const; 105 }; 106 107 108 // 109 // StaticTokenID 110 // 111 112 class GCC_StaticTokenID : public PASN_Integer 113 { 114 #ifndef PASN_LEANANDMEAN 115 PCLASSINFO(GCC_StaticTokenID, PASN_Integer); 116 #endif 117 public: 118 GCC_StaticTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 119 120 GCC_StaticTokenID & operator=(int v); 121 GCC_StaticTokenID & operator=(unsigned v); 122 PObject * Clone() const; 123 }; 124 125 126 // 127 // DynamicTokenID 128 // 129 130 class GCC_DynamicTokenID : public PASN_Integer 131 { 132 #ifndef PASN_LEANANDMEAN 133 PCLASSINFO(GCC_DynamicTokenID, PASN_Integer); 134 #endif 135 public: 136 GCC_DynamicTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 137 138 GCC_DynamicTokenID & operator=(int v); 139 GCC_DynamicTokenID & operator=(unsigned v); 140 PObject * Clone() const; 141 }; 142 143 144 // 145 // Time 146 // 147 148 class GCC_Time : public PASN_Integer 149 { 150 #ifndef PASN_LEANANDMEAN 151 PCLASSINFO(GCC_Time, PASN_Integer); 152 #endif 153 public: 154 GCC_Time(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 155 156 GCC_Time & operator=(int v); 157 GCC_Time & operator=(unsigned v); 158 PObject * Clone() const; 159 }; 160 161 162 // 163 // Handle 164 // 165 166 class GCC_Handle : public PASN_Integer 167 { 168 #ifndef PASN_LEANANDMEAN 169 PCLASSINFO(GCC_Handle, PASN_Integer); 170 #endif 171 public: 172 GCC_Handle(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 173 174 GCC_Handle & operator=(int v); 175 GCC_Handle & operator=(unsigned v); 176 PObject * Clone() const; 177 }; 178 179 180 // 181 // H221NonStandardIdentifier 182 // 183 184 class GCC_H221NonStandardIdentifier : public PASN_OctetString 185 { 186 #ifndef PASN_LEANANDMEAN 187 PCLASSINFO(GCC_H221NonStandardIdentifier, PASN_OctetString); 188 #endif 189 public: 190 GCC_H221NonStandardIdentifier(unsigned tag = UniversalOctetString, TagClass tagClass = UniversalTagClass); 191 192 GCC_H221NonStandardIdentifier(const char * v); 193 GCC_H221NonStandardIdentifier(const PString & v); 194 GCC_H221NonStandardIdentifier(const PBYTEArray & v); 195 196 GCC_H221NonStandardIdentifier & operator=(const char * v); 197 GCC_H221NonStandardIdentifier & operator=(const PString & v); 198 GCC_H221NonStandardIdentifier & operator=(const PBYTEArray & v); 199 PObject * Clone() const; 200 }; 201 202 203 // 204 // Key 205 // 206 207 class GCC_H221NonStandardIdentifier; 208 209 class GCC_Key : public PASN_Choice 210 { 211 #ifndef PASN_LEANANDMEAN 212 PCLASSINFO(GCC_Key, PASN_Choice); 213 #endif 214 public: 215 GCC_Key(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 216 217 enum Choices { 218 e_object, 219 e_h221NonStandard 220 }; 221 222 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 223 operator GCC_H221NonStandardIdentifier &() const; 224 #else 225 operator GCC_H221NonStandardIdentifier &(); 226 operator const GCC_H221NonStandardIdentifier &() const; 227 #endif 228 229 PBoolean CreateObject(); 230 PObject * Clone() const; 231 }; 232 233 234 // 235 // NonStandardParameter 236 // 237 238 class GCC_NonStandardParameter : public PASN_Sequence 239 { 240 #ifndef PASN_LEANANDMEAN 241 PCLASSINFO(GCC_NonStandardParameter, PASN_Sequence); 242 #endif 243 public: 244 GCC_NonStandardParameter(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 245 246 GCC_Key m_key; 247 PASN_OctetString m_data; 248 249 PINDEX GetDataLength() const; 250 PBoolean Decode(PASN_Stream & strm); 251 void Encode(PASN_Stream & strm) const; 252 #ifndef PASN_NOPRINTON 253 void PrintOn(ostream & strm) const; 254 #endif 255 Comparison Compare(const PObject & obj) const; 256 PObject * Clone() const; 257 }; 258 259 260 // 261 // TextString 262 // 263 264 class GCC_TextString : public PASN_BMPString 265 { 266 #ifndef PASN_LEANANDMEAN 267 PCLASSINFO(GCC_TextString, PASN_BMPString); 268 #endif 269 public: 270 GCC_TextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass); 271 272 GCC_TextString & operator=(const char * v); 273 GCC_TextString & operator=(const PString & v); 274 GCC_TextString & operator=(const PWCharArray & v); 275 GCC_TextString & operator=(const PASN_BMPString & v); 276 PObject * Clone() const; 277 }; 278 279 280 // 281 // SimpleTextString 282 // 283 284 class GCC_SimpleTextString : public PASN_BMPString 285 { 286 #ifndef PASN_LEANANDMEAN 287 PCLASSINFO(GCC_SimpleTextString, PASN_BMPString); 288 #endif 289 public: 290 GCC_SimpleTextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass); 291 292 GCC_SimpleTextString & operator=(const char * v); 293 GCC_SimpleTextString & operator=(const PString & v); 294 GCC_SimpleTextString & operator=(const PWCharArray & v); 295 GCC_SimpleTextString & operator=(const PASN_BMPString & v); 296 PObject * Clone() const; 297 }; 298 299 300 // 301 // SimpleNumericString 302 // 303 304 class GCC_SimpleNumericString : public PASN_NumericString 305 { 306 #ifndef PASN_LEANANDMEAN 307 PCLASSINFO(GCC_SimpleNumericString, PASN_NumericString); 308 #endif 309 public: 310 GCC_SimpleNumericString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass); 311 312 GCC_SimpleNumericString & operator=(const char * v); 313 GCC_SimpleNumericString & operator=(const PString & v); 314 PObject * Clone() const; 315 }; 316 317 318 // 319 // DialingString 320 // 321 322 class GCC_DialingString : public PASN_NumericString 323 { 324 #ifndef PASN_LEANANDMEAN 325 PCLASSINFO(GCC_DialingString, PASN_NumericString); 326 #endif 327 public: 328 GCC_DialingString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass); 329 330 GCC_DialingString & operator=(const char * v); 331 GCC_DialingString & operator=(const PString & v); 332 PObject * Clone() const; 333 }; 334 335 336 // 337 // SubAddressString 338 // 339 340 class GCC_SubAddressString : public PASN_NumericString 341 { 342 #ifndef PASN_LEANANDMEAN 343 PCLASSINFO(GCC_SubAddressString, PASN_NumericString); 344 #endif 345 public: 346 GCC_SubAddressString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass); 347 348 GCC_SubAddressString & operator=(const char * v); 349 GCC_SubAddressString & operator=(const PString & v); 350 PObject * Clone() const; 351 }; 352 353 354 // 355 // ExtraDialingString 356 // 357 358 class GCC_ExtraDialingString : public PASN_BMPString 359 { 360 #ifndef PASN_LEANANDMEAN 361 PCLASSINFO(GCC_ExtraDialingString, PASN_BMPString); 362 #endif 363 public: 364 GCC_ExtraDialingString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass); 365 366 GCC_ExtraDialingString & operator=(const char * v); 367 GCC_ExtraDialingString & operator=(const PString & v); 368 GCC_ExtraDialingString & operator=(const PWCharArray & v); 369 GCC_ExtraDialingString & operator=(const PASN_BMPString & v); 370 PObject * Clone() const; 371 }; 372 373 374 // 375 // UserData 376 // 377 378 class GCC_UserData_subtype; 379 380 class GCC_UserData : public PASN_Array 381 { 382 #ifndef PASN_LEANANDMEAN 383 PCLASSINFO(GCC_UserData, PASN_Array); 384 #endif 385 public: 386 GCC_UserData(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 387 388 PASN_Object * CreateObject() const; 389 GCC_UserData_subtype & operator[](PINDEX i) const; 390 PObject * Clone() const; 391 }; 392 393 394 // 395 // Password 396 // 397 398 class GCC_Password : public PASN_Sequence 399 { 400 #ifndef PASN_LEANANDMEAN 401 PCLASSINFO(GCC_Password, PASN_Sequence); 402 #endif 403 public: 404 GCC_Password(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 405 406 enum OptionalFields { 407 e_text 408 }; 409 410 GCC_SimpleNumericString m_numeric; 411 GCC_SimpleTextString m_text; 412 413 PINDEX GetDataLength() const; 414 PBoolean Decode(PASN_Stream & strm); 415 void Encode(PASN_Stream & strm) const; 416 #ifndef PASN_NOPRINTON 417 void PrintOn(ostream & strm) const; 418 #endif 419 Comparison Compare(const PObject & obj) const; 420 PObject * Clone() const; 421 }; 422 423 424 // 425 // PasswordSelector 426 // 427 428 class GCC_SimpleNumericString; 429 class GCC_SimpleTextString; 430 431 class GCC_PasswordSelector : public PASN_Choice 432 { 433 #ifndef PASN_LEANANDMEAN 434 PCLASSINFO(GCC_PasswordSelector, PASN_Choice); 435 #endif 436 public: 437 GCC_PasswordSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 438 439 enum Choices { 440 e_numeric, 441 e_text 442 }; 443 444 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 445 operator GCC_SimpleNumericString &() const; 446 #else 447 operator GCC_SimpleNumericString &(); 448 operator const GCC_SimpleNumericString &() const; 449 #endif 450 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 451 operator GCC_SimpleTextString &() const; 452 #else 453 operator GCC_SimpleTextString &(); 454 operator const GCC_SimpleTextString &() const; 455 #endif 456 457 PBoolean CreateObject(); 458 PObject * Clone() const; 459 }; 460 461 462 // 463 // ChallengeResponseItem 464 // 465 466 class GCC_PasswordSelector; 467 class GCC_UserData; 468 469 class GCC_ChallengeResponseItem : public PASN_Choice 470 { 471 #ifndef PASN_LEANANDMEAN 472 PCLASSINFO(GCC_ChallengeResponseItem, PASN_Choice); 473 #endif 474 public: 475 GCC_ChallengeResponseItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 476 477 enum Choices { 478 e_passwordString, 479 e_responseData 480 }; 481 482 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 483 operator GCC_PasswordSelector &() const; 484 #else 485 operator GCC_PasswordSelector &(); 486 operator const GCC_PasswordSelector &() const; 487 #endif 488 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 489 operator GCC_UserData &() const; 490 #else 491 operator GCC_UserData &(); 492 operator const GCC_UserData &() const; 493 #endif 494 495 PBoolean CreateObject(); 496 PObject * Clone() const; 497 }; 498 499 500 // 501 // ChallengeResponseAlgorithm 502 // 503 504 class GCC_NonStandardParameter; 505 506 class GCC_ChallengeResponseAlgorithm : public PASN_Choice 507 { 508 #ifndef PASN_LEANANDMEAN 509 PCLASSINFO(GCC_ChallengeResponseAlgorithm, PASN_Choice); 510 #endif 511 public: 512 GCC_ChallengeResponseAlgorithm(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 513 514 enum Choices { 515 e_passwordInTheClear, 516 e_nonStandardAlgorithm 517 }; 518 519 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 520 operator GCC_NonStandardParameter &() const; 521 #else 522 operator GCC_NonStandardParameter &(); 523 operator const GCC_NonStandardParameter &() const; 524 #endif 525 526 PBoolean CreateObject(); 527 PObject * Clone() const; 528 }; 529 530 531 // 532 // ChallengeItem 533 // 534 535 class GCC_ChallengeItem : public PASN_Sequence 536 { 537 #ifndef PASN_LEANANDMEAN 538 PCLASSINFO(GCC_ChallengeItem, PASN_Sequence); 539 #endif 540 public: 541 GCC_ChallengeItem(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 542 543 GCC_ChallengeResponseAlgorithm m_responseAlgorithm; 544 GCC_UserData m_challengeData; 545 546 PINDEX GetDataLength() const; 547 PBoolean Decode(PASN_Stream & strm); 548 void Encode(PASN_Stream & strm) const; 549 #ifndef PASN_NOPRINTON 550 void PrintOn(ostream & strm) const; 551 #endif 552 Comparison Compare(const PObject & obj) const; 553 PObject * Clone() const; 554 }; 555 556 557 // 558 // ChallengeResponse 559 // 560 561 class GCC_ChallengeResponse : public PASN_Sequence 562 { 563 #ifndef PASN_LEANANDMEAN 564 PCLASSINFO(GCC_ChallengeResponse, PASN_Sequence); 565 #endif 566 public: 567 GCC_ChallengeResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 568 569 PASN_Integer m_challengeTag; 570 GCC_ChallengeResponseAlgorithm m_responseAlgorithm; 571 GCC_ChallengeResponseItem m_responseItem; 572 573 PINDEX GetDataLength() const; 574 PBoolean Decode(PASN_Stream & strm); 575 void Encode(PASN_Stream & strm) const; 576 #ifndef PASN_NOPRINTON 577 void PrintOn(ostream & strm) const; 578 #endif 579 Comparison Compare(const PObject & obj) const; 580 PObject * Clone() const; 581 }; 582 583 584 // 585 // PasswordChallengeRequestResponse 586 // 587 588 class GCC_PasswordSelector; 589 class GCC_PasswordChallengeRequestResponse_challengeRequestResponse; 590 591 class GCC_PasswordChallengeRequestResponse : public PASN_Choice 592 { 593 #ifndef PASN_LEANANDMEAN 594 PCLASSINFO(GCC_PasswordChallengeRequestResponse, PASN_Choice); 595 #endif 596 public: 597 GCC_PasswordChallengeRequestResponse(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 598 599 enum Choices { 600 e_passwordInTheClear, 601 e_challengeRequestResponse 602 }; 603 604 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 605 operator GCC_PasswordSelector &() const; 606 #else 607 operator GCC_PasswordSelector &(); 608 operator const GCC_PasswordSelector &() const; 609 #endif 610 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 611 operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const; 612 #else 613 operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &(); 614 operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const; 615 #endif 616 617 PBoolean CreateObject(); 618 PObject * Clone() const; 619 }; 620 621 622 // 623 // ConferenceName 624 // 625 626 class GCC_ConferenceName : public PASN_Sequence 627 { 628 #ifndef PASN_LEANANDMEAN 629 PCLASSINFO(GCC_ConferenceName, PASN_Sequence); 630 #endif 631 public: 632 GCC_ConferenceName(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 633 634 enum OptionalFields { 635 e_text 636 }; 637 638 GCC_SimpleNumericString m_numeric; 639 GCC_SimpleTextString m_text; 640 641 PINDEX GetDataLength() const; 642 PBoolean Decode(PASN_Stream & strm); 643 void Encode(PASN_Stream & strm) const; 644 #ifndef PASN_NOPRINTON 645 void PrintOn(ostream & strm) const; 646 #endif 647 Comparison Compare(const PObject & obj) const; 648 PObject * Clone() const; 649 }; 650 651 652 // 653 // ConferenceNameSelector 654 // 655 656 class GCC_SimpleNumericString; 657 class GCC_SimpleTextString; 658 659 class GCC_ConferenceNameSelector : public PASN_Choice 660 { 661 #ifndef PASN_LEANANDMEAN 662 PCLASSINFO(GCC_ConferenceNameSelector, PASN_Choice); 663 #endif 664 public: 665 GCC_ConferenceNameSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 666 667 enum Choices { 668 e_numeric, 669 e_text 670 }; 671 672 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 673 operator GCC_SimpleNumericString &() const; 674 #else 675 operator GCC_SimpleNumericString &(); 676 operator const GCC_SimpleNumericString &() const; 677 #endif 678 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 679 operator GCC_SimpleTextString &() const; 680 #else 681 operator GCC_SimpleTextString &(); 682 operator const GCC_SimpleTextString &() const; 683 #endif 684 685 PBoolean CreateObject(); 686 PObject * Clone() const; 687 }; 688 689 690 // 691 // ConferenceNameModifier 692 // 693 694 class GCC_ConferenceNameModifier : public GCC_SimpleNumericString 695 { 696 #ifndef PASN_LEANANDMEAN 697 PCLASSINFO(GCC_ConferenceNameModifier, GCC_SimpleNumericString); 698 #endif 699 public: 700 GCC_ConferenceNameModifier(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass); 701 702 GCC_ConferenceNameModifier & operator=(const char * v); 703 GCC_ConferenceNameModifier & operator=(const PString & v); 704 PObject * Clone() const; 705 }; 706 707 708 // 709 // Privilege 710 // 711 712 class GCC_Privilege : public PASN_Enumeration 713 { 714 #ifndef PASN_LEANANDMEAN 715 PCLASSINFO(GCC_Privilege, PASN_Enumeration); 716 #endif 717 public: 718 GCC_Privilege(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 719 720 enum Enumerations { 721 e_terminate, 722 e_ejectUser, 723 e_add, 724 e_lockUnlock, 725 e_transfer 726 }; 727 728 GCC_Privilege & operator=(unsigned v); 729 PObject * Clone() const; 730 }; 731 732 733 // 734 // TerminationMethod 735 // 736 737 class GCC_TerminationMethod : public PASN_Enumeration 738 { 739 #ifndef PASN_LEANANDMEAN 740 PCLASSINFO(GCC_TerminationMethod, PASN_Enumeration); 741 #endif 742 public: 743 GCC_TerminationMethod(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 744 745 enum Enumerations { 746 e_automatic, 747 e_manual 748 }; 749 750 GCC_TerminationMethod & operator=(unsigned v); 751 PObject * Clone() const; 752 }; 753 754 755 // 756 // ConferencePriorityScheme 757 // 758 759 class GCC_NonStandardParameter; 760 761 class GCC_ConferencePriorityScheme : public PASN_Choice 762 { 763 #ifndef PASN_LEANANDMEAN 764 PCLASSINFO(GCC_ConferencePriorityScheme, PASN_Choice); 765 #endif 766 public: 767 GCC_ConferencePriorityScheme(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 768 769 enum Choices { 770 e_nonStandardScheme 771 }; 772 773 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 774 operator GCC_NonStandardParameter &() const; 775 #else 776 operator GCC_NonStandardParameter &(); 777 operator const GCC_NonStandardParameter &() const; 778 #endif 779 780 PBoolean CreateObject(); 781 PObject * Clone() const; 782 }; 783 784 785 // 786 // ConferencePriority 787 // 788 789 class GCC_ConferencePriority : public PASN_Sequence 790 { 791 #ifndef PASN_LEANANDMEAN 792 PCLASSINFO(GCC_ConferencePriority, PASN_Sequence); 793 #endif 794 public: 795 GCC_ConferencePriority(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 796 797 PASN_Integer m_priority; 798 GCC_ConferencePriorityScheme m_scheme; 799 800 PINDEX GetDataLength() const; 801 PBoolean Decode(PASN_Stream & strm); 802 void Encode(PASN_Stream & strm) const; 803 #ifndef PASN_NOPRINTON 804 void PrintOn(ostream & strm) const; 805 #endif 806 Comparison Compare(const PObject & obj) const; 807 PObject * Clone() const; 808 }; 809 810 811 // 812 // NetworkAddress 813 // 814 815 class GCC_NetworkAddress_subtype; 816 817 class GCC_NetworkAddress : public PASN_Array 818 { 819 #ifndef PASN_LEANANDMEAN 820 PCLASSINFO(GCC_NetworkAddress, PASN_Array); 821 #endif 822 public: 823 GCC_NetworkAddress(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 824 825 PASN_Object * CreateObject() const; 826 GCC_NetworkAddress_subtype & operator[](PINDEX i) const; 827 PObject * Clone() const; 828 }; 829 830 831 // 832 // NodeType 833 // 834 835 class GCC_NodeType : public PASN_Enumeration 836 { 837 #ifndef PASN_LEANANDMEAN 838 PCLASSINFO(GCC_NodeType, PASN_Enumeration); 839 #endif 840 public: 841 GCC_NodeType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 842 843 enum Enumerations { 844 e_terminal, 845 e_multiportTerminal, 846 e_mcu 847 }; 848 849 GCC_NodeType & operator=(unsigned v); 850 PObject * Clone() const; 851 }; 852 853 854 // 855 // NodeProperties 856 // 857 858 class GCC_NodeProperties : public PASN_Sequence 859 { 860 #ifndef PASN_LEANANDMEAN 861 PCLASSINFO(GCC_NodeProperties, PASN_Sequence); 862 #endif 863 public: 864 GCC_NodeProperties(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 865 866 PASN_Boolean m_managementDevice; 867 PASN_Boolean m_peripheralDevice; 868 869 PINDEX GetDataLength() const; 870 PBoolean Decode(PASN_Stream & strm); 871 void Encode(PASN_Stream & strm) const; 872 #ifndef PASN_NOPRINTON 873 void PrintOn(ostream & strm) const; 874 #endif 875 Comparison Compare(const PObject & obj) const; 876 PObject * Clone() const; 877 }; 878 879 880 // 881 // AsymmetryIndicator 882 // 883 884 class GCC_AsymmetryIndicator : public PASN_Choice 885 { 886 #ifndef PASN_LEANANDMEAN 887 PCLASSINFO(GCC_AsymmetryIndicator, PASN_Choice); 888 #endif 889 public: 890 GCC_AsymmetryIndicator(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 891 892 enum Choices { 893 e_callingNode, 894 e_calledNode, 895 e_unknown 896 }; 897 898 PBoolean CreateObject(); 899 PObject * Clone() const; 900 }; 901 902 903 // 904 // AlternativeNodeID 905 // 906 907 class GCC_AlternativeNodeID : public PASN_Choice 908 { 909 #ifndef PASN_LEANANDMEAN 910 PCLASSINFO(GCC_AlternativeNodeID, PASN_Choice); 911 #endif 912 public: 913 GCC_AlternativeNodeID(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 914 915 enum Choices { 916 e_h243NodeID 917 }; 918 919 PBoolean CreateObject(); 920 PObject * Clone() const; 921 }; 922 923 924 // 925 // ConferenceDescriptor 926 // 927 928 class GCC_ConferenceDescriptor : public PASN_Sequence 929 { 930 #ifndef PASN_LEANANDMEAN 931 PCLASSINFO(GCC_ConferenceDescriptor, PASN_Sequence); 932 #endif 933 public: 934 GCC_ConferenceDescriptor(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 935 936 enum OptionalFields { 937 e_conferenceNameModifier, 938 e_conferenceDescription, 939 e_networkAddress, 940 e_defaultConferenceFlag 941 }; 942 943 GCC_ConferenceName m_conferenceName; 944 GCC_ConferenceNameModifier m_conferenceNameModifier; 945 GCC_TextString m_conferenceDescription; 946 PASN_Boolean m_lockedConference; 947 PASN_Boolean m_passwordInTheClearRequired; 948 GCC_NetworkAddress m_networkAddress; 949 PASN_Boolean m_defaultConferenceFlag; 950 951 PINDEX GetDataLength() const; 952 PBoolean Decode(PASN_Stream & strm); 953 void Encode(PASN_Stream & strm) const; 954 #ifndef PASN_NOPRINTON 955 void PrintOn(ostream & strm) const; 956 #endif 957 Comparison Compare(const PObject & obj) const; 958 PObject * Clone() const; 959 }; 960 961 962 // 963 // SessionKey 964 // 965 966 class GCC_SessionKey : public PASN_Sequence 967 { 968 #ifndef PASN_LEANANDMEAN 969 PCLASSINFO(GCC_SessionKey, PASN_Sequence); 970 #endif 971 public: 972 GCC_SessionKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 973 974 enum OptionalFields { 975 e_sessionID 976 }; 977 978 GCC_Key m_applicationProtocolKey; 979 GCC_ChannelID m_sessionID; 980 981 PINDEX GetDataLength() const; 982 PBoolean Decode(PASN_Stream & strm); 983 void Encode(PASN_Stream & strm) const; 984 #ifndef PASN_NOPRINTON 985 void PrintOn(ostream & strm) const; 986 #endif 987 Comparison Compare(const PObject & obj) const; 988 PObject * Clone() const; 989 }; 990 991 992 // 993 // ChannelType 994 // 995 996 class GCC_ChannelType : public PASN_Enumeration 997 { 998 #ifndef PASN_LEANANDMEAN 999 PCLASSINFO(GCC_ChannelType, PASN_Enumeration); 1000 #endif 1001 public: 1002 GCC_ChannelType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 1003 1004 enum Enumerations { 1005 e_static, 1006 e_dynamicMulticast, 1007 e_dynamicPrivate, 1008 e_dynamicUserId 1009 }; 1010 1011 GCC_ChannelType & operator=(unsigned v); 1012 PObject * Clone() const; 1013 }; 1014 1015 1016 // 1017 // CapabilityID 1018 // 1019 1020 class GCC_Key; 1021 1022 class GCC_CapabilityID : public PASN_Choice 1023 { 1024 #ifndef PASN_LEANANDMEAN 1025 PCLASSINFO(GCC_CapabilityID, PASN_Choice); 1026 #endif 1027 public: 1028 GCC_CapabilityID(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 1029 1030 enum Choices { 1031 e_standard, 1032 e_nonStandard 1033 }; 1034 1035 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1036 operator GCC_Key &() const; 1037 #else 1038 operator GCC_Key &(); 1039 operator const GCC_Key &() const; 1040 #endif 1041 1042 PBoolean CreateObject(); 1043 PObject * Clone() const; 1044 }; 1045 1046 1047 // 1048 // CapabilityClass 1049 // 1050 1051 class GCC_CapabilityClass : public PASN_Choice 1052 { 1053 #ifndef PASN_LEANANDMEAN 1054 PCLASSINFO(GCC_CapabilityClass, PASN_Choice); 1055 #endif 1056 public: 1057 GCC_CapabilityClass(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 1058 1059 enum Choices { 1060 e_logical, 1061 e_unsignedMin, 1062 e_unsignedMax 1063 }; 1064 1065 PBoolean CreateObject(); 1066 PObject * Clone() const; 1067 }; 1068 1069 1070 // 1071 // EntityID 1072 // 1073 1074 class GCC_EntityID : public PASN_Integer 1075 { 1076 #ifndef PASN_LEANANDMEAN 1077 PCLASSINFO(GCC_EntityID, PASN_Integer); 1078 #endif 1079 public: 1080 GCC_EntityID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass); 1081 1082 GCC_EntityID & operator=(int v); 1083 GCC_EntityID & operator=(unsigned v); 1084 PObject * Clone() const; 1085 }; 1086 1087 1088 // 1089 // RegistryKey 1090 // 1091 1092 class GCC_RegistryKey : public PASN_Sequence 1093 { 1094 #ifndef PASN_LEANANDMEAN 1095 PCLASSINFO(GCC_RegistryKey, PASN_Sequence); 1096 #endif 1097 public: 1098 GCC_RegistryKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1099 1100 GCC_SessionKey m_sessionKey; 1101 PASN_OctetString m_resourceID; 1102 1103 PINDEX GetDataLength() const; 1104 PBoolean Decode(PASN_Stream & strm); 1105 void Encode(PASN_Stream & strm) const; 1106 #ifndef PASN_NOPRINTON 1107 void PrintOn(ostream & strm) const; 1108 #endif 1109 Comparison Compare(const PObject & obj) const; 1110 PObject * Clone() const; 1111 }; 1112 1113 1114 // 1115 // RegistryItem 1116 // 1117 1118 class GCC_DynamicChannelID; 1119 class GCC_DynamicTokenID; 1120 1121 class GCC_RegistryItem : public PASN_Choice 1122 { 1123 #ifndef PASN_LEANANDMEAN 1124 PCLASSINFO(GCC_RegistryItem, PASN_Choice); 1125 #endif 1126 public: 1127 GCC_RegistryItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 1128 1129 enum Choices { 1130 e_channelID, 1131 e_tokenID, 1132 e_parameter, 1133 e_vacant 1134 }; 1135 1136 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1137 operator GCC_DynamicChannelID &() const; 1138 #else 1139 operator GCC_DynamicChannelID &(); 1140 operator const GCC_DynamicChannelID &() const; 1141 #endif 1142 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1143 operator GCC_DynamicTokenID &() const; 1144 #else 1145 operator GCC_DynamicTokenID &(); 1146 operator const GCC_DynamicTokenID &() const; 1147 #endif 1148 1149 PBoolean CreateObject(); 1150 PObject * Clone() const; 1151 }; 1152 1153 1154 // 1155 // RegistryEntryOwner 1156 // 1157 1158 class GCC_RegistryEntryOwner_owned; 1159 1160 class GCC_RegistryEntryOwner : public PASN_Choice 1161 { 1162 #ifndef PASN_LEANANDMEAN 1163 PCLASSINFO(GCC_RegistryEntryOwner, PASN_Choice); 1164 #endif 1165 public: 1166 GCC_RegistryEntryOwner(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 1167 1168 enum Choices { 1169 e_owned, 1170 e_notOwned 1171 }; 1172 1173 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1174 operator GCC_RegistryEntryOwner_owned &() const; 1175 #else 1176 operator GCC_RegistryEntryOwner_owned &(); 1177 operator const GCC_RegistryEntryOwner_owned &() const; 1178 #endif 1179 1180 PBoolean CreateObject(); 1181 PObject * Clone() const; 1182 }; 1183 1184 1185 // 1186 // RegistryModificationRights 1187 // 1188 1189 class GCC_RegistryModificationRights : public PASN_Enumeration 1190 { 1191 #ifndef PASN_LEANANDMEAN 1192 PCLASSINFO(GCC_RegistryModificationRights, PASN_Enumeration); 1193 #endif 1194 public: 1195 GCC_RegistryModificationRights(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 1196 1197 enum Enumerations { 1198 e_owner, 1199 e_session, 1200 e_public 1201 }; 1202 1203 GCC_RegistryModificationRights & operator=(unsigned v); 1204 PObject * Clone() const; 1205 }; 1206 1207 1208 // 1209 // UserIDIndication 1210 // 1211 1212 class GCC_UserIDIndication : public PASN_Sequence 1213 { 1214 #ifndef PASN_LEANANDMEAN 1215 PCLASSINFO(GCC_UserIDIndication, PASN_Sequence); 1216 #endif 1217 public: 1218 GCC_UserIDIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1219 1220 PASN_Integer m_tag; 1221 1222 PINDEX GetDataLength() const; 1223 PBoolean Decode(PASN_Stream & strm); 1224 void Encode(PASN_Stream & strm) const; 1225 #ifndef PASN_NOPRINTON 1226 void PrintOn(ostream & strm) const; 1227 #endif 1228 Comparison Compare(const PObject & obj) const; 1229 PObject * Clone() const; 1230 }; 1231 1232 1233 // 1234 // ConferenceQueryRequest 1235 // 1236 1237 class GCC_ConferenceQueryRequest : public PASN_Sequence 1238 { 1239 #ifndef PASN_LEANANDMEAN 1240 PCLASSINFO(GCC_ConferenceQueryRequest, PASN_Sequence); 1241 #endif 1242 public: 1243 GCC_ConferenceQueryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1244 1245 enum OptionalFields { 1246 e_asymmetryIndicator, 1247 e_userData 1248 }; 1249 1250 GCC_NodeType m_nodeType; 1251 GCC_AsymmetryIndicator m_asymmetryIndicator; 1252 GCC_UserData m_userData; 1253 1254 PINDEX GetDataLength() const; 1255 PBoolean Decode(PASN_Stream & strm); 1256 void Encode(PASN_Stream & strm) const; 1257 #ifndef PASN_NOPRINTON 1258 void PrintOn(ostream & strm) const; 1259 #endif 1260 Comparison Compare(const PObject & obj) const; 1261 PObject * Clone() const; 1262 }; 1263 1264 1265 // 1266 // ConferenceJoinRequest 1267 // 1268 1269 class GCC_ConferenceJoinRequest : public PASN_Sequence 1270 { 1271 #ifndef PASN_LEANANDMEAN 1272 PCLASSINFO(GCC_ConferenceJoinRequest, PASN_Sequence); 1273 #endif 1274 public: 1275 GCC_ConferenceJoinRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1276 1277 enum OptionalFields { 1278 e_conferenceName, 1279 e_conferenceNameModifier, 1280 e_tag, 1281 e_password, 1282 e_convenerPassword, 1283 e_callerIdentifier, 1284 e_userData 1285 }; 1286 1287 GCC_ConferenceNameSelector m_conferenceName; 1288 GCC_ConferenceNameModifier m_conferenceNameModifier; 1289 PASN_Integer m_tag; 1290 GCC_PasswordChallengeRequestResponse m_password; 1291 GCC_PasswordSelector m_convenerPassword; 1292 GCC_TextString m_callerIdentifier; 1293 GCC_UserData m_userData; 1294 1295 PINDEX GetDataLength() const; 1296 PBoolean Decode(PASN_Stream & strm); 1297 void Encode(PASN_Stream & strm) const; 1298 #ifndef PASN_NOPRINTON 1299 void PrintOn(ostream & strm) const; 1300 #endif 1301 Comparison Compare(const PObject & obj) const; 1302 PObject * Clone() const; 1303 }; 1304 1305 1306 // 1307 // ConferenceAddRequest 1308 // 1309 1310 class GCC_ConferenceAddRequest : public PASN_Sequence 1311 { 1312 #ifndef PASN_LEANANDMEAN 1313 PCLASSINFO(GCC_ConferenceAddRequest, PASN_Sequence); 1314 #endif 1315 public: 1316 GCC_ConferenceAddRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1317 1318 enum OptionalFields { 1319 e_addingMCU, 1320 e_userData 1321 }; 1322 1323 GCC_NetworkAddress m_networkAddress; 1324 GCC_UserID m_requestingNode; 1325 PASN_Integer m_tag; 1326 GCC_UserID m_addingMCU; 1327 GCC_UserData m_userData; 1328 1329 PINDEX GetDataLength() const; 1330 PBoolean Decode(PASN_Stream & strm); 1331 void Encode(PASN_Stream & strm) const; 1332 #ifndef PASN_NOPRINTON 1333 void PrintOn(ostream & strm) const; 1334 #endif 1335 Comparison Compare(const PObject & obj) const; 1336 PObject * Clone() const; 1337 }; 1338 1339 1340 // 1341 // ConferenceLockRequest 1342 // 1343 1344 class GCC_ConferenceLockRequest : public PASN_Sequence 1345 { 1346 #ifndef PASN_LEANANDMEAN 1347 PCLASSINFO(GCC_ConferenceLockRequest, PASN_Sequence); 1348 #endif 1349 public: 1350 GCC_ConferenceLockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1351 1352 1353 PINDEX GetDataLength() const; 1354 PBoolean Decode(PASN_Stream & strm); 1355 void Encode(PASN_Stream & strm) const; 1356 #ifndef PASN_NOPRINTON 1357 void PrintOn(ostream & strm) const; 1358 #endif 1359 PObject * Clone() const; 1360 }; 1361 1362 1363 // 1364 // ConferenceLockIndication 1365 // 1366 1367 class GCC_ConferenceLockIndication : public PASN_Sequence 1368 { 1369 #ifndef PASN_LEANANDMEAN 1370 PCLASSINFO(GCC_ConferenceLockIndication, PASN_Sequence); 1371 #endif 1372 public: 1373 GCC_ConferenceLockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1374 1375 1376 PINDEX GetDataLength() const; 1377 PBoolean Decode(PASN_Stream & strm); 1378 void Encode(PASN_Stream & strm) const; 1379 #ifndef PASN_NOPRINTON 1380 void PrintOn(ostream & strm) const; 1381 #endif 1382 PObject * Clone() const; 1383 }; 1384 1385 1386 // 1387 // ConferenceUnlockRequest 1388 // 1389 1390 class GCC_ConferenceUnlockRequest : public PASN_Sequence 1391 { 1392 #ifndef PASN_LEANANDMEAN 1393 PCLASSINFO(GCC_ConferenceUnlockRequest, PASN_Sequence); 1394 #endif 1395 public: 1396 GCC_ConferenceUnlockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1397 1398 1399 PINDEX GetDataLength() const; 1400 PBoolean Decode(PASN_Stream & strm); 1401 void Encode(PASN_Stream & strm) const; 1402 #ifndef PASN_NOPRINTON 1403 void PrintOn(ostream & strm) const; 1404 #endif 1405 PObject * Clone() const; 1406 }; 1407 1408 1409 // 1410 // ConferenceUnlockIndication 1411 // 1412 1413 class GCC_ConferenceUnlockIndication : public PASN_Sequence 1414 { 1415 #ifndef PASN_LEANANDMEAN 1416 PCLASSINFO(GCC_ConferenceUnlockIndication, PASN_Sequence); 1417 #endif 1418 public: 1419 GCC_ConferenceUnlockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1420 1421 1422 PINDEX GetDataLength() const; 1423 PBoolean Decode(PASN_Stream & strm); 1424 void Encode(PASN_Stream & strm) const; 1425 #ifndef PASN_NOPRINTON 1426 void PrintOn(ostream & strm) const; 1427 #endif 1428 PObject * Clone() const; 1429 }; 1430 1431 1432 // 1433 // RegistryRegisterChannelRequest 1434 // 1435 1436 class GCC_RegistryRegisterChannelRequest : public PASN_Sequence 1437 { 1438 #ifndef PASN_LEANANDMEAN 1439 PCLASSINFO(GCC_RegistryRegisterChannelRequest, PASN_Sequence); 1440 #endif 1441 public: 1442 GCC_RegistryRegisterChannelRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1443 1444 GCC_EntityID m_entityID; 1445 GCC_RegistryKey m_key; 1446 GCC_DynamicChannelID m_channelID; 1447 1448 PINDEX GetDataLength() const; 1449 PBoolean Decode(PASN_Stream & strm); 1450 void Encode(PASN_Stream & strm) const; 1451 #ifndef PASN_NOPRINTON 1452 void PrintOn(ostream & strm) const; 1453 #endif 1454 Comparison Compare(const PObject & obj) const; 1455 PObject * Clone() const; 1456 }; 1457 1458 1459 // 1460 // RegistryAssignTokenRequest 1461 // 1462 1463 class GCC_RegistryAssignTokenRequest : public PASN_Sequence 1464 { 1465 #ifndef PASN_LEANANDMEAN 1466 PCLASSINFO(GCC_RegistryAssignTokenRequest, PASN_Sequence); 1467 #endif 1468 public: 1469 GCC_RegistryAssignTokenRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1470 1471 GCC_EntityID m_entityID; 1472 GCC_RegistryKey m_key; 1473 1474 PINDEX GetDataLength() const; 1475 PBoolean Decode(PASN_Stream & strm); 1476 void Encode(PASN_Stream & strm) const; 1477 #ifndef PASN_NOPRINTON 1478 void PrintOn(ostream & strm) const; 1479 #endif 1480 Comparison Compare(const PObject & obj) const; 1481 PObject * Clone() const; 1482 }; 1483 1484 1485 // 1486 // RegistrySetParameterRequest 1487 // 1488 1489 class GCC_RegistrySetParameterRequest : public PASN_Sequence 1490 { 1491 #ifndef PASN_LEANANDMEAN 1492 PCLASSINFO(GCC_RegistrySetParameterRequest, PASN_Sequence); 1493 #endif 1494 public: 1495 GCC_RegistrySetParameterRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1496 1497 enum OptionalFields { 1498 e_modificationRights 1499 }; 1500 1501 GCC_EntityID m_entityID; 1502 GCC_RegistryKey m_key; 1503 PASN_OctetString m_parameter; 1504 GCC_RegistryModificationRights m_modificationRights; 1505 1506 PINDEX GetDataLength() const; 1507 PBoolean Decode(PASN_Stream & strm); 1508 void Encode(PASN_Stream & strm) const; 1509 #ifndef PASN_NOPRINTON 1510 void PrintOn(ostream & strm) const; 1511 #endif 1512 Comparison Compare(const PObject & obj) const; 1513 PObject * Clone() const; 1514 }; 1515 1516 1517 // 1518 // RegistryRetrieveEntryRequest 1519 // 1520 1521 class GCC_RegistryRetrieveEntryRequest : public PASN_Sequence 1522 { 1523 #ifndef PASN_LEANANDMEAN 1524 PCLASSINFO(GCC_RegistryRetrieveEntryRequest, PASN_Sequence); 1525 #endif 1526 public: 1527 GCC_RegistryRetrieveEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1528 1529 GCC_EntityID m_entityID; 1530 GCC_RegistryKey m_key; 1531 1532 PINDEX GetDataLength() const; 1533 PBoolean Decode(PASN_Stream & strm); 1534 void Encode(PASN_Stream & strm) const; 1535 #ifndef PASN_NOPRINTON 1536 void PrintOn(ostream & strm) const; 1537 #endif 1538 Comparison Compare(const PObject & obj) const; 1539 PObject * Clone() const; 1540 }; 1541 1542 1543 // 1544 // RegistryDeleteEntryRequest 1545 // 1546 1547 class GCC_RegistryDeleteEntryRequest : public PASN_Sequence 1548 { 1549 #ifndef PASN_LEANANDMEAN 1550 PCLASSINFO(GCC_RegistryDeleteEntryRequest, PASN_Sequence); 1551 #endif 1552 public: 1553 GCC_RegistryDeleteEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1554 1555 GCC_EntityID m_entityID; 1556 GCC_RegistryKey m_key; 1557 1558 PINDEX GetDataLength() const; 1559 PBoolean Decode(PASN_Stream & strm); 1560 void Encode(PASN_Stream & strm) const; 1561 #ifndef PASN_NOPRINTON 1562 void PrintOn(ostream & strm) const; 1563 #endif 1564 Comparison Compare(const PObject & obj) const; 1565 PObject * Clone() const; 1566 }; 1567 1568 1569 // 1570 // RegistryMonitorEntryRequest 1571 // 1572 1573 class GCC_RegistryMonitorEntryRequest : public PASN_Sequence 1574 { 1575 #ifndef PASN_LEANANDMEAN 1576 PCLASSINFO(GCC_RegistryMonitorEntryRequest, PASN_Sequence); 1577 #endif 1578 public: 1579 GCC_RegistryMonitorEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1580 1581 GCC_EntityID m_entityID; 1582 GCC_RegistryKey m_key; 1583 1584 PINDEX GetDataLength() const; 1585 PBoolean Decode(PASN_Stream & strm); 1586 void Encode(PASN_Stream & strm) const; 1587 #ifndef PASN_NOPRINTON 1588 void PrintOn(ostream & strm) const; 1589 #endif 1590 Comparison Compare(const PObject & obj) const; 1591 PObject * Clone() const; 1592 }; 1593 1594 1595 // 1596 // RegistryMonitorEntryIndication 1597 // 1598 1599 class GCC_RegistryMonitorEntryIndication : public PASN_Sequence 1600 { 1601 #ifndef PASN_LEANANDMEAN 1602 PCLASSINFO(GCC_RegistryMonitorEntryIndication, PASN_Sequence); 1603 #endif 1604 public: 1605 GCC_RegistryMonitorEntryIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1606 1607 enum OptionalFields { 1608 e_modificationRights 1609 }; 1610 1611 GCC_RegistryKey m_key; 1612 GCC_RegistryItem m_item; 1613 GCC_RegistryEntryOwner m_owner; 1614 GCC_RegistryModificationRights m_modificationRights; 1615 1616 PINDEX GetDataLength() const; 1617 PBoolean Decode(PASN_Stream & strm); 1618 void Encode(PASN_Stream & strm) const; 1619 #ifndef PASN_NOPRINTON 1620 void PrintOn(ostream & strm) const; 1621 #endif 1622 Comparison Compare(const PObject & obj) const; 1623 PObject * Clone() const; 1624 }; 1625 1626 1627 // 1628 // RegistryAllocateHandleRequest 1629 // 1630 1631 class GCC_RegistryAllocateHandleRequest : public PASN_Sequence 1632 { 1633 #ifndef PASN_LEANANDMEAN 1634 PCLASSINFO(GCC_RegistryAllocateHandleRequest, PASN_Sequence); 1635 #endif 1636 public: 1637 GCC_RegistryAllocateHandleRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1638 1639 GCC_EntityID m_entityID; 1640 PASN_Integer m_numberOfHandles; 1641 1642 PINDEX GetDataLength() const; 1643 PBoolean Decode(PASN_Stream & strm); 1644 void Encode(PASN_Stream & strm) const; 1645 #ifndef PASN_NOPRINTON 1646 void PrintOn(ostream & strm) const; 1647 #endif 1648 Comparison Compare(const PObject & obj) const; 1649 PObject * Clone() const; 1650 }; 1651 1652 1653 // 1654 // ConductorAssignIndication 1655 // 1656 1657 class GCC_ConductorAssignIndication : public PASN_Sequence 1658 { 1659 #ifndef PASN_LEANANDMEAN 1660 PCLASSINFO(GCC_ConductorAssignIndication, PASN_Sequence); 1661 #endif 1662 public: 1663 GCC_ConductorAssignIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1664 1665 GCC_UserID m_conductingNode; 1666 1667 PINDEX GetDataLength() const; 1668 PBoolean Decode(PASN_Stream & strm); 1669 void Encode(PASN_Stream & strm) const; 1670 #ifndef PASN_NOPRINTON 1671 void PrintOn(ostream & strm) const; 1672 #endif 1673 Comparison Compare(const PObject & obj) const; 1674 PObject * Clone() const; 1675 }; 1676 1677 1678 // 1679 // ConductorReleaseIndication 1680 // 1681 1682 class GCC_ConductorReleaseIndication : public PASN_Sequence 1683 { 1684 #ifndef PASN_LEANANDMEAN 1685 PCLASSINFO(GCC_ConductorReleaseIndication, PASN_Sequence); 1686 #endif 1687 public: 1688 GCC_ConductorReleaseIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1689 1690 1691 PINDEX GetDataLength() const; 1692 PBoolean Decode(PASN_Stream & strm); 1693 void Encode(PASN_Stream & strm) const; 1694 #ifndef PASN_NOPRINTON 1695 void PrintOn(ostream & strm) const; 1696 #endif 1697 PObject * Clone() const; 1698 }; 1699 1700 1701 // 1702 // ConductorPermissionAskIndication 1703 // 1704 1705 class GCC_ConductorPermissionAskIndication : public PASN_Sequence 1706 { 1707 #ifndef PASN_LEANANDMEAN 1708 PCLASSINFO(GCC_ConductorPermissionAskIndication, PASN_Sequence); 1709 #endif 1710 public: 1711 GCC_ConductorPermissionAskIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1712 1713 PASN_Boolean m_grantFlag; 1714 1715 PINDEX GetDataLength() const; 1716 PBoolean Decode(PASN_Stream & strm); 1717 void Encode(PASN_Stream & strm) const; 1718 #ifndef PASN_NOPRINTON 1719 void PrintOn(ostream & strm) const; 1720 #endif 1721 Comparison Compare(const PObject & obj) const; 1722 PObject * Clone() const; 1723 }; 1724 1725 1726 // 1727 // ConferenceTimeRemainingIndication 1728 // 1729 1730 class GCC_ConferenceTimeRemainingIndication : public PASN_Sequence 1731 { 1732 #ifndef PASN_LEANANDMEAN 1733 PCLASSINFO(GCC_ConferenceTimeRemainingIndication, PASN_Sequence); 1734 #endif 1735 public: 1736 GCC_ConferenceTimeRemainingIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1737 1738 enum OptionalFields { 1739 e_nodeID 1740 }; 1741 1742 GCC_Time m_timeRemaining; 1743 GCC_UserID m_nodeID; 1744 1745 PINDEX GetDataLength() const; 1746 PBoolean Decode(PASN_Stream & strm); 1747 void Encode(PASN_Stream & strm) const; 1748 #ifndef PASN_NOPRINTON 1749 void PrintOn(ostream & strm) const; 1750 #endif 1751 Comparison Compare(const PObject & obj) const; 1752 PObject * Clone() const; 1753 }; 1754 1755 1756 // 1757 // ConferenceTimeInquireIndication 1758 // 1759 1760 class GCC_ConferenceTimeInquireIndication : public PASN_Sequence 1761 { 1762 #ifndef PASN_LEANANDMEAN 1763 PCLASSINFO(GCC_ConferenceTimeInquireIndication, PASN_Sequence); 1764 #endif 1765 public: 1766 GCC_ConferenceTimeInquireIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1767 1768 PASN_Boolean m_nodeSpecificTimeFlag; 1769 1770 PINDEX GetDataLength() const; 1771 PBoolean Decode(PASN_Stream & strm); 1772 void Encode(PASN_Stream & strm) const; 1773 #ifndef PASN_NOPRINTON 1774 void PrintOn(ostream & strm) const; 1775 #endif 1776 Comparison Compare(const PObject & obj) const; 1777 PObject * Clone() const; 1778 }; 1779 1780 1781 // 1782 // ConferenceTimeExtendIndication 1783 // 1784 1785 class GCC_ConferenceTimeExtendIndication : public PASN_Sequence 1786 { 1787 #ifndef PASN_LEANANDMEAN 1788 PCLASSINFO(GCC_ConferenceTimeExtendIndication, PASN_Sequence); 1789 #endif 1790 public: 1791 GCC_ConferenceTimeExtendIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1792 1793 GCC_Time m_timeToExtend; 1794 PASN_Boolean m_nodeSpecificTimeFlag; 1795 1796 PINDEX GetDataLength() const; 1797 PBoolean Decode(PASN_Stream & strm); 1798 void Encode(PASN_Stream & strm) const; 1799 #ifndef PASN_NOPRINTON 1800 void PrintOn(ostream & strm) const; 1801 #endif 1802 Comparison Compare(const PObject & obj) const; 1803 PObject * Clone() const; 1804 }; 1805 1806 1807 // 1808 // ConferenceAssistanceIndication 1809 // 1810 1811 class GCC_ConferenceAssistanceIndication : public PASN_Sequence 1812 { 1813 #ifndef PASN_LEANANDMEAN 1814 PCLASSINFO(GCC_ConferenceAssistanceIndication, PASN_Sequence); 1815 #endif 1816 public: 1817 GCC_ConferenceAssistanceIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1818 1819 enum OptionalFields { 1820 e_userData 1821 }; 1822 1823 GCC_UserData m_userData; 1824 1825 PINDEX GetDataLength() const; 1826 PBoolean Decode(PASN_Stream & strm); 1827 void Encode(PASN_Stream & strm) const; 1828 #ifndef PASN_NOPRINTON 1829 void PrintOn(ostream & strm) const; 1830 #endif 1831 Comparison Compare(const PObject & obj) const; 1832 PObject * Clone() const; 1833 }; 1834 1835 1836 // 1837 // TextMessageIndication 1838 // 1839 1840 class GCC_TextMessageIndication : public PASN_Sequence 1841 { 1842 #ifndef PASN_LEANANDMEAN 1843 PCLASSINFO(GCC_TextMessageIndication, PASN_Sequence); 1844 #endif 1845 public: 1846 GCC_TextMessageIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1847 1848 GCC_TextString m_message; 1849 1850 PINDEX GetDataLength() const; 1851 PBoolean Decode(PASN_Stream & strm); 1852 void Encode(PASN_Stream & strm) const; 1853 #ifndef PASN_NOPRINTON 1854 void PrintOn(ostream & strm) const; 1855 #endif 1856 Comparison Compare(const PObject & obj) const; 1857 PObject * Clone() const; 1858 }; 1859 1860 1861 // 1862 // NonStandardPDU 1863 // 1864 1865 class GCC_NonStandardPDU : public PASN_Sequence 1866 { 1867 #ifndef PASN_LEANANDMEAN 1868 PCLASSINFO(GCC_NonStandardPDU, PASN_Sequence); 1869 #endif 1870 public: 1871 GCC_NonStandardPDU(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1872 1873 GCC_NonStandardParameter m_data; 1874 1875 PINDEX GetDataLength() const; 1876 PBoolean Decode(PASN_Stream & strm); 1877 void Encode(PASN_Stream & strm) const; 1878 #ifndef PASN_NOPRINTON 1879 void PrintOn(ostream & strm) const; 1880 #endif 1881 Comparison Compare(const PObject & obj) const; 1882 PObject * Clone() const; 1883 }; 1884 1885 1886 // 1887 // ConnectData 1888 // 1889 1890 class GCC_ConnectData : public PASN_Sequence 1891 { 1892 #ifndef PASN_LEANANDMEAN 1893 PCLASSINFO(GCC_ConnectData, PASN_Sequence); 1894 #endif 1895 public: 1896 GCC_ConnectData(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 1897 1898 GCC_Key m_t124Identifier; 1899 PASN_OctetString m_connectPDU; 1900 1901 PINDEX GetDataLength() const; 1902 PBoolean Decode(PASN_Stream & strm); 1903 void Encode(PASN_Stream & strm) const; 1904 #ifndef PASN_NOPRINTON 1905 void PrintOn(ostream & strm) const; 1906 #endif 1907 Comparison Compare(const PObject & obj) const; 1908 PObject * Clone() const; 1909 }; 1910 1911 1912 // 1913 // ConnectGCCPDU 1914 // 1915 1916 class GCC_ConferenceCreateRequest; 1917 class GCC_ConferenceCreateResponse; 1918 class GCC_ConferenceQueryRequest; 1919 class GCC_ConferenceQueryResponse; 1920 class GCC_ConferenceJoinRequest; 1921 class GCC_ConferenceJoinResponse; 1922 class GCC_ConferenceInviteRequest; 1923 class GCC_ConferenceInviteResponse; 1924 1925 class GCC_ConnectGCCPDU : public PASN_Choice 1926 { 1927 #ifndef PASN_LEANANDMEAN 1928 PCLASSINFO(GCC_ConnectGCCPDU, PASN_Choice); 1929 #endif 1930 public: 1931 GCC_ConnectGCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 1932 1933 enum Choices { 1934 e_conferenceCreateRequest, 1935 e_conferenceCreateResponse, 1936 e_conferenceQueryRequest, 1937 e_conferenceQueryResponse, 1938 e_conferenceJoinRequest, 1939 e_conferenceJoinResponse, 1940 e_conferenceInviteRequest, 1941 e_conferenceInviteResponse 1942 }; 1943 1944 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1945 operator GCC_ConferenceCreateRequest &() const; 1946 #else 1947 operator GCC_ConferenceCreateRequest &(); 1948 operator const GCC_ConferenceCreateRequest &() const; 1949 #endif 1950 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1951 operator GCC_ConferenceCreateResponse &() const; 1952 #else 1953 operator GCC_ConferenceCreateResponse &(); 1954 operator const GCC_ConferenceCreateResponse &() const; 1955 #endif 1956 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1957 operator GCC_ConferenceQueryRequest &() const; 1958 #else 1959 operator GCC_ConferenceQueryRequest &(); 1960 operator const GCC_ConferenceQueryRequest &() const; 1961 #endif 1962 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1963 operator GCC_ConferenceQueryResponse &() const; 1964 #else 1965 operator GCC_ConferenceQueryResponse &(); 1966 operator const GCC_ConferenceQueryResponse &() const; 1967 #endif 1968 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1969 operator GCC_ConferenceJoinRequest &() const; 1970 #else 1971 operator GCC_ConferenceJoinRequest &(); 1972 operator const GCC_ConferenceJoinRequest &() const; 1973 #endif 1974 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1975 operator GCC_ConferenceJoinResponse &() const; 1976 #else 1977 operator GCC_ConferenceJoinResponse &(); 1978 operator const GCC_ConferenceJoinResponse &() const; 1979 #endif 1980 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1981 operator GCC_ConferenceInviteRequest &() const; 1982 #else 1983 operator GCC_ConferenceInviteRequest &(); 1984 operator const GCC_ConferenceInviteRequest &() const; 1985 #endif 1986 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 1987 operator GCC_ConferenceInviteResponse &() const; 1988 #else 1989 operator GCC_ConferenceInviteResponse &(); 1990 operator const GCC_ConferenceInviteResponse &() const; 1991 #endif 1992 1993 PBoolean CreateObject(); 1994 PObject * Clone() const; 1995 }; 1996 1997 1998 // 1999 // GCCPDU 2000 // 2001 2002 class GCC_RequestPDU; 2003 class GCC_ResponsePDU; 2004 class GCC_IndicationPDU; 2005 2006 class GCC_GCCPDU : public PASN_Choice 2007 { 2008 #ifndef PASN_LEANANDMEAN 2009 PCLASSINFO(GCC_GCCPDU, PASN_Choice); 2010 #endif 2011 public: 2012 GCC_GCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 2013 2014 enum Choices { 2015 e_request, 2016 e_response, 2017 e_indication 2018 }; 2019 2020 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2021 operator GCC_RequestPDU &() const; 2022 #else 2023 operator GCC_RequestPDU &(); 2024 operator const GCC_RequestPDU &() const; 2025 #endif 2026 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2027 operator GCC_ResponsePDU &() const; 2028 #else 2029 operator GCC_ResponsePDU &(); 2030 operator const GCC_ResponsePDU &() const; 2031 #endif 2032 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2033 operator GCC_IndicationPDU &() const; 2034 #else 2035 operator GCC_IndicationPDU &(); 2036 operator const GCC_IndicationPDU &() const; 2037 #endif 2038 2039 PBoolean CreateObject(); 2040 PObject * Clone() const; 2041 }; 2042 2043 2044 // 2045 // RequestPDU 2046 // 2047 2048 class GCC_ConferenceJoinRequest; 2049 class GCC_ConferenceAddRequest; 2050 class GCC_ConferenceLockRequest; 2051 class GCC_ConferenceUnlockRequest; 2052 class GCC_ConferenceTerminateRequest; 2053 class GCC_ConferenceEjectUserRequest; 2054 class GCC_ConferenceTransferRequest; 2055 class GCC_RegistryRegisterChannelRequest; 2056 class GCC_RegistryAssignTokenRequest; 2057 class GCC_RegistrySetParameterRequest; 2058 class GCC_RegistryRetrieveEntryRequest; 2059 class GCC_RegistryDeleteEntryRequest; 2060 class GCC_RegistryMonitorEntryRequest; 2061 class GCC_RegistryAllocateHandleRequest; 2062 class GCC_NonStandardPDU; 2063 2064 class GCC_RequestPDU : public PASN_Choice 2065 { 2066 #ifndef PASN_LEANANDMEAN 2067 PCLASSINFO(GCC_RequestPDU, PASN_Choice); 2068 #endif 2069 public: 2070 GCC_RequestPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 2071 2072 enum Choices { 2073 e_conferenceJoinRequest, 2074 e_conferenceAddRequest, 2075 e_conferenceLockRequest, 2076 e_conferenceUnlockRequest, 2077 e_conferenceTerminateRequest, 2078 e_conferenceEjectUserRequest, 2079 e_conferenceTransferRequest, 2080 e_registryRegisterChannelRequest, 2081 e_registryAssignTokenRequest, 2082 e_registrySetParameterRequest, 2083 e_registryRetrieveEntryRequest, 2084 e_registryDeleteEntryRequest, 2085 e_registryMonitorEntryRequest, 2086 e_registryAllocateHandleRequest, 2087 e_nonStandardRequest 2088 }; 2089 2090 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2091 operator GCC_ConferenceJoinRequest &() const; 2092 #else 2093 operator GCC_ConferenceJoinRequest &(); 2094 operator const GCC_ConferenceJoinRequest &() const; 2095 #endif 2096 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2097 operator GCC_ConferenceAddRequest &() const; 2098 #else 2099 operator GCC_ConferenceAddRequest &(); 2100 operator const GCC_ConferenceAddRequest &() const; 2101 #endif 2102 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2103 operator GCC_ConferenceLockRequest &() const; 2104 #else 2105 operator GCC_ConferenceLockRequest &(); 2106 operator const GCC_ConferenceLockRequest &() const; 2107 #endif 2108 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2109 operator GCC_ConferenceUnlockRequest &() const; 2110 #else 2111 operator GCC_ConferenceUnlockRequest &(); 2112 operator const GCC_ConferenceUnlockRequest &() const; 2113 #endif 2114 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2115 operator GCC_ConferenceTerminateRequest &() const; 2116 #else 2117 operator GCC_ConferenceTerminateRequest &(); 2118 operator const GCC_ConferenceTerminateRequest &() const; 2119 #endif 2120 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2121 operator GCC_ConferenceEjectUserRequest &() const; 2122 #else 2123 operator GCC_ConferenceEjectUserRequest &(); 2124 operator const GCC_ConferenceEjectUserRequest &() const; 2125 #endif 2126 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2127 operator GCC_ConferenceTransferRequest &() const; 2128 #else 2129 operator GCC_ConferenceTransferRequest &(); 2130 operator const GCC_ConferenceTransferRequest &() const; 2131 #endif 2132 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2133 operator GCC_RegistryRegisterChannelRequest &() const; 2134 #else 2135 operator GCC_RegistryRegisterChannelRequest &(); 2136 operator const GCC_RegistryRegisterChannelRequest &() const; 2137 #endif 2138 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2139 operator GCC_RegistryAssignTokenRequest &() const; 2140 #else 2141 operator GCC_RegistryAssignTokenRequest &(); 2142 operator const GCC_RegistryAssignTokenRequest &() const; 2143 #endif 2144 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2145 operator GCC_RegistrySetParameterRequest &() const; 2146 #else 2147 operator GCC_RegistrySetParameterRequest &(); 2148 operator const GCC_RegistrySetParameterRequest &() const; 2149 #endif 2150 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2151 operator GCC_RegistryRetrieveEntryRequest &() const; 2152 #else 2153 operator GCC_RegistryRetrieveEntryRequest &(); 2154 operator const GCC_RegistryRetrieveEntryRequest &() const; 2155 #endif 2156 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2157 operator GCC_RegistryDeleteEntryRequest &() const; 2158 #else 2159 operator GCC_RegistryDeleteEntryRequest &(); 2160 operator const GCC_RegistryDeleteEntryRequest &() const; 2161 #endif 2162 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2163 operator GCC_RegistryMonitorEntryRequest &() const; 2164 #else 2165 operator GCC_RegistryMonitorEntryRequest &(); 2166 operator const GCC_RegistryMonitorEntryRequest &() const; 2167 #endif 2168 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2169 operator GCC_RegistryAllocateHandleRequest &() const; 2170 #else 2171 operator GCC_RegistryAllocateHandleRequest &(); 2172 operator const GCC_RegistryAllocateHandleRequest &() const; 2173 #endif 2174 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2175 operator GCC_NonStandardPDU &() const; 2176 #else 2177 operator GCC_NonStandardPDU &(); 2178 operator const GCC_NonStandardPDU &() const; 2179 #endif 2180 2181 PBoolean CreateObject(); 2182 PObject * Clone() const; 2183 }; 2184 2185 2186 // 2187 // ResponsePDU 2188 // 2189 2190 class GCC_ConferenceJoinResponse; 2191 class GCC_ConferenceAddResponse; 2192 class GCC_ConferenceLockResponse; 2193 class GCC_ConferenceUnlockResponse; 2194 class GCC_ConferenceTerminateResponse; 2195 class GCC_ConferenceEjectUserResponse; 2196 class GCC_ConferenceTransferResponse; 2197 class GCC_RegistryResponse; 2198 class GCC_RegistryAllocateHandleResponse; 2199 class GCC_FunctionNotSupportedResponse; 2200 class GCC_NonStandardPDU; 2201 2202 class GCC_ResponsePDU : public PASN_Choice 2203 { 2204 #ifndef PASN_LEANANDMEAN 2205 PCLASSINFO(GCC_ResponsePDU, PASN_Choice); 2206 #endif 2207 public: 2208 GCC_ResponsePDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 2209 2210 enum Choices { 2211 e_conferenceJoinResponse, 2212 e_conferenceAddResponse, 2213 e_conferenceLockResponse, 2214 e_conferenceUnlockResponse, 2215 e_conferenceTerminateResponse, 2216 e_conferenceEjectUserResponse, 2217 e_conferenceTransferResponse, 2218 e_registryResponse, 2219 e_registryAllocateHandleResponse, 2220 e_functionNotSupportedResponse, 2221 e_nonStandardResponse 2222 }; 2223 2224 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2225 operator GCC_ConferenceJoinResponse &() const; 2226 #else 2227 operator GCC_ConferenceJoinResponse &(); 2228 operator const GCC_ConferenceJoinResponse &() const; 2229 #endif 2230 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2231 operator GCC_ConferenceAddResponse &() const; 2232 #else 2233 operator GCC_ConferenceAddResponse &(); 2234 operator const GCC_ConferenceAddResponse &() const; 2235 #endif 2236 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2237 operator GCC_ConferenceLockResponse &() const; 2238 #else 2239 operator GCC_ConferenceLockResponse &(); 2240 operator const GCC_ConferenceLockResponse &() const; 2241 #endif 2242 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2243 operator GCC_ConferenceUnlockResponse &() const; 2244 #else 2245 operator GCC_ConferenceUnlockResponse &(); 2246 operator const GCC_ConferenceUnlockResponse &() const; 2247 #endif 2248 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2249 operator GCC_ConferenceTerminateResponse &() const; 2250 #else 2251 operator GCC_ConferenceTerminateResponse &(); 2252 operator const GCC_ConferenceTerminateResponse &() const; 2253 #endif 2254 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2255 operator GCC_ConferenceEjectUserResponse &() const; 2256 #else 2257 operator GCC_ConferenceEjectUserResponse &(); 2258 operator const GCC_ConferenceEjectUserResponse &() const; 2259 #endif 2260 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2261 operator GCC_ConferenceTransferResponse &() const; 2262 #else 2263 operator GCC_ConferenceTransferResponse &(); 2264 operator const GCC_ConferenceTransferResponse &() const; 2265 #endif 2266 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2267 operator GCC_RegistryResponse &() const; 2268 #else 2269 operator GCC_RegistryResponse &(); 2270 operator const GCC_RegistryResponse &() const; 2271 #endif 2272 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2273 operator GCC_RegistryAllocateHandleResponse &() const; 2274 #else 2275 operator GCC_RegistryAllocateHandleResponse &(); 2276 operator const GCC_RegistryAllocateHandleResponse &() const; 2277 #endif 2278 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2279 operator GCC_FunctionNotSupportedResponse &() const; 2280 #else 2281 operator GCC_FunctionNotSupportedResponse &(); 2282 operator const GCC_FunctionNotSupportedResponse &() const; 2283 #endif 2284 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2285 operator GCC_NonStandardPDU &() const; 2286 #else 2287 operator GCC_NonStandardPDU &(); 2288 operator const GCC_NonStandardPDU &() const; 2289 #endif 2290 2291 PBoolean CreateObject(); 2292 PObject * Clone() const; 2293 }; 2294 2295 2296 // 2297 // IndicationPDU 2298 // 2299 2300 class GCC_UserIDIndication; 2301 class GCC_ConferenceLockIndication; 2302 class GCC_ConferenceUnlockIndication; 2303 class GCC_ConferenceTerminateIndication; 2304 class GCC_ConferenceEjectUserIndication; 2305 class GCC_ConferenceTransferIndication; 2306 class GCC_RosterUpdateIndication; 2307 class GCC_ApplicationInvokeIndication; 2308 class GCC_RegistryMonitorEntryIndication; 2309 class GCC_ConductorAssignIndication; 2310 class GCC_ConductorReleaseIndication; 2311 class GCC_ConductorPermissionAskIndication; 2312 class GCC_ConductorPermissionGrantIndication; 2313 class GCC_ConferenceTimeRemainingIndication; 2314 class GCC_ConferenceTimeInquireIndication; 2315 class GCC_ConferenceTimeExtendIndication; 2316 class GCC_ConferenceAssistanceIndication; 2317 class GCC_TextMessageIndication; 2318 class GCC_NonStandardPDU; 2319 2320 class GCC_IndicationPDU : public PASN_Choice 2321 { 2322 #ifndef PASN_LEANANDMEAN 2323 PCLASSINFO(GCC_IndicationPDU, PASN_Choice); 2324 #endif 2325 public: 2326 GCC_IndicationPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 2327 2328 enum Choices { 2329 e_userIDIndication, 2330 e_conferenceLockIndication, 2331 e_conferenceUnlockIndication, 2332 e_conferenceTerminateIndication, 2333 e_conferenceEjectUserIndication, 2334 e_conferenceTransferIndication, 2335 e_rosterUpdateIndication, 2336 e_applicationInvokeIndication, 2337 e_registryMonitorEntryIndication, 2338 e_conductorAssignIndication, 2339 e_conductorReleaseIndication, 2340 e_conductorPermissionAskIndication, 2341 e_conductorPermissionGrantIndication, 2342 e_conferenceTimeRemainingIndication, 2343 e_conferenceTimeInquireIndication, 2344 e_conferenceTimeExtendIndication, 2345 e_conferenceAssistanceIndication, 2346 e_textMessageIndication, 2347 e_nonStandardIndication 2348 }; 2349 2350 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2351 operator GCC_UserIDIndication &() const; 2352 #else 2353 operator GCC_UserIDIndication &(); 2354 operator const GCC_UserIDIndication &() const; 2355 #endif 2356 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2357 operator GCC_ConferenceLockIndication &() const; 2358 #else 2359 operator GCC_ConferenceLockIndication &(); 2360 operator const GCC_ConferenceLockIndication &() const; 2361 #endif 2362 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2363 operator GCC_ConferenceUnlockIndication &() const; 2364 #else 2365 operator GCC_ConferenceUnlockIndication &(); 2366 operator const GCC_ConferenceUnlockIndication &() const; 2367 #endif 2368 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2369 operator GCC_ConferenceTerminateIndication &() const; 2370 #else 2371 operator GCC_ConferenceTerminateIndication &(); 2372 operator const GCC_ConferenceTerminateIndication &() const; 2373 #endif 2374 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2375 operator GCC_ConferenceEjectUserIndication &() const; 2376 #else 2377 operator GCC_ConferenceEjectUserIndication &(); 2378 operator const GCC_ConferenceEjectUserIndication &() const; 2379 #endif 2380 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2381 operator GCC_ConferenceTransferIndication &() const; 2382 #else 2383 operator GCC_ConferenceTransferIndication &(); 2384 operator const GCC_ConferenceTransferIndication &() const; 2385 #endif 2386 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2387 operator GCC_RosterUpdateIndication &() const; 2388 #else 2389 operator GCC_RosterUpdateIndication &(); 2390 operator const GCC_RosterUpdateIndication &() const; 2391 #endif 2392 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2393 operator GCC_ApplicationInvokeIndication &() const; 2394 #else 2395 operator GCC_ApplicationInvokeIndication &(); 2396 operator const GCC_ApplicationInvokeIndication &() const; 2397 #endif 2398 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2399 operator GCC_RegistryMonitorEntryIndication &() const; 2400 #else 2401 operator GCC_RegistryMonitorEntryIndication &(); 2402 operator const GCC_RegistryMonitorEntryIndication &() const; 2403 #endif 2404 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2405 operator GCC_ConductorAssignIndication &() const; 2406 #else 2407 operator GCC_ConductorAssignIndication &(); 2408 operator const GCC_ConductorAssignIndication &() const; 2409 #endif 2410 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2411 operator GCC_ConductorReleaseIndication &() const; 2412 #else 2413 operator GCC_ConductorReleaseIndication &(); 2414 operator const GCC_ConductorReleaseIndication &() const; 2415 #endif 2416 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2417 operator GCC_ConductorPermissionAskIndication &() const; 2418 #else 2419 operator GCC_ConductorPermissionAskIndication &(); 2420 operator const GCC_ConductorPermissionAskIndication &() const; 2421 #endif 2422 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2423 operator GCC_ConductorPermissionGrantIndication &() const; 2424 #else 2425 operator GCC_ConductorPermissionGrantIndication &(); 2426 operator const GCC_ConductorPermissionGrantIndication &() const; 2427 #endif 2428 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2429 operator GCC_ConferenceTimeRemainingIndication &() const; 2430 #else 2431 operator GCC_ConferenceTimeRemainingIndication &(); 2432 operator const GCC_ConferenceTimeRemainingIndication &() const; 2433 #endif 2434 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2435 operator GCC_ConferenceTimeInquireIndication &() const; 2436 #else 2437 operator GCC_ConferenceTimeInquireIndication &(); 2438 operator const GCC_ConferenceTimeInquireIndication &() const; 2439 #endif 2440 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2441 operator GCC_ConferenceTimeExtendIndication &() const; 2442 #else 2443 operator GCC_ConferenceTimeExtendIndication &(); 2444 operator const GCC_ConferenceTimeExtendIndication &() const; 2445 #endif 2446 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2447 operator GCC_ConferenceAssistanceIndication &() const; 2448 #else 2449 operator GCC_ConferenceAssistanceIndication &(); 2450 operator const GCC_ConferenceAssistanceIndication &() const; 2451 #endif 2452 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2453 operator GCC_TextMessageIndication &() const; 2454 #else 2455 operator GCC_TextMessageIndication &(); 2456 operator const GCC_TextMessageIndication &() const; 2457 #endif 2458 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2459 operator GCC_NonStandardPDU &() const; 2460 #else 2461 operator GCC_NonStandardPDU &(); 2462 operator const GCC_NonStandardPDU &() const; 2463 #endif 2464 2465 PBoolean CreateObject(); 2466 PObject * Clone() const; 2467 }; 2468 2469 2470 // 2471 // UserData_subtype 2472 // 2473 2474 class GCC_UserData_subtype : public PASN_Sequence 2475 { 2476 #ifndef PASN_LEANANDMEAN 2477 PCLASSINFO(GCC_UserData_subtype, PASN_Sequence); 2478 #endif 2479 public: 2480 GCC_UserData_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 2481 2482 enum OptionalFields { 2483 e_value 2484 }; 2485 2486 GCC_Key m_key; 2487 PASN_OctetString m_value; 2488 2489 PINDEX GetDataLength() const; 2490 PBoolean Decode(PASN_Stream & strm); 2491 void Encode(PASN_Stream & strm) const; 2492 #ifndef PASN_NOPRINTON 2493 void PrintOn(ostream & strm) const; 2494 #endif 2495 Comparison Compare(const PObject & obj) const; 2496 PObject * Clone() const; 2497 }; 2498 2499 2500 // 2501 // ArrayOf_ChallengeItem 2502 // 2503 2504 class GCC_ChallengeItem; 2505 2506 class GCC_ArrayOf_ChallengeItem : public PASN_Array 2507 { 2508 #ifndef PASN_LEANANDMEAN 2509 PCLASSINFO(GCC_ArrayOf_ChallengeItem, PASN_Array); 2510 #endif 2511 public: 2512 GCC_ArrayOf_ChallengeItem(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 2513 2514 PASN_Object * CreateObject() const; 2515 GCC_ChallengeItem & operator[](PINDEX i) const; 2516 PObject * Clone() const; 2517 }; 2518 2519 2520 // 2521 // NetworkAddress_subtype 2522 // 2523 2524 class GCC_NetworkAddress_subtype_aggregatedChannel; 2525 class GCC_NetworkAddress_subtype_transportConnection; 2526 class GCC_NonStandardParameter; 2527 2528 class GCC_NetworkAddress_subtype : public PASN_Choice 2529 { 2530 #ifndef PASN_LEANANDMEAN 2531 PCLASSINFO(GCC_NetworkAddress_subtype, PASN_Choice); 2532 #endif 2533 public: 2534 GCC_NetworkAddress_subtype(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 2535 2536 enum Choices { 2537 e_aggregatedChannel, 2538 e_transportConnection, 2539 e_nonStandard 2540 }; 2541 2542 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2543 operator GCC_NetworkAddress_subtype_aggregatedChannel &() const; 2544 #else 2545 operator GCC_NetworkAddress_subtype_aggregatedChannel &(); 2546 operator const GCC_NetworkAddress_subtype_aggregatedChannel &() const; 2547 #endif 2548 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2549 operator GCC_NetworkAddress_subtype_transportConnection &() const; 2550 #else 2551 operator GCC_NetworkAddress_subtype_transportConnection &(); 2552 operator const GCC_NetworkAddress_subtype_transportConnection &() const; 2553 #endif 2554 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 2555 operator GCC_NonStandardParameter &() const; 2556 #else 2557 operator GCC_NonStandardParameter &(); 2558 operator const GCC_NonStandardParameter &() const; 2559 #endif 2560 2561 PBoolean CreateObject(); 2562 PObject * Clone() const; 2563 }; 2564 2565 2566 // 2567 // ArrayOf_TextString 2568 // 2569 2570 class GCC_TextString; 2571 2572 class GCC_ArrayOf_TextString : public PASN_Array 2573 { 2574 #ifndef PASN_LEANANDMEAN 2575 PCLASSINFO(GCC_ArrayOf_TextString, PASN_Array); 2576 #endif 2577 public: 2578 GCC_ArrayOf_TextString(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 2579 2580 PASN_Object * CreateObject() const; 2581 GCC_TextString & operator[](PINDEX i) const; 2582 PObject * Clone() const; 2583 }; 2584 2585 2586 // 2587 // ApplicationRecord_nonCollapsingCapabilities 2588 // 2589 2590 class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype; 2591 2592 class GCC_ApplicationRecord_nonCollapsingCapabilities : public PASN_Array 2593 { 2594 #ifndef PASN_LEANANDMEAN 2595 PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities, PASN_Array); 2596 #endif 2597 public: 2598 GCC_ApplicationRecord_nonCollapsingCapabilities(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 2599 2600 PASN_Object * CreateObject() const; 2601 GCC_ApplicationRecord_nonCollapsingCapabilities_subtype & operator[](PINDEX i) const; 2602 PObject * Clone() const; 2603 }; 2604 2605 2606 // 2607 // ApplicationInvokeSpecifier_expectedCapabilitySet 2608 // 2609 2610 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype; 2611 2612 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet : public PASN_Array 2613 { 2614 #ifndef PASN_LEANANDMEAN 2615 PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet, PASN_Array); 2616 #endif 2617 public: 2618 GCC_ApplicationInvokeSpecifier_expectedCapabilitySet(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 2619 2620 PASN_Object * CreateObject() const; 2621 GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype & operator[](PINDEX i) const; 2622 PObject * Clone() const; 2623 }; 2624 2625 2626 // 2627 // RegistryEntryOwner_owned 2628 // 2629 2630 class GCC_RegistryEntryOwner_owned : public PASN_Sequence 2631 { 2632 #ifndef PASN_LEANANDMEAN 2633 PCLASSINFO(GCC_RegistryEntryOwner_owned, PASN_Sequence); 2634 #endif 2635 public: 2636 GCC_RegistryEntryOwner_owned(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 2637 2638 GCC_UserID m_nodeID; 2639 GCC_EntityID m_entityID; 2640 2641 PINDEX GetDataLength() const; 2642 PBoolean Decode(PASN_Stream & strm); 2643 void Encode(PASN_Stream & strm) const; 2644 #ifndef PASN_NOPRINTON 2645 void PrintOn(ostream & strm) const; 2646 #endif 2647 Comparison Compare(const PObject & obj) const; 2648 PObject * Clone() const; 2649 }; 2650 2651 2652 // 2653 // ArrayOf_Privilege 2654 // 2655 2656 class GCC_Privilege; 2657 2658 class GCC_ArrayOf_Privilege : public PASN_Array 2659 { 2660 #ifndef PASN_LEANANDMEAN 2661 PCLASSINFO(GCC_ArrayOf_Privilege, PASN_Array); 2662 #endif 2663 public: 2664 GCC_ArrayOf_Privilege(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 2665 2666 PASN_Object * CreateObject() const; 2667 GCC_Privilege & operator[](PINDEX i) const; 2668 PObject * Clone() const; 2669 }; 2670 2671 2672 // 2673 // ConferenceCreateResponse_result 2674 // 2675 2676 class GCC_ConferenceCreateResponse_result : public PASN_Enumeration 2677 { 2678 #ifndef PASN_LEANANDMEAN 2679 PCLASSINFO(GCC_ConferenceCreateResponse_result, PASN_Enumeration); 2680 #endif 2681 public: 2682 GCC_ConferenceCreateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2683 2684 enum Enumerations { 2685 e_success, 2686 e_userRejected, 2687 e_resourcesNotAvailable, 2688 e_rejectedForSymmetryBreaking, 2689 e_lockedConferenceNotSupported 2690 }; 2691 2692 GCC_ConferenceCreateResponse_result & operator=(unsigned v); 2693 PObject * Clone() const; 2694 }; 2695 2696 2697 // 2698 // ArrayOf_ConferenceDescriptor 2699 // 2700 2701 class GCC_ConferenceDescriptor; 2702 2703 class GCC_ArrayOf_ConferenceDescriptor : public PASN_Array 2704 { 2705 #ifndef PASN_LEANANDMEAN 2706 PCLASSINFO(GCC_ArrayOf_ConferenceDescriptor, PASN_Array); 2707 #endif 2708 public: 2709 GCC_ArrayOf_ConferenceDescriptor(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 2710 2711 PASN_Object * CreateObject() const; 2712 GCC_ConferenceDescriptor & operator[](PINDEX i) const; 2713 PObject * Clone() const; 2714 }; 2715 2716 2717 // 2718 // ConferenceQueryResponse_result 2719 // 2720 2721 class GCC_ConferenceQueryResponse_result : public PASN_Enumeration 2722 { 2723 #ifndef PASN_LEANANDMEAN 2724 PCLASSINFO(GCC_ConferenceQueryResponse_result, PASN_Enumeration); 2725 #endif 2726 public: 2727 GCC_ConferenceQueryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2728 2729 enum Enumerations { 2730 e_success, 2731 e_userRejected 2732 }; 2733 2734 GCC_ConferenceQueryResponse_result & operator=(unsigned v); 2735 PObject * Clone() const; 2736 }; 2737 2738 2739 // 2740 // ConferenceJoinResponse_result 2741 // 2742 2743 class GCC_ConferenceJoinResponse_result : public PASN_Enumeration 2744 { 2745 #ifndef PASN_LEANANDMEAN 2746 PCLASSINFO(GCC_ConferenceJoinResponse_result, PASN_Enumeration); 2747 #endif 2748 public: 2749 GCC_ConferenceJoinResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2750 2751 enum Enumerations { 2752 e_success, 2753 e_userRejected, 2754 e_invalidConference, 2755 e_invalidPassword, 2756 e_invalidConvenerPassword, 2757 e_challengeResponseRequired, 2758 e_invalidChallengeResponse 2759 }; 2760 2761 GCC_ConferenceJoinResponse_result & operator=(unsigned v); 2762 PObject * Clone() const; 2763 }; 2764 2765 2766 // 2767 // ConferenceInviteResponse_result 2768 // 2769 2770 class GCC_ConferenceInviteResponse_result : public PASN_Enumeration 2771 { 2772 #ifndef PASN_LEANANDMEAN 2773 PCLASSINFO(GCC_ConferenceInviteResponse_result, PASN_Enumeration); 2774 #endif 2775 public: 2776 GCC_ConferenceInviteResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2777 2778 enum Enumerations { 2779 e_success, 2780 e_userRejected 2781 }; 2782 2783 GCC_ConferenceInviteResponse_result & operator=(unsigned v); 2784 PObject * Clone() const; 2785 }; 2786 2787 2788 // 2789 // ConferenceAddResponse_result 2790 // 2791 2792 class GCC_ConferenceAddResponse_result : public PASN_Enumeration 2793 { 2794 #ifndef PASN_LEANANDMEAN 2795 PCLASSINFO(GCC_ConferenceAddResponse_result, PASN_Enumeration); 2796 #endif 2797 public: 2798 GCC_ConferenceAddResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2799 2800 enum Enumerations { 2801 e_success, 2802 e_invalidRequester, 2803 e_invalidNetworkType, 2804 e_invalidNetworkAddress, 2805 e_addedNodeBusy, 2806 e_networkBusy, 2807 e_noPortsAvailable, 2808 e_connectionUnsuccessful 2809 }; 2810 2811 GCC_ConferenceAddResponse_result & operator=(unsigned v); 2812 PObject * Clone() const; 2813 }; 2814 2815 2816 // 2817 // ConferenceLockResponse_result 2818 // 2819 2820 class GCC_ConferenceLockResponse_result : public PASN_Enumeration 2821 { 2822 #ifndef PASN_LEANANDMEAN 2823 PCLASSINFO(GCC_ConferenceLockResponse_result, PASN_Enumeration); 2824 #endif 2825 public: 2826 GCC_ConferenceLockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2827 2828 enum Enumerations { 2829 e_success, 2830 e_invalidRequester, 2831 e_alreadyLocked 2832 }; 2833 2834 GCC_ConferenceLockResponse_result & operator=(unsigned v); 2835 PObject * Clone() const; 2836 }; 2837 2838 2839 // 2840 // ConferenceUnlockResponse_result 2841 // 2842 2843 class GCC_ConferenceUnlockResponse_result : public PASN_Enumeration 2844 { 2845 #ifndef PASN_LEANANDMEAN 2846 PCLASSINFO(GCC_ConferenceUnlockResponse_result, PASN_Enumeration); 2847 #endif 2848 public: 2849 GCC_ConferenceUnlockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2850 2851 enum Enumerations { 2852 e_success, 2853 e_invalidRequester, 2854 e_alreadyUnlocked 2855 }; 2856 2857 GCC_ConferenceUnlockResponse_result & operator=(unsigned v); 2858 PObject * Clone() const; 2859 }; 2860 2861 2862 // 2863 // ConferenceTerminateRequest_reason 2864 // 2865 2866 class GCC_ConferenceTerminateRequest_reason : public PASN_Enumeration 2867 { 2868 #ifndef PASN_LEANANDMEAN 2869 PCLASSINFO(GCC_ConferenceTerminateRequest_reason, PASN_Enumeration); 2870 #endif 2871 public: 2872 GCC_ConferenceTerminateRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2873 2874 enum Enumerations { 2875 e_userInitiated, 2876 e_timedConferenceTermination 2877 }; 2878 2879 GCC_ConferenceTerminateRequest_reason & operator=(unsigned v); 2880 PObject * Clone() const; 2881 }; 2882 2883 2884 // 2885 // ConferenceTerminateResponse_result 2886 // 2887 2888 class GCC_ConferenceTerminateResponse_result : public PASN_Enumeration 2889 { 2890 #ifndef PASN_LEANANDMEAN 2891 PCLASSINFO(GCC_ConferenceTerminateResponse_result, PASN_Enumeration); 2892 #endif 2893 public: 2894 GCC_ConferenceTerminateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2895 2896 enum Enumerations { 2897 e_success, 2898 e_invalidRequester 2899 }; 2900 2901 GCC_ConferenceTerminateResponse_result & operator=(unsigned v); 2902 PObject * Clone() const; 2903 }; 2904 2905 2906 // 2907 // ConferenceTerminateIndication_reason 2908 // 2909 2910 class GCC_ConferenceTerminateIndication_reason : public PASN_Enumeration 2911 { 2912 #ifndef PASN_LEANANDMEAN 2913 PCLASSINFO(GCC_ConferenceTerminateIndication_reason, PASN_Enumeration); 2914 #endif 2915 public: 2916 GCC_ConferenceTerminateIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2917 2918 enum Enumerations { 2919 e_userInitiated, 2920 e_timedConferenceTermination 2921 }; 2922 2923 GCC_ConferenceTerminateIndication_reason & operator=(unsigned v); 2924 PObject * Clone() const; 2925 }; 2926 2927 2928 // 2929 // ConferenceEjectUserRequest_reason 2930 // 2931 2932 class GCC_ConferenceEjectUserRequest_reason : public PASN_Enumeration 2933 { 2934 #ifndef PASN_LEANANDMEAN 2935 PCLASSINFO(GCC_ConferenceEjectUserRequest_reason, PASN_Enumeration); 2936 #endif 2937 public: 2938 GCC_ConferenceEjectUserRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2939 2940 enum Enumerations { 2941 e_userInitiated 2942 }; 2943 2944 GCC_ConferenceEjectUserRequest_reason & operator=(unsigned v); 2945 PObject * Clone() const; 2946 }; 2947 2948 2949 // 2950 // ConferenceEjectUserResponse_result 2951 // 2952 2953 class GCC_ConferenceEjectUserResponse_result : public PASN_Enumeration 2954 { 2955 #ifndef PASN_LEANANDMEAN 2956 PCLASSINFO(GCC_ConferenceEjectUserResponse_result, PASN_Enumeration); 2957 #endif 2958 public: 2959 GCC_ConferenceEjectUserResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2960 2961 enum Enumerations { 2962 e_success, 2963 e_invalidRequester, 2964 e_invalidNode 2965 }; 2966 2967 GCC_ConferenceEjectUserResponse_result & operator=(unsigned v); 2968 PObject * Clone() const; 2969 }; 2970 2971 2972 // 2973 // ConferenceEjectUserIndication_reason 2974 // 2975 2976 class GCC_ConferenceEjectUserIndication_reason : public PASN_Enumeration 2977 { 2978 #ifndef PASN_LEANANDMEAN 2979 PCLASSINFO(GCC_ConferenceEjectUserIndication_reason, PASN_Enumeration); 2980 #endif 2981 public: 2982 GCC_ConferenceEjectUserIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 2983 2984 enum Enumerations { 2985 e_userInitiated, 2986 e_higherNodeDisconnected, 2987 e_higherNodeEjected 2988 }; 2989 2990 GCC_ConferenceEjectUserIndication_reason & operator=(unsigned v); 2991 PObject * Clone() const; 2992 }; 2993 2994 2995 // 2996 // ArrayOf_UserID 2997 // 2998 2999 class GCC_UserID; 3000 3001 class GCC_ArrayOf_UserID : public PASN_Array 3002 { 3003 #ifndef PASN_LEANANDMEAN 3004 PCLASSINFO(GCC_ArrayOf_UserID, PASN_Array); 3005 #endif 3006 public: 3007 GCC_ArrayOf_UserID(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3008 3009 PASN_Object * CreateObject() const; 3010 GCC_UserID & operator[](PINDEX i) const; 3011 PObject * Clone() const; 3012 }; 3013 3014 3015 // 3016 // ConferenceTransferResponse_result 3017 // 3018 3019 class GCC_ConferenceTransferResponse_result : public PASN_Enumeration 3020 { 3021 #ifndef PASN_LEANANDMEAN 3022 PCLASSINFO(GCC_ConferenceTransferResponse_result, PASN_Enumeration); 3023 #endif 3024 public: 3025 GCC_ConferenceTransferResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 3026 3027 enum Enumerations { 3028 e_success, 3029 e_invalidRequester 3030 }; 3031 3032 GCC_ConferenceTransferResponse_result & operator=(unsigned v); 3033 PObject * Clone() const; 3034 }; 3035 3036 3037 // 3038 // RosterUpdateIndication_applicationInformation 3039 // 3040 3041 class GCC_RosterUpdateIndication_applicationInformation_subtype; 3042 3043 class GCC_RosterUpdateIndication_applicationInformation : public PASN_Array 3044 { 3045 #ifndef PASN_LEANANDMEAN 3046 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation, PASN_Array); 3047 #endif 3048 public: 3049 GCC_RosterUpdateIndication_applicationInformation(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3050 3051 PASN_Object * CreateObject() const; 3052 GCC_RosterUpdateIndication_applicationInformation_subtype & operator[](PINDEX i) const; 3053 PObject * Clone() const; 3054 }; 3055 3056 3057 // 3058 // ArrayOf_ApplicationInvokeSpecifier 3059 // 3060 3061 class GCC_ApplicationInvokeSpecifier; 3062 3063 class GCC_ArrayOf_ApplicationInvokeSpecifier : public PASN_Array 3064 { 3065 #ifndef PASN_LEANANDMEAN 3066 PCLASSINFO(GCC_ArrayOf_ApplicationInvokeSpecifier, PASN_Array); 3067 #endif 3068 public: 3069 GCC_ArrayOf_ApplicationInvokeSpecifier(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3070 3071 PASN_Object * CreateObject() const; 3072 GCC_ApplicationInvokeSpecifier & operator[](PINDEX i) const; 3073 PObject * Clone() const; 3074 }; 3075 3076 3077 // 3078 // RegistryAllocateHandleResponse_result 3079 // 3080 3081 class GCC_RegistryAllocateHandleResponse_result : public PASN_Enumeration 3082 { 3083 #ifndef PASN_LEANANDMEAN 3084 PCLASSINFO(GCC_RegistryAllocateHandleResponse_result, PASN_Enumeration); 3085 #endif 3086 public: 3087 GCC_RegistryAllocateHandleResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 3088 3089 enum Enumerations { 3090 e_successful, 3091 e_noHandlesAvailable 3092 }; 3093 3094 GCC_RegistryAllocateHandleResponse_result & operator=(unsigned v); 3095 PObject * Clone() const; 3096 }; 3097 3098 3099 // 3100 // RegistryResponse_primitiveType 3101 // 3102 3103 class GCC_RegistryResponse_primitiveType : public PASN_Enumeration 3104 { 3105 #ifndef PASN_LEANANDMEAN 3106 PCLASSINFO(GCC_RegistryResponse_primitiveType, PASN_Enumeration); 3107 #endif 3108 public: 3109 GCC_RegistryResponse_primitiveType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 3110 3111 enum Enumerations { 3112 e_registerChannel, 3113 e_assignToken, 3114 e_setParameter, 3115 e_retrieveEntry, 3116 e_deleteEntry, 3117 e_monitorEntry 3118 }; 3119 3120 GCC_RegistryResponse_primitiveType & operator=(unsigned v); 3121 PObject * Clone() const; 3122 }; 3123 3124 3125 // 3126 // RegistryResponse_result 3127 // 3128 3129 class GCC_RegistryResponse_result : public PASN_Enumeration 3130 { 3131 #ifndef PASN_LEANANDMEAN 3132 PCLASSINFO(GCC_RegistryResponse_result, PASN_Enumeration); 3133 #endif 3134 public: 3135 GCC_RegistryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass); 3136 3137 enum Enumerations { 3138 e_successful, 3139 e_belongsToOther, 3140 e_tooManyEntries, 3141 e_inconsistentType, 3142 e_entryNotFound, 3143 e_entryAlreadyExists, 3144 e_invalidRequester 3145 }; 3146 3147 GCC_RegistryResponse_result & operator=(unsigned v); 3148 PObject * Clone() const; 3149 }; 3150 3151 3152 // 3153 // NetworkAddress_subtype_transportConnection 3154 // 3155 3156 class GCC_NetworkAddress_subtype_transportConnection : public PASN_Sequence 3157 { 3158 #ifndef PASN_LEANANDMEAN 3159 PCLASSINFO(GCC_NetworkAddress_subtype_transportConnection, PASN_Sequence); 3160 #endif 3161 public: 3162 GCC_NetworkAddress_subtype_transportConnection(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3163 3164 enum OptionalFields { 3165 e_transportSelector 3166 }; 3167 3168 PASN_OctetString m_nsapAddress; 3169 PASN_OctetString m_transportSelector; 3170 3171 PINDEX GetDataLength() const; 3172 PBoolean Decode(PASN_Stream & strm); 3173 void Encode(PASN_Stream & strm) const; 3174 #ifndef PASN_NOPRINTON 3175 void PrintOn(ostream & strm) const; 3176 #endif 3177 Comparison Compare(const PObject & obj) const; 3178 PObject * Clone() const; 3179 }; 3180 3181 3182 // 3183 // ApplicationRecord_nonCollapsingCapabilities_subtype 3184 // 3185 3186 class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype : public PASN_Sequence 3187 { 3188 #ifndef PASN_LEANANDMEAN 3189 PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities_subtype, PASN_Sequence); 3190 #endif 3191 public: 3192 GCC_ApplicationRecord_nonCollapsingCapabilities_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3193 3194 enum OptionalFields { 3195 e_applicationData 3196 }; 3197 3198 GCC_CapabilityID m_capabilityID; 3199 PASN_OctetString m_applicationData; 3200 3201 PINDEX GetDataLength() const; 3202 PBoolean Decode(PASN_Stream & strm); 3203 void Encode(PASN_Stream & strm) const; 3204 #ifndef PASN_NOPRINTON 3205 void PrintOn(ostream & strm) const; 3206 #endif 3207 Comparison Compare(const PObject & obj) const; 3208 PObject * Clone() const; 3209 }; 3210 3211 3212 // 3213 // ApplicationInvokeSpecifier_expectedCapabilitySet_subtype 3214 // 3215 3216 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype : public PASN_Sequence 3217 { 3218 #ifndef PASN_LEANANDMEAN 3219 PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype, PASN_Sequence); 3220 #endif 3221 public: 3222 GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3223 3224 GCC_CapabilityID m_capabilityID; 3225 GCC_CapabilityClass m_capabilityClass; 3226 3227 PINDEX GetDataLength() const; 3228 PBoolean Decode(PASN_Stream & strm); 3229 void Encode(PASN_Stream & strm) const; 3230 #ifndef PASN_NOPRINTON 3231 void PrintOn(ostream & strm) const; 3232 #endif 3233 Comparison Compare(const PObject & obj) const; 3234 PObject * Clone() const; 3235 }; 3236 3237 3238 // 3239 // RosterUpdateIndication_nodeInformation_nodeRecordList 3240 // 3241 3242 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh; 3243 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update; 3244 3245 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList : public PASN_Choice 3246 { 3247 #ifndef PASN_LEANANDMEAN 3248 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList, PASN_Choice); 3249 #endif 3250 public: 3251 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 3252 3253 enum Choices { 3254 e_noChange, 3255 e_refresh, 3256 e_update 3257 }; 3258 3259 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3260 operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const; 3261 #else 3262 operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &(); 3263 operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const; 3264 #endif 3265 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3266 operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const; 3267 #else 3268 operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &(); 3269 operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const; 3270 #endif 3271 3272 PBoolean CreateObject(); 3273 PObject * Clone() const; 3274 }; 3275 3276 3277 // 3278 // NetworkAddress_subtype_aggregatedChannel_transferModes 3279 // 3280 3281 class GCC_NetworkAddress_subtype_aggregatedChannel_transferModes : public PASN_Sequence 3282 { 3283 #ifndef PASN_LEANANDMEAN 3284 PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_transferModes, PASN_Sequence); 3285 #endif 3286 public: 3287 GCC_NetworkAddress_subtype_aggregatedChannel_transferModes(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3288 3289 PASN_Boolean m_speech; 3290 PASN_Boolean m_voice_band; 3291 PASN_Boolean m_digital_56k; 3292 PASN_Boolean m_digital_64k; 3293 PASN_Boolean m_digital_128k; 3294 PASN_Boolean m_digital_192k; 3295 PASN_Boolean m_digital_256k; 3296 PASN_Boolean m_digital_320k; 3297 PASN_Boolean m_digital_384k; 3298 PASN_Boolean m_digital_512k; 3299 PASN_Boolean m_digital_768k; 3300 PASN_Boolean m_digital_1152k; 3301 PASN_Boolean m_digital_1472k; 3302 PASN_Boolean m_digital_1536k; 3303 PASN_Boolean m_digital_1920k; 3304 PASN_Boolean m_packet_mode; 3305 PASN_Boolean m_frame_mode; 3306 PASN_Boolean m_atm; 3307 3308 PINDEX GetDataLength() const; 3309 PBoolean Decode(PASN_Stream & strm); 3310 void Encode(PASN_Stream & strm) const; 3311 #ifndef PASN_NOPRINTON 3312 void PrintOn(ostream & strm) const; 3313 #endif 3314 Comparison Compare(const PObject & obj) const; 3315 PObject * Clone() const; 3316 }; 3317 3318 3319 // 3320 // NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility 3321 // 3322 3323 class GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility : public PASN_Sequence 3324 { 3325 #ifndef PASN_LEANANDMEAN 3326 PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility, PASN_Sequence); 3327 #endif 3328 public: 3329 GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3330 3331 PASN_Boolean m_telephony3kHz; 3332 PASN_Boolean m_telephony7kHz; 3333 PASN_Boolean m_videotelephony; 3334 PASN_Boolean m_videoconference; 3335 PASN_Boolean m_audiographic; 3336 PASN_Boolean m_audiovisual; 3337 PASN_Boolean m_multimedia; 3338 3339 PINDEX GetDataLength() const; 3340 PBoolean Decode(PASN_Stream & strm); 3341 void Encode(PASN_Stream & strm) const; 3342 #ifndef PASN_NOPRINTON 3343 void PrintOn(ostream & strm) const; 3344 #endif 3345 Comparison Compare(const PObject & obj) const; 3346 PObject * Clone() const; 3347 }; 3348 3349 3350 // 3351 // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh 3352 // 3353 3354 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype; 3355 3356 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh : public PASN_Array 3357 { 3358 #ifndef PASN_LEANANDMEAN 3359 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh, PASN_Array); 3360 #endif 3361 public: 3362 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3363 3364 PASN_Object * CreateObject() const; 3365 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype & operator[](PINDEX i) const; 3366 PObject * Clone() const; 3367 }; 3368 3369 3370 // 3371 // RosterUpdateIndication_nodeInformation_nodeRecordList_update 3372 // 3373 3374 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype; 3375 3376 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update : public PASN_Array 3377 { 3378 #ifndef PASN_LEANANDMEAN 3379 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update, PASN_Array); 3380 #endif 3381 public: 3382 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3383 3384 PASN_Object * CreateObject() const; 3385 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype & operator[](PINDEX i) const; 3386 PObject * Clone() const; 3387 }; 3388 3389 3390 // 3391 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList 3392 // 3393 3394 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh; 3395 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update; 3396 3397 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList : public PASN_Choice 3398 { 3399 #ifndef PASN_LEANANDMEAN 3400 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList, PASN_Choice); 3401 #endif 3402 public: 3403 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 3404 3405 enum Choices { 3406 e_noChange, 3407 e_refresh, 3408 e_update 3409 }; 3410 3411 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3412 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const; 3413 #else 3414 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &(); 3415 operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const; 3416 #endif 3417 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3418 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const; 3419 #else 3420 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &(); 3421 operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const; 3422 #endif 3423 3424 PBoolean CreateObject(); 3425 PObject * Clone() const; 3426 }; 3427 3428 3429 // 3430 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList 3431 // 3432 3433 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh; 3434 3435 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList : public PASN_Choice 3436 { 3437 #ifndef PASN_LEANANDMEAN 3438 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList, PASN_Choice); 3439 #endif 3440 public: 3441 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 3442 3443 enum Choices { 3444 e_noChange, 3445 e_refresh 3446 }; 3447 3448 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3449 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const; 3450 #else 3451 operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &(); 3452 operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const; 3453 #endif 3454 3455 PBoolean CreateObject(); 3456 PObject * Clone() const; 3457 }; 3458 3459 3460 // 3461 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh 3462 // 3463 3464 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype; 3465 3466 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh : public PASN_Array 3467 { 3468 #ifndef PASN_LEANANDMEAN 3469 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh, PASN_Array); 3470 #endif 3471 public: 3472 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3473 3474 PASN_Object * CreateObject() const; 3475 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype & operator[](PINDEX i) const; 3476 PObject * Clone() const; 3477 }; 3478 3479 3480 // 3481 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update 3482 // 3483 3484 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype; 3485 3486 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update : public PASN_Array 3487 { 3488 #ifndef PASN_LEANANDMEAN 3489 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update, PASN_Array); 3490 #endif 3491 public: 3492 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3493 3494 PASN_Object * CreateObject() const; 3495 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype & operator[](PINDEX i) const; 3496 PObject * Clone() const; 3497 }; 3498 3499 3500 // 3501 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh 3502 // 3503 3504 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype; 3505 3506 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh : public PASN_Array 3507 { 3508 #ifndef PASN_LEANANDMEAN 3509 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh, PASN_Array); 3510 #endif 3511 public: 3512 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass); 3513 3514 PASN_Object * CreateObject() const; 3515 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype & operator[](PINDEX i) const; 3516 PObject * Clone() const; 3517 }; 3518 3519 3520 // 3521 // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate 3522 // 3523 3524 class GCC_NodeRecord; 3525 3526 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate : public PASN_Choice 3527 { 3528 #ifndef PASN_LEANANDMEAN 3529 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate, PASN_Choice); 3530 #endif 3531 public: 3532 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 3533 3534 enum Choices { 3535 e_addRecord, 3536 e_replaceRecord, 3537 e_removeRecord 3538 }; 3539 3540 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3541 operator GCC_NodeRecord &() const; 3542 #else 3543 operator GCC_NodeRecord &(); 3544 operator const GCC_NodeRecord &() const; 3545 #endif 3546 3547 PBoolean CreateObject(); 3548 PObject * Clone() const; 3549 }; 3550 3551 3552 // 3553 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype 3554 // 3555 3556 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype : public PASN_Sequence 3557 { 3558 #ifndef PASN_LEANANDMEAN 3559 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype, PASN_Sequence); 3560 #endif 3561 public: 3562 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3563 3564 GCC_CapabilityID m_capabilityID; 3565 GCC_CapabilityClass m_capabilityClass; 3566 PASN_Integer m_numberOfEntities; 3567 3568 PINDEX GetDataLength() const; 3569 PBoolean Decode(PASN_Stream & strm); 3570 void Encode(PASN_Stream & strm) const; 3571 #ifndef PASN_NOPRINTON 3572 void PrintOn(ostream & strm) const; 3573 #endif 3574 Comparison Compare(const PObject & obj) const; 3575 PObject * Clone() const; 3576 }; 3577 3578 3579 // 3580 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate 3581 // 3582 3583 class GCC_ApplicationRecord; 3584 3585 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate : public PASN_Choice 3586 { 3587 #ifndef PASN_LEANANDMEAN 3588 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate, PASN_Choice); 3589 #endif 3590 public: 3591 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass); 3592 3593 enum Choices { 3594 e_addRecord, 3595 e_replaceRecord, 3596 e_removeRecord 3597 }; 3598 3599 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9 3600 operator GCC_ApplicationRecord &() const; 3601 #else 3602 operator GCC_ApplicationRecord &(); 3603 operator const GCC_ApplicationRecord &() const; 3604 #endif 3605 3606 PBoolean CreateObject(); 3607 PObject * Clone() const; 3608 }; 3609 3610 3611 // 3612 // ChallengeRequest 3613 // 3614 3615 class GCC_ChallengeRequest : public PASN_Sequence 3616 { 3617 #ifndef PASN_LEANANDMEAN 3618 PCLASSINFO(GCC_ChallengeRequest, PASN_Sequence); 3619 #endif 3620 public: 3621 GCC_ChallengeRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3622 3623 PASN_Integer m_challengeTag; 3624 GCC_ArrayOf_ChallengeItem m_challengeSet; 3625 3626 PINDEX GetDataLength() const; 3627 PBoolean Decode(PASN_Stream & strm); 3628 void Encode(PASN_Stream & strm) const; 3629 #ifndef PASN_NOPRINTON 3630 void PrintOn(ostream & strm) const; 3631 #endif 3632 Comparison Compare(const PObject & obj) const; 3633 PObject * Clone() const; 3634 }; 3635 3636 3637 // 3638 // NodeRecord 3639 // 3640 3641 class GCC_NodeRecord : public PASN_Sequence 3642 { 3643 #ifndef PASN_LEANANDMEAN 3644 PCLASSINFO(GCC_NodeRecord, PASN_Sequence); 3645 #endif 3646 public: 3647 GCC_NodeRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3648 3649 enum OptionalFields { 3650 e_superiorNode, 3651 e_nodeName, 3652 e_participantsList, 3653 e_siteInformation, 3654 e_networkAddress, 3655 e_alternativeNodeID, 3656 e_userData 3657 }; 3658 3659 GCC_UserID m_superiorNode; 3660 GCC_NodeType m_nodeType; 3661 GCC_NodeProperties m_nodeProperties; 3662 GCC_TextString m_nodeName; 3663 GCC_ArrayOf_TextString m_participantsList; 3664 GCC_TextString m_siteInformation; 3665 GCC_NetworkAddress m_networkAddress; 3666 GCC_AlternativeNodeID m_alternativeNodeID; 3667 GCC_UserData m_userData; 3668 3669 PINDEX GetDataLength() const; 3670 PBoolean Decode(PASN_Stream & strm); 3671 void Encode(PASN_Stream & strm) const; 3672 #ifndef PASN_NOPRINTON 3673 void PrintOn(ostream & strm) const; 3674 #endif 3675 Comparison Compare(const PObject & obj) const; 3676 PObject * Clone() const; 3677 }; 3678 3679 3680 // 3681 // ApplicationRecord 3682 // 3683 3684 class GCC_ApplicationRecord : public PASN_Sequence 3685 { 3686 #ifndef PASN_LEANANDMEAN 3687 PCLASSINFO(GCC_ApplicationRecord, PASN_Sequence); 3688 #endif 3689 public: 3690 GCC_ApplicationRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3691 3692 enum OptionalFields { 3693 e_startupChannel, 3694 e_applicationUserID, 3695 e_nonCollapsingCapabilities 3696 }; 3697 3698 PASN_Boolean m_applicationActive; 3699 PASN_Boolean m_conductingOperationCapable; 3700 GCC_ChannelType m_startupChannel; 3701 GCC_UserID m_applicationUserID; 3702 GCC_ApplicationRecord_nonCollapsingCapabilities m_nonCollapsingCapabilities; 3703 3704 PINDEX GetDataLength() const; 3705 PBoolean Decode(PASN_Stream & strm); 3706 void Encode(PASN_Stream & strm) const; 3707 #ifndef PASN_NOPRINTON 3708 void PrintOn(ostream & strm) const; 3709 #endif 3710 Comparison Compare(const PObject & obj) const; 3711 PObject * Clone() const; 3712 }; 3713 3714 3715 // 3716 // ApplicationInvokeSpecifier 3717 // 3718 3719 class GCC_ApplicationInvokeSpecifier : public PASN_Sequence 3720 { 3721 #ifndef PASN_LEANANDMEAN 3722 PCLASSINFO(GCC_ApplicationInvokeSpecifier, PASN_Sequence); 3723 #endif 3724 public: 3725 GCC_ApplicationInvokeSpecifier(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3726 3727 enum OptionalFields { 3728 e_expectedCapabilitySet, 3729 e_startupChannel 3730 }; 3731 3732 GCC_SessionKey m_sessionKey; 3733 GCC_ApplicationInvokeSpecifier_expectedCapabilitySet m_expectedCapabilitySet; 3734 GCC_ChannelType m_startupChannel; 3735 PASN_Boolean m_mandatoryFlag; 3736 3737 PINDEX GetDataLength() const; 3738 PBoolean Decode(PASN_Stream & strm); 3739 void Encode(PASN_Stream & strm) const; 3740 #ifndef PASN_NOPRINTON 3741 void PrintOn(ostream & strm) const; 3742 #endif 3743 Comparison Compare(const PObject & obj) const; 3744 PObject * Clone() const; 3745 }; 3746 3747 3748 // 3749 // ConferenceCreateRequest 3750 // 3751 3752 class GCC_ConferenceCreateRequest : public PASN_Sequence 3753 { 3754 #ifndef PASN_LEANANDMEAN 3755 PCLASSINFO(GCC_ConferenceCreateRequest, PASN_Sequence); 3756 #endif 3757 public: 3758 GCC_ConferenceCreateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3759 3760 enum OptionalFields { 3761 e_convenerPassword, 3762 e_password, 3763 e_conductorPrivileges, 3764 e_conductedPrivileges, 3765 e_nonConductedPrivileges, 3766 e_conferenceDescription, 3767 e_callerIdentifier, 3768 e_userData, 3769 e_conferencePriority 3770 }; 3771 3772 GCC_ConferenceName m_conferenceName; 3773 GCC_Password m_convenerPassword; 3774 GCC_Password m_password; 3775 PASN_Boolean m_lockedConference; 3776 PASN_Boolean m_listedConference; 3777 PASN_Boolean m_conductibleConference; 3778 GCC_TerminationMethod m_terminationMethod; 3779 GCC_ArrayOf_Privilege m_conductorPrivileges; 3780 GCC_ArrayOf_Privilege m_conductedPrivileges; 3781 GCC_ArrayOf_Privilege m_nonConductedPrivileges; 3782 GCC_TextString m_conferenceDescription; 3783 GCC_TextString m_callerIdentifier; 3784 GCC_UserData m_userData; 3785 GCC_ConferencePriority m_conferencePriority; 3786 3787 PINDEX GetDataLength() const; 3788 PBoolean Decode(PASN_Stream & strm); 3789 void Encode(PASN_Stream & strm) const; 3790 #ifndef PASN_NOPRINTON 3791 void PrintOn(ostream & strm) const; 3792 #endif 3793 Comparison Compare(const PObject & obj) const; 3794 PObject * Clone() const; 3795 }; 3796 3797 3798 // 3799 // ConferenceCreateResponse 3800 // 3801 3802 class GCC_ConferenceCreateResponse : public PASN_Sequence 3803 { 3804 #ifndef PASN_LEANANDMEAN 3805 PCLASSINFO(GCC_ConferenceCreateResponse, PASN_Sequence); 3806 #endif 3807 public: 3808 GCC_ConferenceCreateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3809 3810 enum OptionalFields { 3811 e_userData 3812 }; 3813 3814 GCC_UserID m_nodeID; 3815 PASN_Integer m_tag; 3816 GCC_ConferenceCreateResponse_result m_result; 3817 GCC_UserData m_userData; 3818 3819 PINDEX GetDataLength() const; 3820 PBoolean Decode(PASN_Stream & strm); 3821 void Encode(PASN_Stream & strm) const; 3822 #ifndef PASN_NOPRINTON 3823 void PrintOn(ostream & strm) const; 3824 #endif 3825 Comparison Compare(const PObject & obj) const; 3826 PObject * Clone() const; 3827 }; 3828 3829 3830 // 3831 // ConferenceQueryResponse 3832 // 3833 3834 class GCC_ConferenceQueryResponse : public PASN_Sequence 3835 { 3836 #ifndef PASN_LEANANDMEAN 3837 PCLASSINFO(GCC_ConferenceQueryResponse, PASN_Sequence); 3838 #endif 3839 public: 3840 GCC_ConferenceQueryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3841 3842 enum OptionalFields { 3843 e_asymmetryIndicator, 3844 e_userData, 3845 e_waitForInvitationFlag, 3846 e_noUnlistedConferenceFlag 3847 }; 3848 3849 GCC_NodeType m_nodeType; 3850 GCC_AsymmetryIndicator m_asymmetryIndicator; 3851 GCC_ArrayOf_ConferenceDescriptor m_conferenceList; 3852 GCC_ConferenceQueryResponse_result m_result; 3853 GCC_UserData m_userData; 3854 PASN_Boolean m_waitForInvitationFlag; 3855 PASN_Boolean m_noUnlistedConferenceFlag; 3856 3857 PINDEX GetDataLength() const; 3858 PBoolean Decode(PASN_Stream & strm); 3859 void Encode(PASN_Stream & strm) const; 3860 #ifndef PASN_NOPRINTON 3861 void PrintOn(ostream & strm) const; 3862 #endif 3863 Comparison Compare(const PObject & obj) const; 3864 PObject * Clone() const; 3865 }; 3866 3867 3868 // 3869 // ConferenceJoinResponse 3870 // 3871 3872 class GCC_ConferenceJoinResponse : public PASN_Sequence 3873 { 3874 #ifndef PASN_LEANANDMEAN 3875 PCLASSINFO(GCC_ConferenceJoinResponse, PASN_Sequence); 3876 #endif 3877 public: 3878 GCC_ConferenceJoinResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3879 3880 enum OptionalFields { 3881 e_nodeID, 3882 e_conferenceNameAlias, 3883 e_conductorPrivileges, 3884 e_conductedPrivileges, 3885 e_nonConductedPrivileges, 3886 e_conferenceDescription, 3887 e_password, 3888 e_userData 3889 }; 3890 3891 GCC_UserID m_nodeID; 3892 GCC_UserID m_topNodeID; 3893 PASN_Integer m_tag; 3894 GCC_ConferenceNameSelector m_conferenceNameAlias; 3895 PASN_Boolean m_passwordInTheClearRequired; 3896 PASN_Boolean m_lockedConference; 3897 PASN_Boolean m_listedConference; 3898 PASN_Boolean m_conductibleConference; 3899 GCC_TerminationMethod m_terminationMethod; 3900 GCC_ArrayOf_Privilege m_conductorPrivileges; 3901 GCC_ArrayOf_Privilege m_conductedPrivileges; 3902 GCC_ArrayOf_Privilege m_nonConductedPrivileges; 3903 GCC_TextString m_conferenceDescription; 3904 GCC_PasswordChallengeRequestResponse m_password; 3905 GCC_ConferenceJoinResponse_result m_result; 3906 GCC_UserData m_userData; 3907 3908 PINDEX GetDataLength() const; 3909 PBoolean Decode(PASN_Stream & strm); 3910 void Encode(PASN_Stream & strm) const; 3911 #ifndef PASN_NOPRINTON 3912 void PrintOn(ostream & strm) const; 3913 #endif 3914 Comparison Compare(const PObject & obj) const; 3915 PObject * Clone() const; 3916 }; 3917 3918 3919 // 3920 // ConferenceInviteRequest 3921 // 3922 3923 class GCC_ConferenceInviteRequest : public PASN_Sequence 3924 { 3925 #ifndef PASN_LEANANDMEAN 3926 PCLASSINFO(GCC_ConferenceInviteRequest, PASN_Sequence); 3927 #endif 3928 public: 3929 GCC_ConferenceInviteRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3930 3931 enum OptionalFields { 3932 e_conductorPrivileges, 3933 e_conductedPrivileges, 3934 e_nonConductedPrivileges, 3935 e_conferenceDescription, 3936 e_callerIdentifier, 3937 e_userData, 3938 e_conferencePriority 3939 }; 3940 3941 GCC_ConferenceName m_conferenceName; 3942 GCC_UserID m_nodeID; 3943 GCC_UserID m_topNodeID; 3944 PASN_Integer m_tag; 3945 PASN_Boolean m_passwordInTheClearRequired; 3946 PASN_Boolean m_lockedConference; 3947 PASN_Boolean m_listedConference; 3948 PASN_Boolean m_conductibleConference; 3949 GCC_TerminationMethod m_terminationMethod; 3950 GCC_ArrayOf_Privilege m_conductorPrivileges; 3951 GCC_ArrayOf_Privilege m_conductedPrivileges; 3952 GCC_ArrayOf_Privilege m_nonConductedPrivileges; 3953 GCC_TextString m_conferenceDescription; 3954 GCC_TextString m_callerIdentifier; 3955 GCC_UserData m_userData; 3956 GCC_ConferencePriority m_conferencePriority; 3957 3958 PINDEX GetDataLength() const; 3959 PBoolean Decode(PASN_Stream & strm); 3960 void Encode(PASN_Stream & strm) const; 3961 #ifndef PASN_NOPRINTON 3962 void PrintOn(ostream & strm) const; 3963 #endif 3964 Comparison Compare(const PObject & obj) const; 3965 PObject * Clone() const; 3966 }; 3967 3968 3969 // 3970 // ConferenceInviteResponse 3971 // 3972 3973 class GCC_ConferenceInviteResponse : public PASN_Sequence 3974 { 3975 #ifndef PASN_LEANANDMEAN 3976 PCLASSINFO(GCC_ConferenceInviteResponse, PASN_Sequence); 3977 #endif 3978 public: 3979 GCC_ConferenceInviteResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 3980 3981 enum OptionalFields { 3982 e_userData 3983 }; 3984 3985 GCC_ConferenceInviteResponse_result m_result; 3986 GCC_UserData m_userData; 3987 3988 PINDEX GetDataLength() const; 3989 PBoolean Decode(PASN_Stream & strm); 3990 void Encode(PASN_Stream & strm) const; 3991 #ifndef PASN_NOPRINTON 3992 void PrintOn(ostream & strm) const; 3993 #endif 3994 Comparison Compare(const PObject & obj) const; 3995 PObject * Clone() const; 3996 }; 3997 3998 3999 // 4000 // ConferenceAddResponse 4001 // 4002 4003 class GCC_ConferenceAddResponse : public PASN_Sequence 4004 { 4005 #ifndef PASN_LEANANDMEAN 4006 PCLASSINFO(GCC_ConferenceAddResponse, PASN_Sequence); 4007 #endif 4008 public: 4009 GCC_ConferenceAddResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4010 4011 enum OptionalFields { 4012 e_userData 4013 }; 4014 4015 PASN_Integer m_tag; 4016 GCC_ConferenceAddResponse_result m_result; 4017 GCC_UserData m_userData; 4018 4019 PINDEX GetDataLength() const; 4020 PBoolean Decode(PASN_Stream & strm); 4021 void Encode(PASN_Stream & strm) const; 4022 #ifndef PASN_NOPRINTON 4023 void PrintOn(ostream & strm) const; 4024 #endif 4025 Comparison Compare(const PObject & obj) const; 4026 PObject * Clone() const; 4027 }; 4028 4029 4030 // 4031 // ConferenceLockResponse 4032 // 4033 4034 class GCC_ConferenceLockResponse : public PASN_Sequence 4035 { 4036 #ifndef PASN_LEANANDMEAN 4037 PCLASSINFO(GCC_ConferenceLockResponse, PASN_Sequence); 4038 #endif 4039 public: 4040 GCC_ConferenceLockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4041 4042 GCC_ConferenceLockResponse_result m_result; 4043 4044 PINDEX GetDataLength() const; 4045 PBoolean Decode(PASN_Stream & strm); 4046 void Encode(PASN_Stream & strm) const; 4047 #ifndef PASN_NOPRINTON 4048 void PrintOn(ostream & strm) const; 4049 #endif 4050 Comparison Compare(const PObject & obj) const; 4051 PObject * Clone() const; 4052 }; 4053 4054 4055 // 4056 // ConferenceUnlockResponse 4057 // 4058 4059 class GCC_ConferenceUnlockResponse : public PASN_Sequence 4060 { 4061 #ifndef PASN_LEANANDMEAN 4062 PCLASSINFO(GCC_ConferenceUnlockResponse, PASN_Sequence); 4063 #endif 4064 public: 4065 GCC_ConferenceUnlockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4066 4067 GCC_ConferenceUnlockResponse_result m_result; 4068 4069 PINDEX GetDataLength() const; 4070 PBoolean Decode(PASN_Stream & strm); 4071 void Encode(PASN_Stream & strm) const; 4072 #ifndef PASN_NOPRINTON 4073 void PrintOn(ostream & strm) const; 4074 #endif 4075 Comparison Compare(const PObject & obj) const; 4076 PObject * Clone() const; 4077 }; 4078 4079 4080 // 4081 // ConferenceTerminateRequest 4082 // 4083 4084 class GCC_ConferenceTerminateRequest : public PASN_Sequence 4085 { 4086 #ifndef PASN_LEANANDMEAN 4087 PCLASSINFO(GCC_ConferenceTerminateRequest, PASN_Sequence); 4088 #endif 4089 public: 4090 GCC_ConferenceTerminateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4091 4092 GCC_ConferenceTerminateRequest_reason m_reason; 4093 4094 PINDEX GetDataLength() const; 4095 PBoolean Decode(PASN_Stream & strm); 4096 void Encode(PASN_Stream & strm) const; 4097 #ifndef PASN_NOPRINTON 4098 void PrintOn(ostream & strm) const; 4099 #endif 4100 Comparison Compare(const PObject & obj) const; 4101 PObject * Clone() const; 4102 }; 4103 4104 4105 // 4106 // ConferenceTerminateResponse 4107 // 4108 4109 class GCC_ConferenceTerminateResponse : public PASN_Sequence 4110 { 4111 #ifndef PASN_LEANANDMEAN 4112 PCLASSINFO(GCC_ConferenceTerminateResponse, PASN_Sequence); 4113 #endif 4114 public: 4115 GCC_ConferenceTerminateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4116 4117 GCC_ConferenceTerminateResponse_result m_result; 4118 4119 PINDEX GetDataLength() const; 4120 PBoolean Decode(PASN_Stream & strm); 4121 void Encode(PASN_Stream & strm) const; 4122 #ifndef PASN_NOPRINTON 4123 void PrintOn(ostream & strm) const; 4124 #endif 4125 Comparison Compare(const PObject & obj) const; 4126 PObject * Clone() const; 4127 }; 4128 4129 4130 // 4131 // ConferenceTerminateIndication 4132 // 4133 4134 class GCC_ConferenceTerminateIndication : public PASN_Sequence 4135 { 4136 #ifndef PASN_LEANANDMEAN 4137 PCLASSINFO(GCC_ConferenceTerminateIndication, PASN_Sequence); 4138 #endif 4139 public: 4140 GCC_ConferenceTerminateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4141 4142 GCC_ConferenceTerminateIndication_reason m_reason; 4143 4144 PINDEX GetDataLength() const; 4145 PBoolean Decode(PASN_Stream & strm); 4146 void Encode(PASN_Stream & strm) const; 4147 #ifndef PASN_NOPRINTON 4148 void PrintOn(ostream & strm) const; 4149 #endif 4150 Comparison Compare(const PObject & obj) const; 4151 PObject * Clone() const; 4152 }; 4153 4154 4155 // 4156 // ConferenceEjectUserRequest 4157 // 4158 4159 class GCC_ConferenceEjectUserRequest : public PASN_Sequence 4160 { 4161 #ifndef PASN_LEANANDMEAN 4162 PCLASSINFO(GCC_ConferenceEjectUserRequest, PASN_Sequence); 4163 #endif 4164 public: 4165 GCC_ConferenceEjectUserRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4166 4167 GCC_UserID m_nodeToEject; 4168 GCC_ConferenceEjectUserRequest_reason m_reason; 4169 4170 PINDEX GetDataLength() const; 4171 PBoolean Decode(PASN_Stream & strm); 4172 void Encode(PASN_Stream & strm) const; 4173 #ifndef PASN_NOPRINTON 4174 void PrintOn(ostream & strm) const; 4175 #endif 4176 Comparison Compare(const PObject & obj) const; 4177 PObject * Clone() const; 4178 }; 4179 4180 4181 // 4182 // ConferenceEjectUserResponse 4183 // 4184 4185 class GCC_ConferenceEjectUserResponse : public PASN_Sequence 4186 { 4187 #ifndef PASN_LEANANDMEAN 4188 PCLASSINFO(GCC_ConferenceEjectUserResponse, PASN_Sequence); 4189 #endif 4190 public: 4191 GCC_ConferenceEjectUserResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4192 4193 GCC_UserID m_nodeToEject; 4194 GCC_ConferenceEjectUserResponse_result m_result; 4195 4196 PINDEX GetDataLength() const; 4197 PBoolean Decode(PASN_Stream & strm); 4198 void Encode(PASN_Stream & strm) const; 4199 #ifndef PASN_NOPRINTON 4200 void PrintOn(ostream & strm) const; 4201 #endif 4202 Comparison Compare(const PObject & obj) const; 4203 PObject * Clone() const; 4204 }; 4205 4206 4207 // 4208 // ConferenceEjectUserIndication 4209 // 4210 4211 class GCC_ConferenceEjectUserIndication : public PASN_Sequence 4212 { 4213 #ifndef PASN_LEANANDMEAN 4214 PCLASSINFO(GCC_ConferenceEjectUserIndication, PASN_Sequence); 4215 #endif 4216 public: 4217 GCC_ConferenceEjectUserIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4218 4219 GCC_UserID m_nodeToEject; 4220 GCC_ConferenceEjectUserIndication_reason m_reason; 4221 4222 PINDEX GetDataLength() const; 4223 PBoolean Decode(PASN_Stream & strm); 4224 void Encode(PASN_Stream & strm) const; 4225 #ifndef PASN_NOPRINTON 4226 void PrintOn(ostream & strm) const; 4227 #endif 4228 Comparison Compare(const PObject & obj) const; 4229 PObject * Clone() const; 4230 }; 4231 4232 4233 // 4234 // ConferenceTransferRequest 4235 // 4236 4237 class GCC_ConferenceTransferRequest : public PASN_Sequence 4238 { 4239 #ifndef PASN_LEANANDMEAN 4240 PCLASSINFO(GCC_ConferenceTransferRequest, PASN_Sequence); 4241 #endif 4242 public: 4243 GCC_ConferenceTransferRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4244 4245 enum OptionalFields { 4246 e_conferenceNameModifier, 4247 e_networkAddress, 4248 e_transferringNodes, 4249 e_password 4250 }; 4251 4252 GCC_ConferenceNameSelector m_conferenceName; 4253 GCC_ConferenceNameModifier m_conferenceNameModifier; 4254 GCC_NetworkAddress m_networkAddress; 4255 GCC_ArrayOf_UserID m_transferringNodes; 4256 GCC_PasswordSelector m_password; 4257 4258 PINDEX GetDataLength() const; 4259 PBoolean Decode(PASN_Stream & strm); 4260 void Encode(PASN_Stream & strm) const; 4261 #ifndef PASN_NOPRINTON 4262 void PrintOn(ostream & strm) const; 4263 #endif 4264 Comparison Compare(const PObject & obj) const; 4265 PObject * Clone() const; 4266 }; 4267 4268 4269 // 4270 // ConferenceTransferResponse 4271 // 4272 4273 class GCC_ConferenceTransferResponse : public PASN_Sequence 4274 { 4275 #ifndef PASN_LEANANDMEAN 4276 PCLASSINFO(GCC_ConferenceTransferResponse, PASN_Sequence); 4277 #endif 4278 public: 4279 GCC_ConferenceTransferResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4280 4281 enum OptionalFields { 4282 e_conferenceNameModifier, 4283 e_transferringNodes 4284 }; 4285 4286 GCC_ConferenceNameSelector m_conferenceName; 4287 GCC_ConferenceNameModifier m_conferenceNameModifier; 4288 GCC_ArrayOf_UserID m_transferringNodes; 4289 GCC_ConferenceTransferResponse_result m_result; 4290 4291 PINDEX GetDataLength() const; 4292 PBoolean Decode(PASN_Stream & strm); 4293 void Encode(PASN_Stream & strm) const; 4294 #ifndef PASN_NOPRINTON 4295 void PrintOn(ostream & strm) const; 4296 #endif 4297 Comparison Compare(const PObject & obj) const; 4298 PObject * Clone() const; 4299 }; 4300 4301 4302 // 4303 // ConferenceTransferIndication 4304 // 4305 4306 class GCC_ConferenceTransferIndication : public PASN_Sequence 4307 { 4308 #ifndef PASN_LEANANDMEAN 4309 PCLASSINFO(GCC_ConferenceTransferIndication, PASN_Sequence); 4310 #endif 4311 public: 4312 GCC_ConferenceTransferIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4313 4314 enum OptionalFields { 4315 e_conferenceNameModifier, 4316 e_networkAddress, 4317 e_transferringNodes, 4318 e_password 4319 }; 4320 4321 GCC_ConferenceNameSelector m_conferenceName; 4322 GCC_ConferenceNameModifier m_conferenceNameModifier; 4323 GCC_NetworkAddress m_networkAddress; 4324 GCC_ArrayOf_UserID m_transferringNodes; 4325 GCC_PasswordSelector m_password; 4326 4327 PINDEX GetDataLength() const; 4328 PBoolean Decode(PASN_Stream & strm); 4329 void Encode(PASN_Stream & strm) const; 4330 #ifndef PASN_NOPRINTON 4331 void PrintOn(ostream & strm) const; 4332 #endif 4333 Comparison Compare(const PObject & obj) const; 4334 PObject * Clone() const; 4335 }; 4336 4337 4338 // 4339 // ApplicationInvokeIndication 4340 // 4341 4342 class GCC_ApplicationInvokeIndication : public PASN_Sequence 4343 { 4344 #ifndef PASN_LEANANDMEAN 4345 PCLASSINFO(GCC_ApplicationInvokeIndication, PASN_Sequence); 4346 #endif 4347 public: 4348 GCC_ApplicationInvokeIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4349 4350 enum OptionalFields { 4351 e_destinationNodes 4352 }; 4353 4354 GCC_ArrayOf_ApplicationInvokeSpecifier m_applicationProtocolEntiyList; 4355 GCC_ArrayOf_UserID m_destinationNodes; 4356 4357 PINDEX GetDataLength() const; 4358 PBoolean Decode(PASN_Stream & strm); 4359 void Encode(PASN_Stream & strm) const; 4360 #ifndef PASN_NOPRINTON 4361 void PrintOn(ostream & strm) const; 4362 #endif 4363 Comparison Compare(const PObject & obj) const; 4364 PObject * Clone() const; 4365 }; 4366 4367 4368 // 4369 // RegistryAllocateHandleResponse 4370 // 4371 4372 class GCC_RegistryAllocateHandleResponse : public PASN_Sequence 4373 { 4374 #ifndef PASN_LEANANDMEAN 4375 PCLASSINFO(GCC_RegistryAllocateHandleResponse, PASN_Sequence); 4376 #endif 4377 public: 4378 GCC_RegistryAllocateHandleResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4379 4380 GCC_EntityID m_entityID; 4381 PASN_Integer m_numberOfHandles; 4382 GCC_Handle m_firstHandle; 4383 GCC_RegistryAllocateHandleResponse_result m_result; 4384 4385 PINDEX GetDataLength() const; 4386 PBoolean Decode(PASN_Stream & strm); 4387 void Encode(PASN_Stream & strm) const; 4388 #ifndef PASN_NOPRINTON 4389 void PrintOn(ostream & strm) const; 4390 #endif 4391 Comparison Compare(const PObject & obj) const; 4392 PObject * Clone() const; 4393 }; 4394 4395 4396 // 4397 // RegistryResponse 4398 // 4399 4400 class GCC_RegistryResponse : public PASN_Sequence 4401 { 4402 #ifndef PASN_LEANANDMEAN 4403 PCLASSINFO(GCC_RegistryResponse, PASN_Sequence); 4404 #endif 4405 public: 4406 GCC_RegistryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4407 4408 enum OptionalFields { 4409 e_modificationRights 4410 }; 4411 4412 GCC_EntityID m_entityID; 4413 GCC_RegistryResponse_primitiveType m_primitiveType; 4414 GCC_RegistryKey m_key; 4415 GCC_RegistryItem m_item; 4416 GCC_RegistryEntryOwner m_owner; 4417 GCC_RegistryModificationRights m_modificationRights; 4418 GCC_RegistryResponse_result m_result; 4419 4420 PINDEX GetDataLength() const; 4421 PBoolean Decode(PASN_Stream & strm); 4422 void Encode(PASN_Stream & strm) const; 4423 #ifndef PASN_NOPRINTON 4424 void PrintOn(ostream & strm) const; 4425 #endif 4426 Comparison Compare(const PObject & obj) const; 4427 PObject * Clone() const; 4428 }; 4429 4430 4431 // 4432 // ConductorPermissionGrantIndication 4433 // 4434 4435 class GCC_ConductorPermissionGrantIndication : public PASN_Sequence 4436 { 4437 #ifndef PASN_LEANANDMEAN 4438 PCLASSINFO(GCC_ConductorPermissionGrantIndication, PASN_Sequence); 4439 #endif 4440 public: 4441 GCC_ConductorPermissionGrantIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4442 4443 enum OptionalFields { 4444 e_waitingList 4445 }; 4446 4447 GCC_ArrayOf_UserID m_permissionList; 4448 GCC_ArrayOf_UserID m_waitingList; 4449 4450 PINDEX GetDataLength() const; 4451 PBoolean Decode(PASN_Stream & strm); 4452 void Encode(PASN_Stream & strm) const; 4453 #ifndef PASN_NOPRINTON 4454 void PrintOn(ostream & strm) const; 4455 #endif 4456 Comparison Compare(const PObject & obj) const; 4457 PObject * Clone() const; 4458 }; 4459 4460 4461 // 4462 // FunctionNotSupportedResponse 4463 // 4464 4465 class GCC_FunctionNotSupportedResponse : public PASN_Sequence 4466 { 4467 #ifndef PASN_LEANANDMEAN 4468 PCLASSINFO(GCC_FunctionNotSupportedResponse, PASN_Sequence); 4469 #endif 4470 public: 4471 GCC_FunctionNotSupportedResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4472 4473 GCC_RequestPDU m_request; 4474 4475 PINDEX GetDataLength() const; 4476 PBoolean Decode(PASN_Stream & strm); 4477 void Encode(PASN_Stream & strm) const; 4478 #ifndef PASN_NOPRINTON 4479 void PrintOn(ostream & strm) const; 4480 #endif 4481 Comparison Compare(const PObject & obj) const; 4482 PObject * Clone() const; 4483 }; 4484 4485 4486 // 4487 // PasswordChallengeRequestResponse_challengeRequestResponse 4488 // 4489 4490 class GCC_PasswordChallengeRequestResponse_challengeRequestResponse : public PASN_Sequence 4491 { 4492 #ifndef PASN_LEANANDMEAN 4493 PCLASSINFO(GCC_PasswordChallengeRequestResponse_challengeRequestResponse, PASN_Sequence); 4494 #endif 4495 public: 4496 GCC_PasswordChallengeRequestResponse_challengeRequestResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4497 4498 enum OptionalFields { 4499 e_challengeRequest, 4500 e_challengeResponse 4501 }; 4502 4503 GCC_ChallengeRequest m_challengeRequest; 4504 GCC_ChallengeResponse m_challengeResponse; 4505 4506 PINDEX GetDataLength() const; 4507 PBoolean Decode(PASN_Stream & strm); 4508 void Encode(PASN_Stream & strm) const; 4509 #ifndef PASN_NOPRINTON 4510 void PrintOn(ostream & strm) const; 4511 #endif 4512 Comparison Compare(const PObject & obj) const; 4513 PObject * Clone() const; 4514 }; 4515 4516 4517 // 4518 // RosterUpdateIndication_nodeInformation 4519 // 4520 4521 class GCC_RosterUpdateIndication_nodeInformation : public PASN_Sequence 4522 { 4523 #ifndef PASN_LEANANDMEAN 4524 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation, PASN_Sequence); 4525 #endif 4526 public: 4527 GCC_RosterUpdateIndication_nodeInformation(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4528 4529 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList m_nodeRecordList; 4530 PASN_Integer m_rosterInstanceNumber; 4531 PASN_Boolean m_nodesAdded; 4532 PASN_Boolean m_nodesRemoved; 4533 4534 PINDEX GetDataLength() const; 4535 PBoolean Decode(PASN_Stream & strm); 4536 void Encode(PASN_Stream & strm) const; 4537 #ifndef PASN_NOPRINTON 4538 void PrintOn(ostream & strm) const; 4539 #endif 4540 Comparison Compare(const PObject & obj) const; 4541 PObject * Clone() const; 4542 }; 4543 4544 4545 // 4546 // NetworkAddress_subtype_aggregatedChannel 4547 // 4548 4549 class GCC_NetworkAddress_subtype_aggregatedChannel : public PASN_Sequence 4550 { 4551 #ifndef PASN_LEANANDMEAN 4552 PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel, PASN_Sequence); 4553 #endif 4554 public: 4555 GCC_NetworkAddress_subtype_aggregatedChannel(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4556 4557 enum OptionalFields { 4558 e_subAddress, 4559 e_extraDialing, 4560 e_highLayerCompatibility 4561 }; 4562 4563 GCC_NetworkAddress_subtype_aggregatedChannel_transferModes m_transferModes; 4564 GCC_DialingString m_internationalNumber; 4565 GCC_SubAddressString m_subAddress; 4566 GCC_ExtraDialingString m_extraDialing; 4567 GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility m_highLayerCompatibility; 4568 4569 PINDEX GetDataLength() const; 4570 PBoolean Decode(PASN_Stream & strm); 4571 void Encode(PASN_Stream & strm) const; 4572 #ifndef PASN_NOPRINTON 4573 void PrintOn(ostream & strm) const; 4574 #endif 4575 Comparison Compare(const PObject & obj) const; 4576 PObject * Clone() const; 4577 }; 4578 4579 4580 // 4581 // RosterUpdateIndication_applicationInformation_subtype 4582 // 4583 4584 class GCC_RosterUpdateIndication_applicationInformation_subtype : public PASN_Sequence 4585 { 4586 #ifndef PASN_LEANANDMEAN 4587 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype, PASN_Sequence); 4588 #endif 4589 public: 4590 GCC_RosterUpdateIndication_applicationInformation_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4591 4592 GCC_SessionKey m_sessionKey; 4593 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList m_applicationRecordList; 4594 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList m_applicationCapabilitiesList; 4595 PASN_Integer m_rosterInstanceNumber; 4596 PASN_Boolean m_peerEntitiesAdded; 4597 PASN_Boolean m_peerEntitiesRemoved; 4598 4599 PINDEX GetDataLength() const; 4600 PBoolean Decode(PASN_Stream & strm); 4601 void Encode(PASN_Stream & strm) const; 4602 #ifndef PASN_NOPRINTON 4603 void PrintOn(ostream & strm) const; 4604 #endif 4605 Comparison Compare(const PObject & obj) const; 4606 PObject * Clone() const; 4607 }; 4608 4609 4610 // 4611 // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype 4612 // 4613 4614 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype : public PASN_Sequence 4615 { 4616 #ifndef PASN_LEANANDMEAN 4617 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype, PASN_Sequence); 4618 #endif 4619 public: 4620 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4621 4622 GCC_UserID m_nodeID; 4623 GCC_NodeRecord m_nodeRecord; 4624 4625 PINDEX GetDataLength() const; 4626 PBoolean Decode(PASN_Stream & strm); 4627 void Encode(PASN_Stream & strm) const; 4628 #ifndef PASN_NOPRINTON 4629 void PrintOn(ostream & strm) const; 4630 #endif 4631 Comparison Compare(const PObject & obj) const; 4632 PObject * Clone() const; 4633 }; 4634 4635 4636 // 4637 // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype 4638 // 4639 4640 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype : public PASN_Sequence 4641 { 4642 #ifndef PASN_LEANANDMEAN 4643 PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype, PASN_Sequence); 4644 #endif 4645 public: 4646 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4647 4648 GCC_UserID m_nodeID; 4649 GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate m_nodeUpdate; 4650 4651 PINDEX GetDataLength() const; 4652 PBoolean Decode(PASN_Stream & strm); 4653 void Encode(PASN_Stream & strm) const; 4654 #ifndef PASN_NOPRINTON 4655 void PrintOn(ostream & strm) const; 4656 #endif 4657 Comparison Compare(const PObject & obj) const; 4658 PObject * Clone() const; 4659 }; 4660 4661 4662 // 4663 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype 4664 // 4665 4666 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype : public PASN_Sequence 4667 { 4668 #ifndef PASN_LEANANDMEAN 4669 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype, PASN_Sequence); 4670 #endif 4671 public: 4672 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4673 4674 GCC_UserID m_nodeID; 4675 GCC_EntityID m_entityID; 4676 GCC_ApplicationRecord m_applicationRecord; 4677 4678 PINDEX GetDataLength() const; 4679 PBoolean Decode(PASN_Stream & strm); 4680 void Encode(PASN_Stream & strm) const; 4681 #ifndef PASN_NOPRINTON 4682 void PrintOn(ostream & strm) const; 4683 #endif 4684 Comparison Compare(const PObject & obj) const; 4685 PObject * Clone() const; 4686 }; 4687 4688 4689 // 4690 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype 4691 // 4692 4693 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype : public PASN_Sequence 4694 { 4695 #ifndef PASN_LEANANDMEAN 4696 PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype, PASN_Sequence); 4697 #endif 4698 public: 4699 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4700 4701 GCC_UserID m_nodeID; 4702 GCC_EntityID m_entityID; 4703 GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate m_applicationUpdate; 4704 4705 PINDEX GetDataLength() const; 4706 PBoolean Decode(PASN_Stream & strm); 4707 void Encode(PASN_Stream & strm) const; 4708 #ifndef PASN_NOPRINTON 4709 void PrintOn(ostream & strm) const; 4710 #endif 4711 Comparison Compare(const PObject & obj) const; 4712 PObject * Clone() const; 4713 }; 4714 4715 4716 // 4717 // RosterUpdateIndication 4718 // 4719 4720 class GCC_RosterUpdateIndication : public PASN_Sequence 4721 { 4722 #ifndef PASN_LEANANDMEAN 4723 PCLASSINFO(GCC_RosterUpdateIndication, PASN_Sequence); 4724 #endif 4725 public: 4726 GCC_RosterUpdateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass); 4727 4728 PASN_Boolean m_fullRefresh; 4729 GCC_RosterUpdateIndication_nodeInformation m_nodeInformation; 4730 GCC_RosterUpdateIndication_applicationInformation m_applicationInformation; 4731 4732 PINDEX GetDataLength() const; 4733 PBoolean Decode(PASN_Stream & strm); 4734 void Encode(PASN_Stream & strm) const; 4735 #ifndef PASN_NOPRINTON 4736 void PrintOn(ostream & strm) const; 4737 #endif 4738 Comparison Compare(const PObject & obj) const; 4739 PObject * Clone() const; 4740 }; 4741 4742 4743 #endif // __GCC_H 4744 4745 #endif // if ! H323_DISABLE_GCC 4746 4747 4748 // End of gccpdu.h 4749