include/gccpdu.h

   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     BOOL 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     BOOL 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 PWORDArray & 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 PWORDArray & 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 PWORDArray & 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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     BOOL 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