# gcc.h

Go to the documentation of this file.

    00001 //
    00002 // gccpdu.h
    00003 //
    00004 // Code automatically generated by asnparse.
    00005 //
    00006
    00007 #if ! H323_DISABLE_GCC
    00008
    00009 #ifndef __GCC_H
    00010 #define __GCC_H
    00011
    00012 #ifdef P_USE_PRAGMA
    00013 #pragma interface
    00014 #endif
    00015
    00016 #include <ptclib/asner.h>
    00017
    00018 //
    00019 // ChannelID
    00020 //
    00021
    00022 class GCC_ChannelID : public PASN_Integer
    00023 {
    00024 #ifndef PASN_LEANANDMEAN
    00025     PCLASSINFO(GCC_ChannelID, PASN_Integer);
    00026 #endif
    00027   public:
    00028     GCC_ChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00029
    00030     GCC_ChannelID & operator=(int v);
    00031     GCC_ChannelID & operator=(unsigned v);
    00032     PObject * Clone() const;
    00033 };
    00034
    00035
    00036 //
    00037 // StaticChannelID
    00038 //
    00039
    00040 class GCC_StaticChannelID : public PASN_Integer
    00041 {
    00042 #ifndef PASN_LEANANDMEAN
    00043     PCLASSINFO(GCC_StaticChannelID, PASN_Integer);
    00044 #endif
    00045   public:
    00046     GCC_StaticChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00047
    00048     GCC_StaticChannelID & operator=(int v);
    00049     GCC_StaticChannelID & operator=(unsigned v);
    00050     PObject * Clone() const;
    00051 };
    00052
    00053
    00054 //
    00055 // DynamicChannelID
    00056 //
    00057
    00058 class GCC_DynamicChannelID : public PASN_Integer
    00059 {
    00060 #ifndef PASN_LEANANDMEAN
    00061     PCLASSINFO(GCC_DynamicChannelID, PASN_Integer);
    00062 #endif
    00063   public:
    00064     GCC_DynamicChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00065
    00066     GCC_DynamicChannelID & operator=(int v);
    00067     GCC_DynamicChannelID & operator=(unsigned v);
    00068     PObject * Clone() const;
    00069 };
    00070
    00071
    00072 //
    00073 // UserID
    00074 //
    00075
    00076 class GCC_UserID : public GCC_DynamicChannelID
    00077 {
    00078 #ifndef PASN_LEANANDMEAN
    00079     PCLASSINFO(GCC_UserID, GCC_DynamicChannelID);
    00080 #endif
    00081   public:
    00082     GCC_UserID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00083
    00084     GCC_UserID & operator=(int v);
    00085     GCC_UserID & operator=(unsigned v);
    00086     PObject * Clone() const;
    00087 };
    00088
    00089
    00090 //
    00091 // TokenID
    00092 //
    00093
    00094 class GCC_TokenID : public PASN_Integer
    00095 {
    00096 #ifndef PASN_LEANANDMEAN
    00097     PCLASSINFO(GCC_TokenID, PASN_Integer);
    00098 #endif
    00099   public:
    00100     GCC_TokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00101
    00102     GCC_TokenID & operator=(int v);
    00103     GCC_TokenID & operator=(unsigned v);
    00104     PObject * Clone() const;
    00105 };
    00106
    00107
    00108 //
    00109 // StaticTokenID
    00110 //
    00111
    00112 class GCC_StaticTokenID : public PASN_Integer
    00113 {
    00114 #ifndef PASN_LEANANDMEAN
    00115     PCLASSINFO(GCC_StaticTokenID, PASN_Integer);
    00116 #endif
    00117   public:
    00118     GCC_StaticTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00119
    00120     GCC_StaticTokenID & operator=(int v);
    00121     GCC_StaticTokenID & operator=(unsigned v);
    00122     PObject * Clone() const;
    00123 };
    00124
    00125
    00126 //
    00127 // DynamicTokenID
    00128 //
    00129
    00130 class GCC_DynamicTokenID : public PASN_Integer
    00131 {
    00132 #ifndef PASN_LEANANDMEAN
    00133     PCLASSINFO(GCC_DynamicTokenID, PASN_Integer);
    00134 #endif
    00135   public:
    00136     GCC_DynamicTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00137
    00138     GCC_DynamicTokenID & operator=(int v);
    00139     GCC_DynamicTokenID & operator=(unsigned v);
    00140     PObject * Clone() const;
    00141 };
    00142
    00143
    00144 //
    00145 // Time
    00146 //
    00147
    00148 class GCC_Time : public PASN_Integer
    00149 {
    00150 #ifndef PASN_LEANANDMEAN
    00151     PCLASSINFO(GCC_Time, PASN_Integer);
    00152 #endif
    00153   public:
    00154     GCC_Time(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00155
    00156     GCC_Time & operator=(int v);
    00157     GCC_Time & operator=(unsigned v);
    00158     PObject * Clone() const;
    00159 };
    00160
    00161
    00162 //
    00163 // Handle
    00164 //
    00165
    00166 class GCC_Handle : public PASN_Integer
    00167 {
    00168 #ifndef PASN_LEANANDMEAN
    00169     PCLASSINFO(GCC_Handle, PASN_Integer);
    00170 #endif
    00171   public:
    00172     GCC_Handle(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    00173
    00174     GCC_Handle & operator=(int v);
    00175     GCC_Handle & operator=(unsigned v);
    00176     PObject * Clone() const;
    00177 };
    00178
    00179
    00180 //
    00181 // H221NonStandardIdentifier
    00182 //
    00183
    00184 class GCC_H221NonStandardIdentifier : public PASN_OctetString
    00185 {
    00186 #ifndef PASN_LEANANDMEAN
    00187     PCLASSINFO(GCC_H221NonStandardIdentifier, PASN_OctetString);
    00188 #endif
    00189   public:
    00190     GCC_H221NonStandardIdentifier(unsigned tag = UniversalOctetString, TagClass tagClass = UniversalTagClass);
    00191
    00192     GCC_H221NonStandardIdentifier(const char * v);
    00193     GCC_H221NonStandardIdentifier(const PString & v);
    00194     GCC_H221NonStandardIdentifier(const PBYTEArray & v);
    00195
    00196     GCC_H221NonStandardIdentifier & operator=(const char * v);
    00197     GCC_H221NonStandardIdentifier & operator=(const PString & v);
    00198     GCC_H221NonStandardIdentifier & operator=(const PBYTEArray & v);
    00199     PObject * Clone() const;
    00200 };
    00201
    00202
    00203 //
    00204 // Key
    00205 //
    00206
    00207 class GCC_H221NonStandardIdentifier;
    00208
    00209 class GCC_Key : public PASN_Choice
    00210 {
    00211 #ifndef PASN_LEANANDMEAN
    00212     PCLASSINFO(GCC_Key, PASN_Choice);
    00213 #endif
    00214   public:
    00215     GCC_Key(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00216
    00217     enum Choices {
    00218       e_object,
    00219       e_h221NonStandard
    00220     };
    00221
    00222 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00223     operator GCC_H221NonStandardIdentifier &() const;
    00224 #else
    00225     operator GCC_H221NonStandardIdentifier &();
    00226     operator const GCC_H221NonStandardIdentifier &() const;
    00227 #endif
    00228
    00229     PBoolean CreateObject();
    00230     PObject * Clone() const;
    00231 };
    00232
    00233
    00234 //
    00235 // NonStandardParameter
    00236 //
    00237
    00238 class GCC_NonStandardParameter : public PASN_Sequence
    00239 {
    00240 #ifndef PASN_LEANANDMEAN
    00241     PCLASSINFO(GCC_NonStandardParameter, PASN_Sequence);
    00242 #endif
    00243   public:
    00244     GCC_NonStandardParameter(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00245
    00246     GCC_Key m_key;
    00247     PASN_OctetString m_data;
    00248
    00249     PINDEX GetDataLength() const;
    00250     PBoolean Decode(PASN_Stream & strm);
    00251     void Encode(PASN_Stream & strm) const;
    00252 #ifndef PASN_NOPRINTON
    00253     void PrintOn(ostream & strm) const;
    00254 #endif
    00255     Comparison Compare(const PObject & obj) const;
    00256     PObject * Clone() const;
    00257 };
    00258
    00259
    00260 //
    00261 // TextString
    00262 //
    00263
    00264 class GCC_TextString : public PASN_BMPString
    00265 {
    00266 #ifndef PASN_LEANANDMEAN
    00267     PCLASSINFO(GCC_TextString, PASN_BMPString);
    00268 #endif
    00269   public:
    00270     GCC_TextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);
    00271
    00272     GCC_TextString & operator=(const char * v);
    00273     GCC_TextString & operator=(const PString & v);
    00274     GCC_TextString & operator=(const PWCharArray & v);
    00275     GCC_TextString & operator=(const PASN_BMPString & v);
    00276     PObject * Clone() const;
    00277 };
    00278
    00279
    00280 //
    00281 // SimpleTextString
    00282 //
    00283
    00284 class GCC_SimpleTextString : public PASN_BMPString
    00285 {
    00286 #ifndef PASN_LEANANDMEAN
    00287     PCLASSINFO(GCC_SimpleTextString, PASN_BMPString);
    00288 #endif
    00289   public:
    00290     GCC_SimpleTextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);
    00291
    00292     GCC_SimpleTextString & operator=(const char * v);
    00293     GCC_SimpleTextString & operator=(const PString & v);
    00294     GCC_SimpleTextString & operator=(const PWCharArray & v);
    00295     GCC_SimpleTextString & operator=(const PASN_BMPString & v);
    00296     PObject * Clone() const;
    00297 };
    00298
    00299
    00300 //
    00301 // SimpleNumericString
    00302 //
    00303
    00304 class GCC_SimpleNumericString : public PASN_NumericString
    00305 {
    00306 #ifndef PASN_LEANANDMEAN
    00307     PCLASSINFO(GCC_SimpleNumericString, PASN_NumericString);
    00308 #endif
    00309   public:
    00310     GCC_SimpleNumericString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);
    00311
    00312     GCC_SimpleNumericString & operator=(const char * v);
    00313     GCC_SimpleNumericString & operator=(const PString & v);
    00314     PObject * Clone() const;
    00315 };
    00316
    00317
    00318 //
    00319 // DialingString
    00320 //
    00321
    00322 class GCC_DialingString : public PASN_NumericString
    00323 {
    00324 #ifndef PASN_LEANANDMEAN
    00325     PCLASSINFO(GCC_DialingString, PASN_NumericString);
    00326 #endif
    00327   public:
    00328     GCC_DialingString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);
    00329
    00330     GCC_DialingString & operator=(const char * v);
    00331     GCC_DialingString & operator=(const PString & v);
    00332     PObject * Clone() const;
    00333 };
    00334
    00335
    00336 //
    00337 // SubAddressString
    00338 //
    00339
    00340 class GCC_SubAddressString : public PASN_NumericString
    00341 {
    00342 #ifndef PASN_LEANANDMEAN
    00343     PCLASSINFO(GCC_SubAddressString, PASN_NumericString);
    00344 #endif
    00345   public:
    00346     GCC_SubAddressString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);
    00347
    00348     GCC_SubAddressString & operator=(const char * v);
    00349     GCC_SubAddressString & operator=(const PString & v);
    00350     PObject * Clone() const;
    00351 };
    00352
    00353
    00354 //
    00355 // ExtraDialingString
    00356 //
    00357
    00358 class GCC_ExtraDialingString : public PASN_BMPString
    00359 {
    00360 #ifndef PASN_LEANANDMEAN
    00361     PCLASSINFO(GCC_ExtraDialingString, PASN_BMPString);
    00362 #endif
    00363   public:
    00364     GCC_ExtraDialingString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);
    00365
    00366     GCC_ExtraDialingString & operator=(const char * v);
    00367     GCC_ExtraDialingString & operator=(const PString & v);
    00368     GCC_ExtraDialingString & operator=(const PWCharArray & v);
    00369     GCC_ExtraDialingString & operator=(const PASN_BMPString & v);
    00370     PObject * Clone() const;
    00371 };
    00372
    00373
    00374 //
    00375 // UserData
    00376 //
    00377
    00378 class GCC_UserData_subtype;
    00379
    00380 class GCC_UserData : public PASN_Array
    00381 {
    00382 #ifndef PASN_LEANANDMEAN
    00383     PCLASSINFO(GCC_UserData, PASN_Array);
    00384 #endif
    00385   public:
    00386     GCC_UserData(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    00387
    00388     PASN_Object * CreateObject() const;
    00389     GCC_UserData_subtype & operator[](PINDEX i) const;
    00390     PObject * Clone() const;
    00391 };
    00392
    00393
    00394 //
    00395 // Password
    00396 //
    00397
    00398 class GCC_Password : public PASN_Sequence
    00399 {
    00400 #ifndef PASN_LEANANDMEAN
    00401     PCLASSINFO(GCC_Password, PASN_Sequence);
    00402 #endif
    00403   public:
    00404     GCC_Password(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00405
    00406     enum OptionalFields {
    00407       e_text
    00408     };
    00409
    00410     GCC_SimpleNumericString m_numeric;
    00411     GCC_SimpleTextString m_text;
    00412
    00413     PINDEX GetDataLength() const;
    00414     PBoolean Decode(PASN_Stream & strm);
    00415     void Encode(PASN_Stream & strm) const;
    00416 #ifndef PASN_NOPRINTON
    00417     void PrintOn(ostream & strm) const;
    00418 #endif
    00419     Comparison Compare(const PObject & obj) const;
    00420     PObject * Clone() const;
    00421 };
    00422
    00423
    00424 //
    00425 // PasswordSelector
    00426 //
    00427
    00428 class GCC_SimpleNumericString;
    00429 class GCC_SimpleTextString;
    00430
    00431 class GCC_PasswordSelector : public PASN_Choice
    00432 {
    00433 #ifndef PASN_LEANANDMEAN
    00434     PCLASSINFO(GCC_PasswordSelector, PASN_Choice);
    00435 #endif
    00436   public:
    00437     GCC_PasswordSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00438
    00439     enum Choices {
    00440       e_numeric,
    00441       e_text
    00442     };
    00443
    00444 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00445     operator GCC_SimpleNumericString &() const;
    00446 #else
    00447     operator GCC_SimpleNumericString &();
    00448     operator const GCC_SimpleNumericString &() const;
    00449 #endif
    00450 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00451     operator GCC_SimpleTextString &() const;
    00452 #else
    00453     operator GCC_SimpleTextString &();
    00454     operator const GCC_SimpleTextString &() const;
    00455 #endif
    00456
    00457     PBoolean CreateObject();
    00458     PObject * Clone() const;
    00459 };
    00460
    00461
    00462 //
    00463 // ChallengeResponseItem
    00464 //
    00465
    00466 class GCC_PasswordSelector;
    00467 class GCC_UserData;
    00468
    00469 class GCC_ChallengeResponseItem : public PASN_Choice
    00470 {
    00471 #ifndef PASN_LEANANDMEAN
    00472     PCLASSINFO(GCC_ChallengeResponseItem, PASN_Choice);
    00473 #endif
    00474   public:
    00475     GCC_ChallengeResponseItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00476
    00477     enum Choices {
    00478       e_passwordString,
    00479       e_responseData
    00480     };
    00481
    00482 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00483     operator GCC_PasswordSelector &() const;
    00484 #else
    00485     operator GCC_PasswordSelector &();
    00486     operator const GCC_PasswordSelector &() const;
    00487 #endif
    00488 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00489     operator GCC_UserData &() const;
    00490 #else
    00491     operator GCC_UserData &();
    00492     operator const GCC_UserData &() const;
    00493 #endif
    00494
    00495     PBoolean CreateObject();
    00496     PObject * Clone() const;
    00497 };
    00498
    00499
    00500 //
    00501 // ChallengeResponseAlgorithm
    00502 //
    00503
    00504 class GCC_NonStandardParameter;
    00505
    00506 class GCC_ChallengeResponseAlgorithm : public PASN_Choice
    00507 {
    00508 #ifndef PASN_LEANANDMEAN
    00509     PCLASSINFO(GCC_ChallengeResponseAlgorithm, PASN_Choice);
    00510 #endif
    00511   public:
    00512     GCC_ChallengeResponseAlgorithm(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00513
    00514     enum Choices {
    00515       e_passwordInTheClear,
    00516       e_nonStandardAlgorithm
    00517     };
    00518
    00519 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00520     operator GCC_NonStandardParameter &() const;
    00521 #else
    00522     operator GCC_NonStandardParameter &();
    00523     operator const GCC_NonStandardParameter &() const;
    00524 #endif
    00525
    00526     PBoolean CreateObject();
    00527     PObject * Clone() const;
    00528 };
    00529
    00530
    00531 //
    00532 // ChallengeItem
    00533 //
    00534
    00535 class GCC_ChallengeItem : public PASN_Sequence
    00536 {
    00537 #ifndef PASN_LEANANDMEAN
    00538     PCLASSINFO(GCC_ChallengeItem, PASN_Sequence);
    00539 #endif
    00540   public:
    00541     GCC_ChallengeItem(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00542
    00543     GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    00544     GCC_UserData m_challengeData;
    00545
    00546     PINDEX GetDataLength() const;
    00547     PBoolean Decode(PASN_Stream & strm);
    00548     void Encode(PASN_Stream & strm) const;
    00549 #ifndef PASN_NOPRINTON
    00550     void PrintOn(ostream & strm) const;
    00551 #endif
    00552     Comparison Compare(const PObject & obj) const;
    00553     PObject * Clone() const;
    00554 };
    00555
    00556
    00557 //
    00558 // ChallengeResponse
    00559 //
    00560
    00561 class GCC_ChallengeResponse : public PASN_Sequence
    00562 {
    00563 #ifndef PASN_LEANANDMEAN
    00564     PCLASSINFO(GCC_ChallengeResponse, PASN_Sequence);
    00565 #endif
    00566   public:
    00567     GCC_ChallengeResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00568
    00569     PASN_Integer m_challengeTag;
    00570     GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    00571     GCC_ChallengeResponseItem m_responseItem;
    00572
    00573     PINDEX GetDataLength() const;
    00574     PBoolean Decode(PASN_Stream & strm);
    00575     void Encode(PASN_Stream & strm) const;
    00576 #ifndef PASN_NOPRINTON
    00577     void PrintOn(ostream & strm) const;
    00578 #endif
    00579     Comparison Compare(const PObject & obj) const;
    00580     PObject * Clone() const;
    00581 };
    00582
    00583
    00584 //
    00585 // PasswordChallengeRequestResponse
    00586 //
    00587
    00588 class GCC_PasswordSelector;
    00589 class GCC_PasswordChallengeRequestResponse_challengeRequestResponse;
    00590
    00591 class GCC_PasswordChallengeRequestResponse : public PASN_Choice
    00592 {
    00593 #ifndef PASN_LEANANDMEAN
    00594     PCLASSINFO(GCC_PasswordChallengeRequestResponse, PASN_Choice);
    00595 #endif
    00596   public:
    00597     GCC_PasswordChallengeRequestResponse(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00598
    00599     enum Choices {
    00600       e_passwordInTheClear,
    00601       e_challengeRequestResponse
    00602     };
    00603
    00604 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00605     operator GCC_PasswordSelector &() const;
    00606 #else
    00607     operator GCC_PasswordSelector &();
    00608     operator const GCC_PasswordSelector &() const;
    00609 #endif
    00610 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00611     operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
    00612 #else
    00613     operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &();
    00614     operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
    00615 #endif
    00616
    00617     PBoolean CreateObject();
    00618     PObject * Clone() const;
    00619 };
    00620
    00621
    00622 //
    00623 // ConferenceName
    00624 //
    00625
    00626 class GCC_ConferenceName : public PASN_Sequence
    00627 {
    00628 #ifndef PASN_LEANANDMEAN
    00629     PCLASSINFO(GCC_ConferenceName, PASN_Sequence);
    00630 #endif
    00631   public:
    00632     GCC_ConferenceName(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00633
    00634     enum OptionalFields {
    00635       e_text
    00636     };
    00637
    00638     GCC_SimpleNumericString m_numeric;
    00639     GCC_SimpleTextString m_text;
    00640
    00641     PINDEX GetDataLength() const;
    00642     PBoolean Decode(PASN_Stream & strm);
    00643     void Encode(PASN_Stream & strm) const;
    00644 #ifndef PASN_NOPRINTON
    00645     void PrintOn(ostream & strm) const;
    00646 #endif
    00647     Comparison Compare(const PObject & obj) const;
    00648     PObject * Clone() const;
    00649 };
    00650
    00651
    00652 //
    00653 // ConferenceNameSelector
    00654 //
    00655
    00656 class GCC_SimpleNumericString;
    00657 class GCC_SimpleTextString;
    00658
    00659 class GCC_ConferenceNameSelector : public PASN_Choice
    00660 {
    00661 #ifndef PASN_LEANANDMEAN
    00662     PCLASSINFO(GCC_ConferenceNameSelector, PASN_Choice);
    00663 #endif
    00664   public:
    00665     GCC_ConferenceNameSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00666
    00667     enum Choices {
    00668       e_numeric,
    00669       e_text
    00670     };
    00671
    00672 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00673     operator GCC_SimpleNumericString &() const;
    00674 #else
    00675     operator GCC_SimpleNumericString &();
    00676     operator const GCC_SimpleNumericString &() const;
    00677 #endif
    00678 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00679     operator GCC_SimpleTextString &() const;
    00680 #else
    00681     operator GCC_SimpleTextString &();
    00682     operator const GCC_SimpleTextString &() const;
    00683 #endif
    00684
    00685     PBoolean CreateObject();
    00686     PObject * Clone() const;
    00687 };
    00688
    00689
    00690 //
    00691 // ConferenceNameModifier
    00692 //
    00693
    00694 class GCC_ConferenceNameModifier : public GCC_SimpleNumericString
    00695 {
    00696 #ifndef PASN_LEANANDMEAN
    00697     PCLASSINFO(GCC_ConferenceNameModifier, GCC_SimpleNumericString);
    00698 #endif
    00699   public:
    00700     GCC_ConferenceNameModifier(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);
    00701
    00702     GCC_ConferenceNameModifier & operator=(const char * v);
    00703     GCC_ConferenceNameModifier & operator=(const PString & v);
    00704     PObject * Clone() const;
    00705 };
    00706
    00707
    00708 //
    00709 // Privilege
    00710 //
    00711
    00712 class GCC_Privilege : public PASN_Enumeration
    00713 {
    00714 #ifndef PASN_LEANANDMEAN
    00715     PCLASSINFO(GCC_Privilege, PASN_Enumeration);
    00716 #endif
    00717   public:
    00718     GCC_Privilege(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    00719
    00720     enum Enumerations {
    00721       e_terminate,
    00722       e_ejectUser,
    00723       e_add,
    00724       e_lockUnlock,
    00725       e_transfer
    00726     };
    00727
    00728     GCC_Privilege & operator=(unsigned v);
    00729     PObject * Clone() const;
    00730 };
    00731
    00732
    00733 //
    00734 // TerminationMethod
    00735 //
    00736
    00737 class GCC_TerminationMethod : public PASN_Enumeration
    00738 {
    00739 #ifndef PASN_LEANANDMEAN
    00740     PCLASSINFO(GCC_TerminationMethod, PASN_Enumeration);
    00741 #endif
    00742   public:
    00743     GCC_TerminationMethod(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    00744
    00745     enum Enumerations {
    00746       e_automatic,
    00747       e_manual
    00748     };
    00749
    00750     GCC_TerminationMethod & operator=(unsigned v);
    00751     PObject * Clone() const;
    00752 };
    00753
    00754
    00755 //
    00756 // ConferencePriorityScheme
    00757 //
    00758
    00759 class GCC_NonStandardParameter;
    00760
    00761 class GCC_ConferencePriorityScheme : public PASN_Choice
    00762 {
    00763 #ifndef PASN_LEANANDMEAN
    00764     PCLASSINFO(GCC_ConferencePriorityScheme, PASN_Choice);
    00765 #endif
    00766   public:
    00767     GCC_ConferencePriorityScheme(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00768
    00769     enum Choices {
    00770       e_nonStandardScheme
    00771     };
    00772
    00773 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    00774     operator GCC_NonStandardParameter &() const;
    00775 #else
    00776     operator GCC_NonStandardParameter &();
    00777     operator const GCC_NonStandardParameter &() const;
    00778 #endif
    00779
    00780     PBoolean CreateObject();
    00781     PObject * Clone() const;
    00782 };
    00783
    00784
    00785 //
    00786 // ConferencePriority
    00787 //
    00788
    00789 class GCC_ConferencePriority : public PASN_Sequence
    00790 {
    00791 #ifndef PASN_LEANANDMEAN
    00792     PCLASSINFO(GCC_ConferencePriority, PASN_Sequence);
    00793 #endif
    00794   public:
    00795     GCC_ConferencePriority(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00796
    00797     PASN_Integer m_priority;
    00798     GCC_ConferencePriorityScheme m_scheme;
    00799
    00800     PINDEX GetDataLength() const;
    00801     PBoolean Decode(PASN_Stream & strm);
    00802     void Encode(PASN_Stream & strm) const;
    00803 #ifndef PASN_NOPRINTON
    00804     void PrintOn(ostream & strm) const;
    00805 #endif
    00806     Comparison Compare(const PObject & obj) const;
    00807     PObject * Clone() const;
    00808 };
    00809
    00810
    00811 //
    00812 // NetworkAddress
    00813 //
    00814
    00815 class GCC_NetworkAddress_subtype;
    00816
    00817 class GCC_NetworkAddress : public PASN_Array
    00818 {
    00819 #ifndef PASN_LEANANDMEAN
    00820     PCLASSINFO(GCC_NetworkAddress, PASN_Array);
    00821 #endif
    00822   public:
    00823     GCC_NetworkAddress(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00824
    00825     PASN_Object * CreateObject() const;
    00826     GCC_NetworkAddress_subtype & operator[](PINDEX i) const;
    00827     PObject * Clone() const;
    00828 };
    00829
    00830
    00831 //
    00832 // NodeType
    00833 //
    00834
    00835 class GCC_NodeType : public PASN_Enumeration
    00836 {
    00837 #ifndef PASN_LEANANDMEAN
    00838     PCLASSINFO(GCC_NodeType, PASN_Enumeration);
    00839 #endif
    00840   public:
    00841     GCC_NodeType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    00842
    00843     enum Enumerations {
    00844       e_terminal,
    00845       e_multiportTerminal,
    00846       e_mcu
    00847     };
    00848
    00849     GCC_NodeType & operator=(unsigned v);
    00850     PObject * Clone() const;
    00851 };
    00852
    00853
    00854 //
    00855 // NodeProperties
    00856 //
    00857
    00858 class GCC_NodeProperties : public PASN_Sequence
    00859 {
    00860 #ifndef PASN_LEANANDMEAN
    00861     PCLASSINFO(GCC_NodeProperties, PASN_Sequence);
    00862 #endif
    00863   public:
    00864     GCC_NodeProperties(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00865
    00866     PASN_Boolean m_managementDevice;
    00867     PASN_Boolean m_peripheralDevice;
    00868
    00869     PINDEX GetDataLength() const;
    00870     PBoolean Decode(PASN_Stream & strm);
    00871     void Encode(PASN_Stream & strm) const;
    00872 #ifndef PASN_NOPRINTON
    00873     void PrintOn(ostream & strm) const;
    00874 #endif
    00875     Comparison Compare(const PObject & obj) const;
    00876     PObject * Clone() const;
    00877 };
    00878
    00879
    00880 //
    00881 // AsymmetryIndicator
    00882 //
    00883
    00884 class GCC_AsymmetryIndicator : public PASN_Choice
    00885 {
    00886 #ifndef PASN_LEANANDMEAN
    00887     PCLASSINFO(GCC_AsymmetryIndicator, PASN_Choice);
    00888 #endif
    00889   public:
    00890     GCC_AsymmetryIndicator(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00891
    00892     enum Choices {
    00893       e_callingNode,
    00894       e_calledNode,
    00895       e_unknown
    00896     };
    00897
    00898     PBoolean CreateObject();
    00899     PObject * Clone() const;
    00900 };
    00901
    00902
    00903 //
    00904 // AlternativeNodeID
    00905 //
    00906
    00907 class GCC_AlternativeNodeID : public PASN_Choice
    00908 {
    00909 #ifndef PASN_LEANANDMEAN
    00910     PCLASSINFO(GCC_AlternativeNodeID, PASN_Choice);
    00911 #endif
    00912   public:
    00913     GCC_AlternativeNodeID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    00914
    00915     enum Choices {
    00916       e_h243NodeID
    00917     };
    00918
    00919     PBoolean CreateObject();
    00920     PObject * Clone() const;
    00921 };
    00922
    00923
    00924 //
    00925 // ConferenceDescriptor
    00926 //
    00927
    00928 class GCC_ConferenceDescriptor : public PASN_Sequence
    00929 {
    00930 #ifndef PASN_LEANANDMEAN
    00931     PCLASSINFO(GCC_ConferenceDescriptor, PASN_Sequence);
    00932 #endif
    00933   public:
    00934     GCC_ConferenceDescriptor(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00935
    00936     enum OptionalFields {
    00937       e_conferenceNameModifier,
    00938       e_conferenceDescription,
    00939       e_networkAddress,
    00940       e_defaultConferenceFlag
    00941     };
    00942
    00943     GCC_ConferenceName m_conferenceName;
    00944     GCC_ConferenceNameModifier m_conferenceNameModifier;
    00945     GCC_TextString m_conferenceDescription;
    00946     PASN_Boolean m_lockedConference;
    00947     PASN_Boolean m_passwordInTheClearRequired;
    00948     GCC_NetworkAddress m_networkAddress;
    00949     PASN_Boolean m_defaultConferenceFlag;
    00950
    00951     PINDEX GetDataLength() const;
    00952     PBoolean Decode(PASN_Stream & strm);
    00953     void Encode(PASN_Stream & strm) const;
    00954 #ifndef PASN_NOPRINTON
    00955     void PrintOn(ostream & strm) const;
    00956 #endif
    00957     Comparison Compare(const PObject & obj) const;
    00958     PObject * Clone() const;
    00959 };
    00960
    00961
    00962 //
    00963 // SessionKey
    00964 //
    00965
    00966 class GCC_SessionKey : public PASN_Sequence
    00967 {
    00968 #ifndef PASN_LEANANDMEAN
    00969     PCLASSINFO(GCC_SessionKey, PASN_Sequence);
    00970 #endif
    00971   public:
    00972     GCC_SessionKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    00973
    00974     enum OptionalFields {
    00975       e_sessionID
    00976     };
    00977
    00978     GCC_Key m_applicationProtocolKey;
    00979     GCC_ChannelID m_sessionID;
    00980
    00981     PINDEX GetDataLength() const;
    00982     PBoolean Decode(PASN_Stream & strm);
    00983     void Encode(PASN_Stream & strm) const;
    00984 #ifndef PASN_NOPRINTON
    00985     void PrintOn(ostream & strm) const;
    00986 #endif
    00987     Comparison Compare(const PObject & obj) const;
    00988     PObject * Clone() const;
    00989 };
    00990
    00991
    00992 //
    00993 // ChannelType
    00994 //
    00995
    00996 class GCC_ChannelType : public PASN_Enumeration
    00997 {
    00998 #ifndef PASN_LEANANDMEAN
    00999     PCLASSINFO(GCC_ChannelType, PASN_Enumeration);
    01000 #endif
    01001   public:
    01002     GCC_ChannelType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    01003
    01004     enum Enumerations {
    01005       e_static,
    01006       e_dynamicMulticast,
    01007       e_dynamicPrivate,
    01008       e_dynamicUserId
    01009     };
    01010
    01011     GCC_ChannelType & operator=(unsigned v);
    01012     PObject * Clone() const;
    01013 };
    01014
    01015
    01016 //
    01017 // CapabilityID
    01018 //
    01019
    01020 class GCC_Key;
    01021
    01022 class GCC_CapabilityID : public PASN_Choice
    01023 {
    01024 #ifndef PASN_LEANANDMEAN
    01025     PCLASSINFO(GCC_CapabilityID, PASN_Choice);
    01026 #endif
    01027   public:
    01028     GCC_CapabilityID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    01029
    01030     enum Choices {
    01031       e_standard,
    01032       e_nonStandard
    01033     };
    01034
    01035 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01036     operator GCC_Key &() const;
    01037 #else
    01038     operator GCC_Key &();
    01039     operator const GCC_Key &() const;
    01040 #endif
    01041
    01042     PBoolean CreateObject();
    01043     PObject * Clone() const;
    01044 };
    01045
    01046
    01047 //
    01048 // CapabilityClass
    01049 //
    01050
    01051 class GCC_CapabilityClass : public PASN_Choice
    01052 {
    01053 #ifndef PASN_LEANANDMEAN
    01054     PCLASSINFO(GCC_CapabilityClass, PASN_Choice);
    01055 #endif
    01056   public:
    01057     GCC_CapabilityClass(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    01058
    01059     enum Choices {
    01060       e_logical,
    01061       e_unsignedMin,
    01062       e_unsignedMax
    01063     };
    01064
    01065     PBoolean CreateObject();
    01066     PObject * Clone() const;
    01067 };
    01068
    01069
    01070 //
    01071 // EntityID
    01072 //
    01073
    01074 class GCC_EntityID : public PASN_Integer
    01075 {
    01076 #ifndef PASN_LEANANDMEAN
    01077     PCLASSINFO(GCC_EntityID, PASN_Integer);
    01078 #endif
    01079   public:
    01080     GCC_EntityID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);
    01081
    01082     GCC_EntityID & operator=(int v);
    01083     GCC_EntityID & operator=(unsigned v);
    01084     PObject * Clone() const;
    01085 };
    01086
    01087
    01088 //
    01089 // RegistryKey
    01090 //
    01091
    01092 class GCC_RegistryKey : public PASN_Sequence
    01093 {
    01094 #ifndef PASN_LEANANDMEAN
    01095     PCLASSINFO(GCC_RegistryKey, PASN_Sequence);
    01096 #endif
    01097   public:
    01098     GCC_RegistryKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01099
    01100     GCC_SessionKey m_sessionKey;
    01101     PASN_OctetString m_resourceID;
    01102
    01103     PINDEX GetDataLength() const;
    01104     PBoolean Decode(PASN_Stream & strm);
    01105     void Encode(PASN_Stream & strm) const;
    01106 #ifndef PASN_NOPRINTON
    01107     void PrintOn(ostream & strm) const;
    01108 #endif
    01109     Comparison Compare(const PObject & obj) const;
    01110     PObject * Clone() const;
    01111 };
    01112
    01113
    01114 //
    01115 // RegistryItem
    01116 //
    01117
    01118 class GCC_DynamicChannelID;
    01119 class GCC_DynamicTokenID;
    01120
    01121 class GCC_RegistryItem : public PASN_Choice
    01122 {
    01123 #ifndef PASN_LEANANDMEAN
    01124     PCLASSINFO(GCC_RegistryItem, PASN_Choice);
    01125 #endif
    01126   public:
    01127     GCC_RegistryItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    01128
    01129     enum Choices {
    01130       e_channelID,
    01131       e_tokenID,
    01132       e_parameter,
    01133       e_vacant
    01134     };
    01135
    01136 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01137     operator GCC_DynamicChannelID &() const;
    01138 #else
    01139     operator GCC_DynamicChannelID &();
    01140     operator const GCC_DynamicChannelID &() const;
    01141 #endif
    01142 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01143     operator GCC_DynamicTokenID &() const;
    01144 #else
    01145     operator GCC_DynamicTokenID &();
    01146     operator const GCC_DynamicTokenID &() const;
    01147 #endif
    01148
    01149     PBoolean CreateObject();
    01150     PObject * Clone() const;
    01151 };
    01152
    01153
    01154 //
    01155 // RegistryEntryOwner
    01156 //
    01157
    01158 class GCC_RegistryEntryOwner_owned;
    01159
    01160 class GCC_RegistryEntryOwner : public PASN_Choice
    01161 {
    01162 #ifndef PASN_LEANANDMEAN
    01163     PCLASSINFO(GCC_RegistryEntryOwner, PASN_Choice);
    01164 #endif
    01165   public:
    01166     GCC_RegistryEntryOwner(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    01167
    01168     enum Choices {
    01169       e_owned,
    01170       e_notOwned
    01171     };
    01172
    01173 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01174     operator GCC_RegistryEntryOwner_owned &() const;
    01175 #else
    01176     operator GCC_RegistryEntryOwner_owned &();
    01177     operator const GCC_RegistryEntryOwner_owned &() const;
    01178 #endif
    01179
    01180     PBoolean CreateObject();
    01181     PObject * Clone() const;
    01182 };
    01183
    01184
    01185 //
    01186 // RegistryModificationRights
    01187 //
    01188
    01189 class GCC_RegistryModificationRights : public PASN_Enumeration
    01190 {
    01191 #ifndef PASN_LEANANDMEAN
    01192     PCLASSINFO(GCC_RegistryModificationRights, PASN_Enumeration);
    01193 #endif
    01194   public:
    01195     GCC_RegistryModificationRights(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    01196
    01197     enum Enumerations {
    01198       e_owner,
    01199       e_session,
    01200       e_public
    01201     };
    01202
    01203     GCC_RegistryModificationRights & operator=(unsigned v);
    01204     PObject * Clone() const;
    01205 };
    01206
    01207
    01208 //
    01209 // UserIDIndication
    01210 //
    01211
    01212 class GCC_UserIDIndication : public PASN_Sequence
    01213 {
    01214 #ifndef PASN_LEANANDMEAN
    01215     PCLASSINFO(GCC_UserIDIndication, PASN_Sequence);
    01216 #endif
    01217   public:
    01218     GCC_UserIDIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01219
    01220     PASN_Integer m_tag;
    01221
    01222     PINDEX GetDataLength() const;
    01223     PBoolean Decode(PASN_Stream & strm);
    01224     void Encode(PASN_Stream & strm) const;
    01225 #ifndef PASN_NOPRINTON
    01226     void PrintOn(ostream & strm) const;
    01227 #endif
    01228     Comparison Compare(const PObject & obj) const;
    01229     PObject * Clone() const;
    01230 };
    01231
    01232
    01233 //
    01234 // ConferenceQueryRequest
    01235 //
    01236
    01237 class GCC_ConferenceQueryRequest : public PASN_Sequence
    01238 {
    01239 #ifndef PASN_LEANANDMEAN
    01240     PCLASSINFO(GCC_ConferenceQueryRequest, PASN_Sequence);
    01241 #endif
    01242   public:
    01243     GCC_ConferenceQueryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01244
    01245     enum OptionalFields {
    01246       e_asymmetryIndicator,
    01247       e_userData
    01248     };
    01249
    01250     GCC_NodeType m_nodeType;
    01251     GCC_AsymmetryIndicator m_asymmetryIndicator;
    01252     GCC_UserData m_userData;
    01253
    01254     PINDEX GetDataLength() const;
    01255     PBoolean Decode(PASN_Stream & strm);
    01256     void Encode(PASN_Stream & strm) const;
    01257 #ifndef PASN_NOPRINTON
    01258     void PrintOn(ostream & strm) const;
    01259 #endif
    01260     Comparison Compare(const PObject & obj) const;
    01261     PObject * Clone() const;
    01262 };
    01263
    01264
    01265 //
    01266 // ConferenceJoinRequest
    01267 //
    01268
    01269 class GCC_ConferenceJoinRequest : public PASN_Sequence
    01270 {
    01271 #ifndef PASN_LEANANDMEAN
    01272     PCLASSINFO(GCC_ConferenceJoinRequest, PASN_Sequence);
    01273 #endif
    01274   public:
    01275     GCC_ConferenceJoinRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01276
    01277     enum OptionalFields {
    01278       e_conferenceName,
    01279       e_conferenceNameModifier,
    01280       e_tag,
    01281       e_password,
    01282       e_convenerPassword,
    01283       e_callerIdentifier,
    01284       e_userData
    01285     };
    01286
    01287     GCC_ConferenceNameSelector m_conferenceName;
    01288     GCC_ConferenceNameModifier m_conferenceNameModifier;
    01289     PASN_Integer m_tag;
    01290     GCC_PasswordChallengeRequestResponse m_password;
    01291     GCC_PasswordSelector m_convenerPassword;
    01292     GCC_TextString m_callerIdentifier;
    01293     GCC_UserData m_userData;
    01294
    01295     PINDEX GetDataLength() const;
    01296     PBoolean Decode(PASN_Stream & strm);
    01297     void Encode(PASN_Stream & strm) const;
    01298 #ifndef PASN_NOPRINTON
    01299     void PrintOn(ostream & strm) const;
    01300 #endif
    01301     Comparison Compare(const PObject & obj) const;
    01302     PObject * Clone() const;
    01303 };
    01304
    01305
    01306 //
    01307 // ConferenceAddRequest
    01308 //
    01309
    01310 class GCC_ConferenceAddRequest : public PASN_Sequence
    01311 {
    01312 #ifndef PASN_LEANANDMEAN
    01313     PCLASSINFO(GCC_ConferenceAddRequest, PASN_Sequence);
    01314 #endif
    01315   public:
    01316     GCC_ConferenceAddRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01317
    01318     enum OptionalFields {
    01319       e_addingMCU,
    01320       e_userData
    01321     };
    01322
    01323     GCC_NetworkAddress m_networkAddress;
    01324     GCC_UserID m_requestingNode;
    01325     PASN_Integer m_tag;
    01326     GCC_UserID m_addingMCU;
    01327     GCC_UserData m_userData;
    01328
    01329     PINDEX GetDataLength() const;
    01330     PBoolean Decode(PASN_Stream & strm);
    01331     void Encode(PASN_Stream & strm) const;
    01332 #ifndef PASN_NOPRINTON
    01333     void PrintOn(ostream & strm) const;
    01334 #endif
    01335     Comparison Compare(const PObject & obj) const;
    01336     PObject * Clone() const;
    01337 };
    01338
    01339
    01340 //
    01341 // ConferenceLockRequest
    01342 //
    01343
    01344 class GCC_ConferenceLockRequest : public PASN_Sequence
    01345 {
    01346 #ifndef PASN_LEANANDMEAN
    01347     PCLASSINFO(GCC_ConferenceLockRequest, PASN_Sequence);
    01348 #endif
    01349   public:
    01350     GCC_ConferenceLockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01351
    01352
    01353     PINDEX GetDataLength() const;
    01354     PBoolean Decode(PASN_Stream & strm);
    01355     void Encode(PASN_Stream & strm) const;
    01356 #ifndef PASN_NOPRINTON
    01357     void PrintOn(ostream & strm) const;
    01358 #endif
    01359     PObject * Clone() const;
    01360 };
    01361
    01362
    01363 //
    01364 // ConferenceLockIndication
    01365 //
    01366
    01367 class GCC_ConferenceLockIndication : public PASN_Sequence
    01368 {
    01369 #ifndef PASN_LEANANDMEAN
    01370     PCLASSINFO(GCC_ConferenceLockIndication, PASN_Sequence);
    01371 #endif
    01372   public:
    01373     GCC_ConferenceLockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01374
    01375
    01376     PINDEX GetDataLength() const;
    01377     PBoolean Decode(PASN_Stream & strm);
    01378     void Encode(PASN_Stream & strm) const;
    01379 #ifndef PASN_NOPRINTON
    01380     void PrintOn(ostream & strm) const;
    01381 #endif
    01382     PObject * Clone() const;
    01383 };
    01384
    01385
    01386 //
    01387 // ConferenceUnlockRequest
    01388 //
    01389
    01390 class GCC_ConferenceUnlockRequest : public PASN_Sequence
    01391 {
    01392 #ifndef PASN_LEANANDMEAN
    01393     PCLASSINFO(GCC_ConferenceUnlockRequest, PASN_Sequence);
    01394 #endif
    01395   public:
    01396     GCC_ConferenceUnlockRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01397
    01398
    01399     PINDEX GetDataLength() const;
    01400     PBoolean Decode(PASN_Stream & strm);
    01401     void Encode(PASN_Stream & strm) const;
    01402 #ifndef PASN_NOPRINTON
    01403     void PrintOn(ostream & strm) const;
    01404 #endif
    01405     PObject * Clone() const;
    01406 };
    01407
    01408
    01409 //
    01410 // ConferenceUnlockIndication
    01411 //
    01412
    01413 class GCC_ConferenceUnlockIndication : public PASN_Sequence
    01414 {
    01415 #ifndef PASN_LEANANDMEAN
    01416     PCLASSINFO(GCC_ConferenceUnlockIndication, PASN_Sequence);
    01417 #endif
    01418   public:
    01419     GCC_ConferenceUnlockIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01420
    01421
    01422     PINDEX GetDataLength() const;
    01423     PBoolean Decode(PASN_Stream & strm);
    01424     void Encode(PASN_Stream & strm) const;
    01425 #ifndef PASN_NOPRINTON
    01426     void PrintOn(ostream & strm) const;
    01427 #endif
    01428     PObject * Clone() const;
    01429 };
    01430
    01431
    01432 //
    01433 // RegistryRegisterChannelRequest
    01434 //
    01435
    01436 class GCC_RegistryRegisterChannelRequest : public PASN_Sequence
    01437 {
    01438 #ifndef PASN_LEANANDMEAN
    01439     PCLASSINFO(GCC_RegistryRegisterChannelRequest, PASN_Sequence);
    01440 #endif
    01441   public:
    01442     GCC_RegistryRegisterChannelRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01443
    01444     GCC_EntityID m_entityID;
    01445     GCC_RegistryKey m_key;
    01446     GCC_DynamicChannelID m_channelID;
    01447
    01448     PINDEX GetDataLength() const;
    01449     PBoolean Decode(PASN_Stream & strm);
    01450     void Encode(PASN_Stream & strm) const;
    01451 #ifndef PASN_NOPRINTON
    01452     void PrintOn(ostream & strm) const;
    01453 #endif
    01454     Comparison Compare(const PObject & obj) const;
    01455     PObject * Clone() const;
    01456 };
    01457
    01458
    01459 //
    01460 // RegistryAssignTokenRequest
    01461 //
    01462
    01463 class GCC_RegistryAssignTokenRequest : public PASN_Sequence
    01464 {
    01465 #ifndef PASN_LEANANDMEAN
    01466     PCLASSINFO(GCC_RegistryAssignTokenRequest, PASN_Sequence);
    01467 #endif
    01468   public:
    01469     GCC_RegistryAssignTokenRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01470
    01471     GCC_EntityID m_entityID;
    01472     GCC_RegistryKey m_key;
    01473
    01474     PINDEX GetDataLength() const;
    01475     PBoolean Decode(PASN_Stream & strm);
    01476     void Encode(PASN_Stream & strm) const;
    01477 #ifndef PASN_NOPRINTON
    01478     void PrintOn(ostream & strm) const;
    01479 #endif
    01480     Comparison Compare(const PObject & obj) const;
    01481     PObject * Clone() const;
    01482 };
    01483
    01484
    01485 //
    01486 // RegistrySetParameterRequest
    01487 //
    01488
    01489 class GCC_RegistrySetParameterRequest : public PASN_Sequence
    01490 {
    01491 #ifndef PASN_LEANANDMEAN
    01492     PCLASSINFO(GCC_RegistrySetParameterRequest, PASN_Sequence);
    01493 #endif
    01494   public:
    01495     GCC_RegistrySetParameterRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01496
    01497     enum OptionalFields {
    01498       e_modificationRights
    01499     };
    01500
    01501     GCC_EntityID m_entityID;
    01502     GCC_RegistryKey m_key;
    01503     PASN_OctetString m_parameter;
    01504     GCC_RegistryModificationRights m_modificationRights;
    01505
    01506     PINDEX GetDataLength() const;
    01507     PBoolean Decode(PASN_Stream & strm);
    01508     void Encode(PASN_Stream & strm) const;
    01509 #ifndef PASN_NOPRINTON
    01510     void PrintOn(ostream & strm) const;
    01511 #endif
    01512     Comparison Compare(const PObject & obj) const;
    01513     PObject * Clone() const;
    01514 };
    01515
    01516
    01517 //
    01518 // RegistryRetrieveEntryRequest
    01519 //
    01520
    01521 class GCC_RegistryRetrieveEntryRequest : public PASN_Sequence
    01522 {
    01523 #ifndef PASN_LEANANDMEAN
    01524     PCLASSINFO(GCC_RegistryRetrieveEntryRequest, PASN_Sequence);
    01525 #endif
    01526   public:
    01527     GCC_RegistryRetrieveEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01528
    01529     GCC_EntityID m_entityID;
    01530     GCC_RegistryKey m_key;
    01531
    01532     PINDEX GetDataLength() const;
    01533     PBoolean Decode(PASN_Stream & strm);
    01534     void Encode(PASN_Stream & strm) const;
    01535 #ifndef PASN_NOPRINTON
    01536     void PrintOn(ostream & strm) const;
    01537 #endif
    01538     Comparison Compare(const PObject & obj) const;
    01539     PObject * Clone() const;
    01540 };
    01541
    01542
    01543 //
    01544 // RegistryDeleteEntryRequest
    01545 //
    01546
    01547 class GCC_RegistryDeleteEntryRequest : public PASN_Sequence
    01548 {
    01549 #ifndef PASN_LEANANDMEAN
    01550     PCLASSINFO(GCC_RegistryDeleteEntryRequest, PASN_Sequence);
    01551 #endif
    01552   public:
    01553     GCC_RegistryDeleteEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01554
    01555     GCC_EntityID m_entityID;
    01556     GCC_RegistryKey m_key;
    01557
    01558     PINDEX GetDataLength() const;
    01559     PBoolean Decode(PASN_Stream & strm);
    01560     void Encode(PASN_Stream & strm) const;
    01561 #ifndef PASN_NOPRINTON
    01562     void PrintOn(ostream & strm) const;
    01563 #endif
    01564     Comparison Compare(const PObject & obj) const;
    01565     PObject * Clone() const;
    01566 };
    01567
    01568
    01569 //
    01570 // RegistryMonitorEntryRequest
    01571 //
    01572
    01573 class GCC_RegistryMonitorEntryRequest : public PASN_Sequence
    01574 {
    01575 #ifndef PASN_LEANANDMEAN
    01576     PCLASSINFO(GCC_RegistryMonitorEntryRequest, PASN_Sequence);
    01577 #endif
    01578   public:
    01579     GCC_RegistryMonitorEntryRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01580
    01581     GCC_EntityID m_entityID;
    01582     GCC_RegistryKey m_key;
    01583
    01584     PINDEX GetDataLength() const;
    01585     PBoolean Decode(PASN_Stream & strm);
    01586     void Encode(PASN_Stream & strm) const;
    01587 #ifndef PASN_NOPRINTON
    01588     void PrintOn(ostream & strm) const;
    01589 #endif
    01590     Comparison Compare(const PObject & obj) const;
    01591     PObject * Clone() const;
    01592 };
    01593
    01594
    01595 //
    01596 // RegistryMonitorEntryIndication
    01597 //
    01598
    01599 class GCC_RegistryMonitorEntryIndication : public PASN_Sequence
    01600 {
    01601 #ifndef PASN_LEANANDMEAN
    01602     PCLASSINFO(GCC_RegistryMonitorEntryIndication, PASN_Sequence);
    01603 #endif
    01604   public:
    01605     GCC_RegistryMonitorEntryIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01606
    01607     enum OptionalFields {
    01608       e_modificationRights
    01609     };
    01610
    01611     GCC_RegistryKey m_key;
    01612     GCC_RegistryItem m_item;
    01613     GCC_RegistryEntryOwner m_owner;
    01614     GCC_RegistryModificationRights m_modificationRights;
    01615
    01616     PINDEX GetDataLength() const;
    01617     PBoolean Decode(PASN_Stream & strm);
    01618     void Encode(PASN_Stream & strm) const;
    01619 #ifndef PASN_NOPRINTON
    01620     void PrintOn(ostream & strm) const;
    01621 #endif
    01622     Comparison Compare(const PObject & obj) const;
    01623     PObject * Clone() const;
    01624 };
    01625
    01626
    01627 //
    01628 // RegistryAllocateHandleRequest
    01629 //
    01630
    01631 class GCC_RegistryAllocateHandleRequest : public PASN_Sequence
    01632 {
    01633 #ifndef PASN_LEANANDMEAN
    01634     PCLASSINFO(GCC_RegistryAllocateHandleRequest, PASN_Sequence);
    01635 #endif
    01636   public:
    01637     GCC_RegistryAllocateHandleRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01638
    01639     GCC_EntityID m_entityID;
    01640     PASN_Integer m_numberOfHandles;
    01641
    01642     PINDEX GetDataLength() const;
    01643     PBoolean Decode(PASN_Stream & strm);
    01644     void Encode(PASN_Stream & strm) const;
    01645 #ifndef PASN_NOPRINTON
    01646     void PrintOn(ostream & strm) const;
    01647 #endif
    01648     Comparison Compare(const PObject & obj) const;
    01649     PObject * Clone() const;
    01650 };
    01651
    01652
    01653 //
    01654 // ConductorAssignIndication
    01655 //
    01656
    01657 class GCC_ConductorAssignIndication : public PASN_Sequence
    01658 {
    01659 #ifndef PASN_LEANANDMEAN
    01660     PCLASSINFO(GCC_ConductorAssignIndication, PASN_Sequence);
    01661 #endif
    01662   public:
    01663     GCC_ConductorAssignIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01664
    01665     GCC_UserID m_conductingNode;
    01666
    01667     PINDEX GetDataLength() const;
    01668     PBoolean Decode(PASN_Stream & strm);
    01669     void Encode(PASN_Stream & strm) const;
    01670 #ifndef PASN_NOPRINTON
    01671     void PrintOn(ostream & strm) const;
    01672 #endif
    01673     Comparison Compare(const PObject & obj) const;
    01674     PObject * Clone() const;
    01675 };
    01676
    01677
    01678 //
    01679 // ConductorReleaseIndication
    01680 //
    01681
    01682 class GCC_ConductorReleaseIndication : public PASN_Sequence
    01683 {
    01684 #ifndef PASN_LEANANDMEAN
    01685     PCLASSINFO(GCC_ConductorReleaseIndication, PASN_Sequence);
    01686 #endif
    01687   public:
    01688     GCC_ConductorReleaseIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01689
    01690
    01691     PINDEX GetDataLength() const;
    01692     PBoolean Decode(PASN_Stream & strm);
    01693     void Encode(PASN_Stream & strm) const;
    01694 #ifndef PASN_NOPRINTON
    01695     void PrintOn(ostream & strm) const;
    01696 #endif
    01697     PObject * Clone() const;
    01698 };
    01699
    01700
    01701 //
    01702 // ConductorPermissionAskIndication
    01703 //
    01704
    01705 class GCC_ConductorPermissionAskIndication : public PASN_Sequence
    01706 {
    01707 #ifndef PASN_LEANANDMEAN
    01708     PCLASSINFO(GCC_ConductorPermissionAskIndication, PASN_Sequence);
    01709 #endif
    01710   public:
    01711     GCC_ConductorPermissionAskIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01712
    01713     PASN_Boolean m_grantFlag;
    01714
    01715     PINDEX GetDataLength() const;
    01716     PBoolean Decode(PASN_Stream & strm);
    01717     void Encode(PASN_Stream & strm) const;
    01718 #ifndef PASN_NOPRINTON
    01719     void PrintOn(ostream & strm) const;
    01720 #endif
    01721     Comparison Compare(const PObject & obj) const;
    01722     PObject * Clone() const;
    01723 };
    01724
    01725
    01726 //
    01727 // ConferenceTimeRemainingIndication
    01728 //
    01729
    01730 class GCC_ConferenceTimeRemainingIndication : public PASN_Sequence
    01731 {
    01732 #ifndef PASN_LEANANDMEAN
    01733     PCLASSINFO(GCC_ConferenceTimeRemainingIndication, PASN_Sequence);
    01734 #endif
    01735   public:
    01736     GCC_ConferenceTimeRemainingIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01737
    01738     enum OptionalFields {
    01739       e_nodeID
    01740     };
    01741
    01742     GCC_Time m_timeRemaining;
    01743     GCC_UserID m_nodeID;
    01744
    01745     PINDEX GetDataLength() const;
    01746     PBoolean Decode(PASN_Stream & strm);
    01747     void Encode(PASN_Stream & strm) const;
    01748 #ifndef PASN_NOPRINTON
    01749     void PrintOn(ostream & strm) const;
    01750 #endif
    01751     Comparison Compare(const PObject & obj) const;
    01752     PObject * Clone() const;
    01753 };
    01754
    01755
    01756 //
    01757 // ConferenceTimeInquireIndication
    01758 //
    01759
    01760 class GCC_ConferenceTimeInquireIndication : public PASN_Sequence
    01761 {
    01762 #ifndef PASN_LEANANDMEAN
    01763     PCLASSINFO(GCC_ConferenceTimeInquireIndication, PASN_Sequence);
    01764 #endif
    01765   public:
    01766     GCC_ConferenceTimeInquireIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01767
    01768     PASN_Boolean m_nodeSpecificTimeFlag;
    01769
    01770     PINDEX GetDataLength() const;
    01771     PBoolean Decode(PASN_Stream & strm);
    01772     void Encode(PASN_Stream & strm) const;
    01773 #ifndef PASN_NOPRINTON
    01774     void PrintOn(ostream & strm) const;
    01775 #endif
    01776     Comparison Compare(const PObject & obj) const;
    01777     PObject * Clone() const;
    01778 };
    01779
    01780
    01781 //
    01782 // ConferenceTimeExtendIndication
    01783 //
    01784
    01785 class GCC_ConferenceTimeExtendIndication : public PASN_Sequence
    01786 {
    01787 #ifndef PASN_LEANANDMEAN
    01788     PCLASSINFO(GCC_ConferenceTimeExtendIndication, PASN_Sequence);
    01789 #endif
    01790   public:
    01791     GCC_ConferenceTimeExtendIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01792
    01793     GCC_Time m_timeToExtend;
    01794     PASN_Boolean m_nodeSpecificTimeFlag;
    01795
    01796     PINDEX GetDataLength() const;
    01797     PBoolean Decode(PASN_Stream & strm);
    01798     void Encode(PASN_Stream & strm) const;
    01799 #ifndef PASN_NOPRINTON
    01800     void PrintOn(ostream & strm) const;
    01801 #endif
    01802     Comparison Compare(const PObject & obj) const;
    01803     PObject * Clone() const;
    01804 };
    01805
    01806
    01807 //
    01808 // ConferenceAssistanceIndication
    01809 //
    01810
    01811 class GCC_ConferenceAssistanceIndication : public PASN_Sequence
    01812 {
    01813 #ifndef PASN_LEANANDMEAN
    01814     PCLASSINFO(GCC_ConferenceAssistanceIndication, PASN_Sequence);
    01815 #endif
    01816   public:
    01817     GCC_ConferenceAssistanceIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01818
    01819     enum OptionalFields {
    01820       e_userData
    01821     };
    01822
    01823     GCC_UserData m_userData;
    01824
    01825     PINDEX GetDataLength() const;
    01826     PBoolean Decode(PASN_Stream & strm);
    01827     void Encode(PASN_Stream & strm) const;
    01828 #ifndef PASN_NOPRINTON
    01829     void PrintOn(ostream & strm) const;
    01830 #endif
    01831     Comparison Compare(const PObject & obj) const;
    01832     PObject * Clone() const;
    01833 };
    01834
    01835
    01836 //
    01837 // TextMessageIndication
    01838 //
    01839
    01840 class GCC_TextMessageIndication : public PASN_Sequence
    01841 {
    01842 #ifndef PASN_LEANANDMEAN
    01843     PCLASSINFO(GCC_TextMessageIndication, PASN_Sequence);
    01844 #endif
    01845   public:
    01846     GCC_TextMessageIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01847
    01848     GCC_TextString m_message;
    01849
    01850     PINDEX GetDataLength() const;
    01851     PBoolean Decode(PASN_Stream & strm);
    01852     void Encode(PASN_Stream & strm) const;
    01853 #ifndef PASN_NOPRINTON
    01854     void PrintOn(ostream & strm) const;
    01855 #endif
    01856     Comparison Compare(const PObject & obj) const;
    01857     PObject * Clone() const;
    01858 };
    01859
    01860
    01861 //
    01862 // NonStandardPDU
    01863 //
    01864
    01865 class GCC_NonStandardPDU : public PASN_Sequence
    01866 {
    01867 #ifndef PASN_LEANANDMEAN
    01868     PCLASSINFO(GCC_NonStandardPDU, PASN_Sequence);
    01869 #endif
    01870   public:
    01871     GCC_NonStandardPDU(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01872
    01873     GCC_NonStandardParameter m_data;
    01874
    01875     PINDEX GetDataLength() const;
    01876     PBoolean Decode(PASN_Stream & strm);
    01877     void Encode(PASN_Stream & strm) const;
    01878 #ifndef PASN_NOPRINTON
    01879     void PrintOn(ostream & strm) const;
    01880 #endif
    01881     Comparison Compare(const PObject & obj) const;
    01882     PObject * Clone() const;
    01883 };
    01884
    01885
    01886 //
    01887 // ConnectData
    01888 //
    01889
    01890 class GCC_ConnectData : public PASN_Sequence
    01891 {
    01892 #ifndef PASN_LEANANDMEAN
    01893     PCLASSINFO(GCC_ConnectData, PASN_Sequence);
    01894 #endif
    01895   public:
    01896     GCC_ConnectData(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    01897
    01898     GCC_Key m_t124Identifier;
    01899     PASN_OctetString m_connectPDU;
    01900
    01901     PINDEX GetDataLength() const;
    01902     PBoolean Decode(PASN_Stream & strm);
    01903     void Encode(PASN_Stream & strm) const;
    01904 #ifndef PASN_NOPRINTON
    01905     void PrintOn(ostream & strm) const;
    01906 #endif
    01907     Comparison Compare(const PObject & obj) const;
    01908     PObject * Clone() const;
    01909 };
    01910
    01911
    01912 //
    01913 // ConnectGCCPDU
    01914 //
    01915
    01916 class GCC_ConferenceCreateRequest;
    01917 class GCC_ConferenceCreateResponse;
    01918 class GCC_ConferenceQueryRequest;
    01919 class GCC_ConferenceQueryResponse;
    01920 class GCC_ConferenceJoinRequest;
    01921 class GCC_ConferenceJoinResponse;
    01922 class GCC_ConferenceInviteRequest;
    01923 class GCC_ConferenceInviteResponse;
    01924
    01925 class GCC_ConnectGCCPDU : public PASN_Choice
    01926 {
    01927 #ifndef PASN_LEANANDMEAN
    01928     PCLASSINFO(GCC_ConnectGCCPDU, PASN_Choice);
    01929 #endif
    01930   public:
    01931     GCC_ConnectGCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    01932
    01933     enum Choices {
    01934       e_conferenceCreateRequest,
    01935       e_conferenceCreateResponse,
    01936       e_conferenceQueryRequest,
    01937       e_conferenceQueryResponse,
    01938       e_conferenceJoinRequest,
    01939       e_conferenceJoinResponse,
    01940       e_conferenceInviteRequest,
    01941       e_conferenceInviteResponse
    01942     };
    01943
    01944 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01945     operator GCC_ConferenceCreateRequest &() const;
    01946 #else
    01947     operator GCC_ConferenceCreateRequest &();
    01948     operator const GCC_ConferenceCreateRequest &() const;
    01949 #endif
    01950 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01951     operator GCC_ConferenceCreateResponse &() const;
    01952 #else
    01953     operator GCC_ConferenceCreateResponse &();
    01954     operator const GCC_ConferenceCreateResponse &() const;
    01955 #endif
    01956 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01957     operator GCC_ConferenceQueryRequest &() const;
    01958 #else
    01959     operator GCC_ConferenceQueryRequest &();
    01960     operator const GCC_ConferenceQueryRequest &() const;
    01961 #endif
    01962 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01963     operator GCC_ConferenceQueryResponse &() const;
    01964 #else
    01965     operator GCC_ConferenceQueryResponse &();
    01966     operator const GCC_ConferenceQueryResponse &() const;
    01967 #endif
    01968 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01969     operator GCC_ConferenceJoinRequest &() const;
    01970 #else
    01971     operator GCC_ConferenceJoinRequest &();
    01972     operator const GCC_ConferenceJoinRequest &() const;
    01973 #endif
    01974 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01975     operator GCC_ConferenceJoinResponse &() const;
    01976 #else
    01977     operator GCC_ConferenceJoinResponse &();
    01978     operator const GCC_ConferenceJoinResponse &() const;
    01979 #endif
    01980 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01981     operator GCC_ConferenceInviteRequest &() const;
    01982 #else
    01983     operator GCC_ConferenceInviteRequest &();
    01984     operator const GCC_ConferenceInviteRequest &() const;
    01985 #endif
    01986 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    01987     operator GCC_ConferenceInviteResponse &() const;
    01988 #else
    01989     operator GCC_ConferenceInviteResponse &();
    01990     operator const GCC_ConferenceInviteResponse &() const;
    01991 #endif
    01992
    01993     PBoolean CreateObject();
    01994     PObject * Clone() const;
    01995 };
    01996
    01997
    01998 //
    01999 // GCCPDU
    02000 //
    02001
    02002 class GCC_RequestPDU;
    02003 class GCC_ResponsePDU;
    02004 class GCC_IndicationPDU;
    02005
    02006 class GCC_GCCPDU : public PASN_Choice
    02007 {
    02008 #ifndef PASN_LEANANDMEAN
    02009     PCLASSINFO(GCC_GCCPDU, PASN_Choice);
    02010 #endif
    02011   public:
    02012     GCC_GCCPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    02013
    02014     enum Choices {
    02015       e_request,
    02016       e_response,
    02017       e_indication
    02018     };
    02019
    02020 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02021     operator GCC_RequestPDU &() const;
    02022 #else
    02023     operator GCC_RequestPDU &();
    02024     operator const GCC_RequestPDU &() const;
    02025 #endif
    02026 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02027     operator GCC_ResponsePDU &() const;
    02028 #else
    02029     operator GCC_ResponsePDU &();
    02030     operator const GCC_ResponsePDU &() const;
    02031 #endif
    02032 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02033     operator GCC_IndicationPDU &() const;
    02034 #else
    02035     operator GCC_IndicationPDU &();
    02036     operator const GCC_IndicationPDU &() const;
    02037 #endif
    02038
    02039     PBoolean CreateObject();
    02040     PObject * Clone() const;
    02041 };
    02042
    02043
    02044 //
    02045 // RequestPDU
    02046 //
    02047
    02048 class GCC_ConferenceJoinRequest;
    02049 class GCC_ConferenceAddRequest;
    02050 class GCC_ConferenceLockRequest;
    02051 class GCC_ConferenceUnlockRequest;
    02052 class GCC_ConferenceTerminateRequest;
    02053 class GCC_ConferenceEjectUserRequest;
    02054 class GCC_ConferenceTransferRequest;
    02055 class GCC_RegistryRegisterChannelRequest;
    02056 class GCC_RegistryAssignTokenRequest;
    02057 class GCC_RegistrySetParameterRequest;
    02058 class GCC_RegistryRetrieveEntryRequest;
    02059 class GCC_RegistryDeleteEntryRequest;
    02060 class GCC_RegistryMonitorEntryRequest;
    02061 class GCC_RegistryAllocateHandleRequest;
    02062 class GCC_NonStandardPDU;
    02063
    02064 class GCC_RequestPDU : public PASN_Choice
    02065 {
    02066 #ifndef PASN_LEANANDMEAN
    02067     PCLASSINFO(GCC_RequestPDU, PASN_Choice);
    02068 #endif
    02069   public:
    02070     GCC_RequestPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    02071
    02072     enum Choices {
    02073       e_conferenceJoinRequest,
    02074       e_conferenceAddRequest,
    02075       e_conferenceLockRequest,
    02076       e_conferenceUnlockRequest,
    02077       e_conferenceTerminateRequest,
    02078       e_conferenceEjectUserRequest,
    02079       e_conferenceTransferRequest,
    02080       e_registryRegisterChannelRequest,
    02081       e_registryAssignTokenRequest,
    02082       e_registrySetParameterRequest,
    02083       e_registryRetrieveEntryRequest,
    02084       e_registryDeleteEntryRequest,
    02085       e_registryMonitorEntryRequest,
    02086       e_registryAllocateHandleRequest,
    02087       e_nonStandardRequest
    02088     };
    02089
    02090 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02091     operator GCC_ConferenceJoinRequest &() const;
    02092 #else
    02093     operator GCC_ConferenceJoinRequest &();
    02094     operator const GCC_ConferenceJoinRequest &() const;
    02095 #endif
    02096 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02097     operator GCC_ConferenceAddRequest &() const;
    02098 #else
    02099     operator GCC_ConferenceAddRequest &();
    02100     operator const GCC_ConferenceAddRequest &() const;
    02101 #endif
    02102 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02103     operator GCC_ConferenceLockRequest &() const;
    02104 #else
    02105     operator GCC_ConferenceLockRequest &();
    02106     operator const GCC_ConferenceLockRequest &() const;
    02107 #endif
    02108 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02109     operator GCC_ConferenceUnlockRequest &() const;
    02110 #else
    02111     operator GCC_ConferenceUnlockRequest &();
    02112     operator const GCC_ConferenceUnlockRequest &() const;
    02113 #endif
    02114 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02115     operator GCC_ConferenceTerminateRequest &() const;
    02116 #else
    02117     operator GCC_ConferenceTerminateRequest &();
    02118     operator const GCC_ConferenceTerminateRequest &() const;
    02119 #endif
    02120 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02121     operator GCC_ConferenceEjectUserRequest &() const;
    02122 #else
    02123     operator GCC_ConferenceEjectUserRequest &();
    02124     operator const GCC_ConferenceEjectUserRequest &() const;
    02125 #endif
    02126 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02127     operator GCC_ConferenceTransferRequest &() const;
    02128 #else
    02129     operator GCC_ConferenceTransferRequest &();
    02130     operator const GCC_ConferenceTransferRequest &() const;
    02131 #endif
    02132 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02133     operator GCC_RegistryRegisterChannelRequest &() const;
    02134 #else
    02135     operator GCC_RegistryRegisterChannelRequest &();
    02136     operator const GCC_RegistryRegisterChannelRequest &() const;
    02137 #endif
    02138 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02139     operator GCC_RegistryAssignTokenRequest &() const;
    02140 #else
    02141     operator GCC_RegistryAssignTokenRequest &();
    02142     operator const GCC_RegistryAssignTokenRequest &() const;
    02143 #endif
    02144 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02145     operator GCC_RegistrySetParameterRequest &() const;
    02146 #else
    02147     operator GCC_RegistrySetParameterRequest &();
    02148     operator const GCC_RegistrySetParameterRequest &() const;
    02149 #endif
    02150 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02151     operator GCC_RegistryRetrieveEntryRequest &() const;
    02152 #else
    02153     operator GCC_RegistryRetrieveEntryRequest &();
    02154     operator const GCC_RegistryRetrieveEntryRequest &() const;
    02155 #endif
    02156 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02157     operator GCC_RegistryDeleteEntryRequest &() const;
    02158 #else
    02159     operator GCC_RegistryDeleteEntryRequest &();
    02160     operator const GCC_RegistryDeleteEntryRequest &() const;
    02161 #endif
    02162 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02163     operator GCC_RegistryMonitorEntryRequest &() const;
    02164 #else
    02165     operator GCC_RegistryMonitorEntryRequest &();
    02166     operator const GCC_RegistryMonitorEntryRequest &() const;
    02167 #endif
    02168 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02169     operator GCC_RegistryAllocateHandleRequest &() const;
    02170 #else
    02171     operator GCC_RegistryAllocateHandleRequest &();
    02172     operator const GCC_RegistryAllocateHandleRequest &() const;
    02173 #endif
    02174 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02175     operator GCC_NonStandardPDU &() const;
    02176 #else
    02177     operator GCC_NonStandardPDU &();
    02178     operator const GCC_NonStandardPDU &() const;
    02179 #endif
    02180
    02181     PBoolean CreateObject();
    02182     PObject * Clone() const;
    02183 };
    02184
    02185
    02186 //
    02187 // ResponsePDU
    02188 //
    02189
    02190 class GCC_ConferenceJoinResponse;
    02191 class GCC_ConferenceAddResponse;
    02192 class GCC_ConferenceLockResponse;
    02193 class GCC_ConferenceUnlockResponse;
    02194 class GCC_ConferenceTerminateResponse;
    02195 class GCC_ConferenceEjectUserResponse;
    02196 class GCC_ConferenceTransferResponse;
    02197 class GCC_RegistryResponse;
    02198 class GCC_RegistryAllocateHandleResponse;
    02199 class GCC_FunctionNotSupportedResponse;
    02200 class GCC_NonStandardPDU;
    02201
    02202 class GCC_ResponsePDU : public PASN_Choice
    02203 {
    02204 #ifndef PASN_LEANANDMEAN
    02205     PCLASSINFO(GCC_ResponsePDU, PASN_Choice);
    02206 #endif
    02207   public:
    02208     GCC_ResponsePDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    02209
    02210     enum Choices {
    02211       e_conferenceJoinResponse,
    02212       e_conferenceAddResponse,
    02213       e_conferenceLockResponse,
    02214       e_conferenceUnlockResponse,
    02215       e_conferenceTerminateResponse,
    02216       e_conferenceEjectUserResponse,
    02217       e_conferenceTransferResponse,
    02218       e_registryResponse,
    02219       e_registryAllocateHandleResponse,
    02220       e_functionNotSupportedResponse,
    02221       e_nonStandardResponse
    02222     };
    02223
    02224 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02225     operator GCC_ConferenceJoinResponse &() const;
    02226 #else
    02227     operator GCC_ConferenceJoinResponse &();
    02228     operator const GCC_ConferenceJoinResponse &() const;
    02229 #endif
    02230 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02231     operator GCC_ConferenceAddResponse &() const;
    02232 #else
    02233     operator GCC_ConferenceAddResponse &();
    02234     operator const GCC_ConferenceAddResponse &() const;
    02235 #endif
    02236 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02237     operator GCC_ConferenceLockResponse &() const;
    02238 #else
    02239     operator GCC_ConferenceLockResponse &();
    02240     operator const GCC_ConferenceLockResponse &() const;
    02241 #endif
    02242 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02243     operator GCC_ConferenceUnlockResponse &() const;
    02244 #else
    02245     operator GCC_ConferenceUnlockResponse &();
    02246     operator const GCC_ConferenceUnlockResponse &() const;
    02247 #endif
    02248 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02249     operator GCC_ConferenceTerminateResponse &() const;
    02250 #else
    02251     operator GCC_ConferenceTerminateResponse &();
    02252     operator const GCC_ConferenceTerminateResponse &() const;
    02253 #endif
    02254 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02255     operator GCC_ConferenceEjectUserResponse &() const;
    02256 #else
    02257     operator GCC_ConferenceEjectUserResponse &();
    02258     operator const GCC_ConferenceEjectUserResponse &() const;
    02259 #endif
    02260 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02261     operator GCC_ConferenceTransferResponse &() const;
    02262 #else
    02263     operator GCC_ConferenceTransferResponse &();
    02264     operator const GCC_ConferenceTransferResponse &() const;
    02265 #endif
    02266 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02267     operator GCC_RegistryResponse &() const;
    02268 #else
    02269     operator GCC_RegistryResponse &();
    02270     operator const GCC_RegistryResponse &() const;
    02271 #endif
    02272 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02273     operator GCC_RegistryAllocateHandleResponse &() const;
    02274 #else
    02275     operator GCC_RegistryAllocateHandleResponse &();
    02276     operator const GCC_RegistryAllocateHandleResponse &() const;
    02277 #endif
    02278 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02279     operator GCC_FunctionNotSupportedResponse &() const;
    02280 #else
    02281     operator GCC_FunctionNotSupportedResponse &();
    02282     operator const GCC_FunctionNotSupportedResponse &() const;
    02283 #endif
    02284 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02285     operator GCC_NonStandardPDU &() const;
    02286 #else
    02287     operator GCC_NonStandardPDU &();
    02288     operator const GCC_NonStandardPDU &() const;
    02289 #endif
    02290
    02291     PBoolean CreateObject();
    02292     PObject * Clone() const;
    02293 };
    02294
    02295
    02296 //
    02297 // IndicationPDU
    02298 //
    02299
    02300 class GCC_UserIDIndication;
    02301 class GCC_ConferenceLockIndication;
    02302 class GCC_ConferenceUnlockIndication;
    02303 class GCC_ConferenceTerminateIndication;
    02304 class GCC_ConferenceEjectUserIndication;
    02305 class GCC_ConferenceTransferIndication;
    02306 class GCC_RosterUpdateIndication;
    02307 class GCC_ApplicationInvokeIndication;
    02308 class GCC_RegistryMonitorEntryIndication;
    02309 class GCC_ConductorAssignIndication;
    02310 class GCC_ConductorReleaseIndication;
    02311 class GCC_ConductorPermissionAskIndication;
    02312 class GCC_ConductorPermissionGrantIndication;
    02313 class GCC_ConferenceTimeRemainingIndication;
    02314 class GCC_ConferenceTimeInquireIndication;
    02315 class GCC_ConferenceTimeExtendIndication;
    02316 class GCC_ConferenceAssistanceIndication;
    02317 class GCC_TextMessageIndication;
    02318 class GCC_NonStandardPDU;
    02319
    02320 class GCC_IndicationPDU : public PASN_Choice
    02321 {
    02322 #ifndef PASN_LEANANDMEAN
    02323     PCLASSINFO(GCC_IndicationPDU, PASN_Choice);
    02324 #endif
    02325   public:
    02326     GCC_IndicationPDU(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    02327
    02328     enum Choices {
    02329       e_userIDIndication,
    02330       e_conferenceLockIndication,
    02331       e_conferenceUnlockIndication,
    02332       e_conferenceTerminateIndication,
    02333       e_conferenceEjectUserIndication,
    02334       e_conferenceTransferIndication,
    02335       e_rosterUpdateIndication,
    02336       e_applicationInvokeIndication,
    02337       e_registryMonitorEntryIndication,
    02338       e_conductorAssignIndication,
    02339       e_conductorReleaseIndication,
    02340       e_conductorPermissionAskIndication,
    02341       e_conductorPermissionGrantIndication,
    02342       e_conferenceTimeRemainingIndication,
    02343       e_conferenceTimeInquireIndication,
    02344       e_conferenceTimeExtendIndication,
    02345       e_conferenceAssistanceIndication,
    02346       e_textMessageIndication,
    02347       e_nonStandardIndication
    02348     };
    02349
    02350 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02351     operator GCC_UserIDIndication &() const;
    02352 #else
    02353     operator GCC_UserIDIndication &();
    02354     operator const GCC_UserIDIndication &() const;
    02355 #endif
    02356 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02357     operator GCC_ConferenceLockIndication &() const;
    02358 #else
    02359     operator GCC_ConferenceLockIndication &();
    02360     operator const GCC_ConferenceLockIndication &() const;
    02361 #endif
    02362 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02363     operator GCC_ConferenceUnlockIndication &() const;
    02364 #else
    02365     operator GCC_ConferenceUnlockIndication &();
    02366     operator const GCC_ConferenceUnlockIndication &() const;
    02367 #endif
    02368 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02369     operator GCC_ConferenceTerminateIndication &() const;
    02370 #else
    02371     operator GCC_ConferenceTerminateIndication &();
    02372     operator const GCC_ConferenceTerminateIndication &() const;
    02373 #endif
    02374 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02375     operator GCC_ConferenceEjectUserIndication &() const;
    02376 #else
    02377     operator GCC_ConferenceEjectUserIndication &();
    02378     operator const GCC_ConferenceEjectUserIndication &() const;
    02379 #endif
    02380 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02381     operator GCC_ConferenceTransferIndication &() const;
    02382 #else
    02383     operator GCC_ConferenceTransferIndication &();
    02384     operator const GCC_ConferenceTransferIndication &() const;
    02385 #endif
    02386 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02387     operator GCC_RosterUpdateIndication &() const;
    02388 #else
    02389     operator GCC_RosterUpdateIndication &();
    02390     operator const GCC_RosterUpdateIndication &() const;
    02391 #endif
    02392 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02393     operator GCC_ApplicationInvokeIndication &() const;
    02394 #else
    02395     operator GCC_ApplicationInvokeIndication &();
    02396     operator const GCC_ApplicationInvokeIndication &() const;
    02397 #endif
    02398 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02399     operator GCC_RegistryMonitorEntryIndication &() const;
    02400 #else
    02401     operator GCC_RegistryMonitorEntryIndication &();
    02402     operator const GCC_RegistryMonitorEntryIndication &() const;
    02403 #endif
    02404 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02405     operator GCC_ConductorAssignIndication &() const;
    02406 #else
    02407     operator GCC_ConductorAssignIndication &();
    02408     operator const GCC_ConductorAssignIndication &() const;
    02409 #endif
    02410 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02411     operator GCC_ConductorReleaseIndication &() const;
    02412 #else
    02413     operator GCC_ConductorReleaseIndication &();
    02414     operator const GCC_ConductorReleaseIndication &() const;
    02415 #endif
    02416 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02417     operator GCC_ConductorPermissionAskIndication &() const;
    02418 #else
    02419     operator GCC_ConductorPermissionAskIndication &();
    02420     operator const GCC_ConductorPermissionAskIndication &() const;
    02421 #endif
    02422 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02423     operator GCC_ConductorPermissionGrantIndication &() const;
    02424 #else
    02425     operator GCC_ConductorPermissionGrantIndication &();
    02426     operator const GCC_ConductorPermissionGrantIndication &() const;
    02427 #endif
    02428 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02429     operator GCC_ConferenceTimeRemainingIndication &() const;
    02430 #else
    02431     operator GCC_ConferenceTimeRemainingIndication &();
    02432     operator const GCC_ConferenceTimeRemainingIndication &() const;
    02433 #endif
    02434 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02435     operator GCC_ConferenceTimeInquireIndication &() const;
    02436 #else
    02437     operator GCC_ConferenceTimeInquireIndication &();
    02438     operator const GCC_ConferenceTimeInquireIndication &() const;
    02439 #endif
    02440 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02441     operator GCC_ConferenceTimeExtendIndication &() const;
    02442 #else
    02443     operator GCC_ConferenceTimeExtendIndication &();
    02444     operator const GCC_ConferenceTimeExtendIndication &() const;
    02445 #endif
    02446 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02447     operator GCC_ConferenceAssistanceIndication &() const;
    02448 #else
    02449     operator GCC_ConferenceAssistanceIndication &();
    02450     operator const GCC_ConferenceAssistanceIndication &() const;
    02451 #endif
    02452 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02453     operator GCC_TextMessageIndication &() const;
    02454 #else
    02455     operator GCC_TextMessageIndication &();
    02456     operator const GCC_TextMessageIndication &() const;
    02457 #endif
    02458 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02459     operator GCC_NonStandardPDU &() const;
    02460 #else
    02461     operator GCC_NonStandardPDU &();
    02462     operator const GCC_NonStandardPDU &() const;
    02463 #endif
    02464
    02465     PBoolean CreateObject();
    02466     PObject * Clone() const;
    02467 };
    02468
    02469
    02470 //
    02471 // UserData_subtype
    02472 //
    02473
    02474 class GCC_UserData_subtype : public PASN_Sequence
    02475 {
    02476 #ifndef PASN_LEANANDMEAN
    02477     PCLASSINFO(GCC_UserData_subtype, PASN_Sequence);
    02478 #endif
    02479   public:
    02480     GCC_UserData_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    02481
    02482     enum OptionalFields {
    02483       e_value
    02484     };
    02485
    02486     GCC_Key m_key;
    02487     PASN_OctetString m_value;
    02488
    02489     PINDEX GetDataLength() const;
    02490     PBoolean Decode(PASN_Stream & strm);
    02491     void Encode(PASN_Stream & strm) const;
    02492 #ifndef PASN_NOPRINTON
    02493     void PrintOn(ostream & strm) const;
    02494 #endif
    02495     Comparison Compare(const PObject & obj) const;
    02496     PObject * Clone() const;
    02497 };
    02498
    02499
    02500 //
    02501 // ArrayOf_ChallengeItem
    02502 //
    02503
    02504 class GCC_ChallengeItem;
    02505
    02506 class GCC_ArrayOf_ChallengeItem : public PASN_Array
    02507 {
    02508 #ifndef PASN_LEANANDMEAN
    02509     PCLASSINFO(GCC_ArrayOf_ChallengeItem, PASN_Array);
    02510 #endif
    02511   public:
    02512     GCC_ArrayOf_ChallengeItem(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    02513
    02514     PASN_Object * CreateObject() const;
    02515     GCC_ChallengeItem & operator[](PINDEX i) const;
    02516     PObject * Clone() const;
    02517 };
    02518
    02519
    02520 //
    02521 // NetworkAddress_subtype
    02522 //
    02523
    02524 class GCC_NetworkAddress_subtype_aggregatedChannel;
    02525 class GCC_NetworkAddress_subtype_transportConnection;
    02526 class GCC_NonStandardParameter;
    02527
    02528 class GCC_NetworkAddress_subtype : public PASN_Choice
    02529 {
    02530 #ifndef PASN_LEANANDMEAN
    02531     PCLASSINFO(GCC_NetworkAddress_subtype, PASN_Choice);
    02532 #endif
    02533   public:
    02534     GCC_NetworkAddress_subtype(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    02535
    02536     enum Choices {
    02537       e_aggregatedChannel,
    02538       e_transportConnection,
    02539       e_nonStandard
    02540     };
    02541
    02542 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02543     operator GCC_NetworkAddress_subtype_aggregatedChannel &() const;
    02544 #else
    02545     operator GCC_NetworkAddress_subtype_aggregatedChannel &();
    02546     operator const GCC_NetworkAddress_subtype_aggregatedChannel &() const;
    02547 #endif
    02548 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02549     operator GCC_NetworkAddress_subtype_transportConnection &() const;
    02550 #else
    02551     operator GCC_NetworkAddress_subtype_transportConnection &();
    02552     operator const GCC_NetworkAddress_subtype_transportConnection &() const;
    02553 #endif
    02554 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    02555     operator GCC_NonStandardParameter &() const;
    02556 #else
    02557     operator GCC_NonStandardParameter &();
    02558     operator const GCC_NonStandardParameter &() const;
    02559 #endif
    02560
    02561     PBoolean CreateObject();
    02562     PObject * Clone() const;
    02563 };
    02564
    02565
    02566 //
    02567 // ArrayOf_TextString
    02568 //
    02569
    02570 class GCC_TextString;
    02571
    02572 class GCC_ArrayOf_TextString : public PASN_Array
    02573 {
    02574 #ifndef PASN_LEANANDMEAN
    02575     PCLASSINFO(GCC_ArrayOf_TextString, PASN_Array);
    02576 #endif
    02577   public:
    02578     GCC_ArrayOf_TextString(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    02579
    02580     PASN_Object * CreateObject() const;
    02581     GCC_TextString & operator[](PINDEX i) const;
    02582     PObject * Clone() const;
    02583 };
    02584
    02585
    02586 //
    02587 // ApplicationRecord_nonCollapsingCapabilities
    02588 //
    02589
    02590 class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype;
    02591
    02592 class GCC_ApplicationRecord_nonCollapsingCapabilities : public PASN_Array
    02593 {
    02594 #ifndef PASN_LEANANDMEAN
    02595     PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities, PASN_Array);
    02596 #endif
    02597   public:
    02598     GCC_ApplicationRecord_nonCollapsingCapabilities(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    02599
    02600     PASN_Object * CreateObject() const;
    02601     GCC_ApplicationRecord_nonCollapsingCapabilities_subtype & operator[](PINDEX i) const;
    02602     PObject * Clone() const;
    02603 };
    02604
    02605
    02606 //
    02607 // ApplicationInvokeSpecifier_expectedCapabilitySet
    02608 //
    02609
    02610 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype;
    02611
    02612 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet : public PASN_Array
    02613 {
    02614 #ifndef PASN_LEANANDMEAN
    02615     PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet, PASN_Array);
    02616 #endif
    02617   public:
    02618     GCC_ApplicationInvokeSpecifier_expectedCapabilitySet(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    02619
    02620     PASN_Object * CreateObject() const;
    02621     GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype & operator[](PINDEX i) const;
    02622     PObject * Clone() const;
    02623 };
    02624
    02625
    02626 //
    02627 // RegistryEntryOwner_owned
    02628 //
    02629
    02630 class GCC_RegistryEntryOwner_owned : public PASN_Sequence
    02631 {
    02632 #ifndef PASN_LEANANDMEAN
    02633     PCLASSINFO(GCC_RegistryEntryOwner_owned, PASN_Sequence);
    02634 #endif
    02635   public:
    02636     GCC_RegistryEntryOwner_owned(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    02637
    02638     GCC_UserID m_nodeID;
    02639     GCC_EntityID m_entityID;
    02640
    02641     PINDEX GetDataLength() const;
    02642     PBoolean Decode(PASN_Stream & strm);
    02643     void Encode(PASN_Stream & strm) const;
    02644 #ifndef PASN_NOPRINTON
    02645     void PrintOn(ostream & strm) const;
    02646 #endif
    02647     Comparison Compare(const PObject & obj) const;
    02648     PObject * Clone() const;
    02649 };
    02650
    02651
    02652 //
    02653 // ArrayOf_Privilege
    02654 //
    02655
    02656 class GCC_Privilege;
    02657
    02658 class GCC_ArrayOf_Privilege : public PASN_Array
    02659 {
    02660 #ifndef PASN_LEANANDMEAN
    02661     PCLASSINFO(GCC_ArrayOf_Privilege, PASN_Array);
    02662 #endif
    02663   public:
    02664     GCC_ArrayOf_Privilege(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    02665
    02666     PASN_Object * CreateObject() const;
    02667     GCC_Privilege & operator[](PINDEX i) const;
    02668     PObject * Clone() const;
    02669 };
    02670
    02671
    02672 //
    02673 // ConferenceCreateResponse_result
    02674 //
    02675
    02676 class GCC_ConferenceCreateResponse_result : public PASN_Enumeration
    02677 {
    02678 #ifndef PASN_LEANANDMEAN
    02679     PCLASSINFO(GCC_ConferenceCreateResponse_result, PASN_Enumeration);
    02680 #endif
    02681   public:
    02682     GCC_ConferenceCreateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02683
    02684     enum Enumerations {
    02685       e_success,
    02686       e_userRejected,
    02687       e_resourcesNotAvailable,
    02688       e_rejectedForSymmetryBreaking,
    02689       e_lockedConferenceNotSupported
    02690     };
    02691
    02692     GCC_ConferenceCreateResponse_result & operator=(unsigned v);
    02693     PObject * Clone() const;
    02694 };
    02695
    02696
    02697 //
    02698 // ArrayOf_ConferenceDescriptor
    02699 //
    02700
    02701 class GCC_ConferenceDescriptor;
    02702
    02703 class GCC_ArrayOf_ConferenceDescriptor : public PASN_Array
    02704 {
    02705 #ifndef PASN_LEANANDMEAN
    02706     PCLASSINFO(GCC_ArrayOf_ConferenceDescriptor, PASN_Array);
    02707 #endif
    02708   public:
    02709     GCC_ArrayOf_ConferenceDescriptor(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    02710
    02711     PASN_Object * CreateObject() const;
    02712     GCC_ConferenceDescriptor & operator[](PINDEX i) const;
    02713     PObject * Clone() const;
    02714 };
    02715
    02716
    02717 //
    02718 // ConferenceQueryResponse_result
    02719 //
    02720
    02721 class GCC_ConferenceQueryResponse_result : public PASN_Enumeration
    02722 {
    02723 #ifndef PASN_LEANANDMEAN
    02724     PCLASSINFO(GCC_ConferenceQueryResponse_result, PASN_Enumeration);
    02725 #endif
    02726   public:
    02727     GCC_ConferenceQueryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02728
    02729     enum Enumerations {
    02730       e_success,
    02731       e_userRejected
    02732     };
    02733
    02734     GCC_ConferenceQueryResponse_result & operator=(unsigned v);
    02735     PObject * Clone() const;
    02736 };
    02737
    02738
    02739 //
    02740 // ConferenceJoinResponse_result
    02741 //
    02742
    02743 class GCC_ConferenceJoinResponse_result : public PASN_Enumeration
    02744 {
    02745 #ifndef PASN_LEANANDMEAN
    02746     PCLASSINFO(GCC_ConferenceJoinResponse_result, PASN_Enumeration);
    02747 #endif
    02748   public:
    02749     GCC_ConferenceJoinResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02750
    02751     enum Enumerations {
    02752       e_success,
    02753       e_userRejected,
    02754       e_invalidConference,
    02755       e_invalidPassword,
    02756       e_invalidConvenerPassword,
    02757       e_challengeResponseRequired,
    02758       e_invalidChallengeResponse
    02759     };
    02760
    02761     GCC_ConferenceJoinResponse_result & operator=(unsigned v);
    02762     PObject * Clone() const;
    02763 };
    02764
    02765
    02766 //
    02767 // ConferenceInviteResponse_result
    02768 //
    02769
    02770 class GCC_ConferenceInviteResponse_result : public PASN_Enumeration
    02771 {
    02772 #ifndef PASN_LEANANDMEAN
    02773     PCLASSINFO(GCC_ConferenceInviteResponse_result, PASN_Enumeration);
    02774 #endif
    02775   public:
    02776     GCC_ConferenceInviteResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02777
    02778     enum Enumerations {
    02779       e_success,
    02780       e_userRejected
    02781     };
    02782
    02783     GCC_ConferenceInviteResponse_result & operator=(unsigned v);
    02784     PObject * Clone() const;
    02785 };
    02786
    02787
    02788 //
    02789 // ConferenceAddResponse_result
    02790 //
    02791
    02792 class GCC_ConferenceAddResponse_result : public PASN_Enumeration
    02793 {
    02794 #ifndef PASN_LEANANDMEAN
    02795     PCLASSINFO(GCC_ConferenceAddResponse_result, PASN_Enumeration);
    02796 #endif
    02797   public:
    02798     GCC_ConferenceAddResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02799
    02800     enum Enumerations {
    02801       e_success,
    02802       e_invalidRequester,
    02803       e_invalidNetworkType,
    02804       e_invalidNetworkAddress,
    02805       e_addedNodeBusy,
    02806       e_networkBusy,
    02807       e_noPortsAvailable,
    02808       e_connectionUnsuccessful
    02809     };
    02810
    02811     GCC_ConferenceAddResponse_result & operator=(unsigned v);
    02812     PObject * Clone() const;
    02813 };
    02814
    02815
    02816 //
    02817 // ConferenceLockResponse_result
    02818 //
    02819
    02820 class GCC_ConferenceLockResponse_result : public PASN_Enumeration
    02821 {
    02822 #ifndef PASN_LEANANDMEAN
    02823     PCLASSINFO(GCC_ConferenceLockResponse_result, PASN_Enumeration);
    02824 #endif
    02825   public:
    02826     GCC_ConferenceLockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02827
    02828     enum Enumerations {
    02829       e_success,
    02830       e_invalidRequester,
    02831       e_alreadyLocked
    02832     };
    02833
    02834     GCC_ConferenceLockResponse_result & operator=(unsigned v);
    02835     PObject * Clone() const;
    02836 };
    02837
    02838
    02839 //
    02840 // ConferenceUnlockResponse_result
    02841 //
    02842
    02843 class GCC_ConferenceUnlockResponse_result : public PASN_Enumeration
    02844 {
    02845 #ifndef PASN_LEANANDMEAN
    02846     PCLASSINFO(GCC_ConferenceUnlockResponse_result, PASN_Enumeration);
    02847 #endif
    02848   public:
    02849     GCC_ConferenceUnlockResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02850
    02851     enum Enumerations {
    02852       e_success,
    02853       e_invalidRequester,
    02854       e_alreadyUnlocked
    02855     };
    02856
    02857     GCC_ConferenceUnlockResponse_result & operator=(unsigned v);
    02858     PObject * Clone() const;
    02859 };
    02860
    02861
    02862 //
    02863 // ConferenceTerminateRequest_reason
    02864 //
    02865
    02866 class GCC_ConferenceTerminateRequest_reason : public PASN_Enumeration
    02867 {
    02868 #ifndef PASN_LEANANDMEAN
    02869     PCLASSINFO(GCC_ConferenceTerminateRequest_reason, PASN_Enumeration);
    02870 #endif
    02871   public:
    02872     GCC_ConferenceTerminateRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02873
    02874     enum Enumerations {
    02875       e_userInitiated,
    02876       e_timedConferenceTermination
    02877     };
    02878
    02879     GCC_ConferenceTerminateRequest_reason & operator=(unsigned v);
    02880     PObject * Clone() const;
    02881 };
    02882
    02883
    02884 //
    02885 // ConferenceTerminateResponse_result
    02886 //
    02887
    02888 class GCC_ConferenceTerminateResponse_result : public PASN_Enumeration
    02889 {
    02890 #ifndef PASN_LEANANDMEAN
    02891     PCLASSINFO(GCC_ConferenceTerminateResponse_result, PASN_Enumeration);
    02892 #endif
    02893   public:
    02894     GCC_ConferenceTerminateResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02895
    02896     enum Enumerations {
    02897       e_success,
    02898       e_invalidRequester
    02899     };
    02900
    02901     GCC_ConferenceTerminateResponse_result & operator=(unsigned v);
    02902     PObject * Clone() const;
    02903 };
    02904
    02905
    02906 //
    02907 // ConferenceTerminateIndication_reason
    02908 //
    02909
    02910 class GCC_ConferenceTerminateIndication_reason : public PASN_Enumeration
    02911 {
    02912 #ifndef PASN_LEANANDMEAN
    02913     PCLASSINFO(GCC_ConferenceTerminateIndication_reason, PASN_Enumeration);
    02914 #endif
    02915   public:
    02916     GCC_ConferenceTerminateIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02917
    02918     enum Enumerations {
    02919       e_userInitiated,
    02920       e_timedConferenceTermination
    02921     };
    02922
    02923     GCC_ConferenceTerminateIndication_reason & operator=(unsigned v);
    02924     PObject * Clone() const;
    02925 };
    02926
    02927
    02928 //
    02929 // ConferenceEjectUserRequest_reason
    02930 //
    02931
    02932 class GCC_ConferenceEjectUserRequest_reason : public PASN_Enumeration
    02933 {
    02934 #ifndef PASN_LEANANDMEAN
    02935     PCLASSINFO(GCC_ConferenceEjectUserRequest_reason, PASN_Enumeration);
    02936 #endif
    02937   public:
    02938     GCC_ConferenceEjectUserRequest_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02939
    02940     enum Enumerations {
    02941       e_userInitiated
    02942     };
    02943
    02944     GCC_ConferenceEjectUserRequest_reason & operator=(unsigned v);
    02945     PObject * Clone() const;
    02946 };
    02947
    02948
    02949 //
    02950 // ConferenceEjectUserResponse_result
    02951 //
    02952
    02953 class GCC_ConferenceEjectUserResponse_result : public PASN_Enumeration
    02954 {
    02955 #ifndef PASN_LEANANDMEAN
    02956     PCLASSINFO(GCC_ConferenceEjectUserResponse_result, PASN_Enumeration);
    02957 #endif
    02958   public:
    02959     GCC_ConferenceEjectUserResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02960
    02961     enum Enumerations {
    02962       e_success,
    02963       e_invalidRequester,
    02964       e_invalidNode
    02965     };
    02966
    02967     GCC_ConferenceEjectUserResponse_result & operator=(unsigned v);
    02968     PObject * Clone() const;
    02969 };
    02970
    02971
    02972 //
    02973 // ConferenceEjectUserIndication_reason
    02974 //
    02975
    02976 class GCC_ConferenceEjectUserIndication_reason : public PASN_Enumeration
    02977 {
    02978 #ifndef PASN_LEANANDMEAN
    02979     PCLASSINFO(GCC_ConferenceEjectUserIndication_reason, PASN_Enumeration);
    02980 #endif
    02981   public:
    02982     GCC_ConferenceEjectUserIndication_reason(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    02983
    02984     enum Enumerations {
    02985       e_userInitiated,
    02986       e_higherNodeDisconnected,
    02987       e_higherNodeEjected
    02988     };
    02989
    02990     GCC_ConferenceEjectUserIndication_reason & operator=(unsigned v);
    02991     PObject * Clone() const;
    02992 };
    02993
    02994
    02995 //
    02996 // ArrayOf_UserID
    02997 //
    02998
    02999 class GCC_UserID;
    03000
    03001 class GCC_ArrayOf_UserID : public PASN_Array
    03002 {
    03003 #ifndef PASN_LEANANDMEAN
    03004     PCLASSINFO(GCC_ArrayOf_UserID, PASN_Array);
    03005 #endif
    03006   public:
    03007     GCC_ArrayOf_UserID(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03008
    03009     PASN_Object * CreateObject() const;
    03010     GCC_UserID & operator[](PINDEX i) const;
    03011     PObject * Clone() const;
    03012 };
    03013
    03014
    03015 //
    03016 // ConferenceTransferResponse_result
    03017 //
    03018
    03019 class GCC_ConferenceTransferResponse_result : public PASN_Enumeration
    03020 {
    03021 #ifndef PASN_LEANANDMEAN
    03022     PCLASSINFO(GCC_ConferenceTransferResponse_result, PASN_Enumeration);
    03023 #endif
    03024   public:
    03025     GCC_ConferenceTransferResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    03026
    03027     enum Enumerations {
    03028       e_success,
    03029       e_invalidRequester
    03030     };
    03031
    03032     GCC_ConferenceTransferResponse_result & operator=(unsigned v);
    03033     PObject * Clone() const;
    03034 };
    03035
    03036
    03037 //
    03038 // RosterUpdateIndication_applicationInformation
    03039 //
    03040
    03041 class GCC_RosterUpdateIndication_applicationInformation_subtype;
    03042
    03043 class GCC_RosterUpdateIndication_applicationInformation : public PASN_Array
    03044 {
    03045 #ifndef PASN_LEANANDMEAN
    03046     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation, PASN_Array);
    03047 #endif
    03048   public:
    03049     GCC_RosterUpdateIndication_applicationInformation(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03050
    03051     PASN_Object * CreateObject() const;
    03052     GCC_RosterUpdateIndication_applicationInformation_subtype & operator[](PINDEX i) const;
    03053     PObject * Clone() const;
    03054 };
    03055
    03056
    03057 //
    03058 // ArrayOf_ApplicationInvokeSpecifier
    03059 //
    03060
    03061 class GCC_ApplicationInvokeSpecifier;
    03062
    03063 class GCC_ArrayOf_ApplicationInvokeSpecifier : public PASN_Array
    03064 {
    03065 #ifndef PASN_LEANANDMEAN
    03066     PCLASSINFO(GCC_ArrayOf_ApplicationInvokeSpecifier, PASN_Array);
    03067 #endif
    03068   public:
    03069     GCC_ArrayOf_ApplicationInvokeSpecifier(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03070
    03071     PASN_Object * CreateObject() const;
    03072     GCC_ApplicationInvokeSpecifier & operator[](PINDEX i) const;
    03073     PObject * Clone() const;
    03074 };
    03075
    03076
    03077 //
    03078 // RegistryAllocateHandleResponse_result
    03079 //
    03080
    03081 class GCC_RegistryAllocateHandleResponse_result : public PASN_Enumeration
    03082 {
    03083 #ifndef PASN_LEANANDMEAN
    03084     PCLASSINFO(GCC_RegistryAllocateHandleResponse_result, PASN_Enumeration);
    03085 #endif
    03086   public:
    03087     GCC_RegistryAllocateHandleResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    03088
    03089     enum Enumerations {
    03090       e_successful,
    03091       e_noHandlesAvailable
    03092     };
    03093
    03094     GCC_RegistryAllocateHandleResponse_result & operator=(unsigned v);
    03095     PObject * Clone() const;
    03096 };
    03097
    03098
    03099 //
    03100 // RegistryResponse_primitiveType
    03101 //
    03102
    03103 class GCC_RegistryResponse_primitiveType : public PASN_Enumeration
    03104 {
    03105 #ifndef PASN_LEANANDMEAN
    03106     PCLASSINFO(GCC_RegistryResponse_primitiveType, PASN_Enumeration);
    03107 #endif
    03108   public:
    03109     GCC_RegistryResponse_primitiveType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    03110
    03111     enum Enumerations {
    03112       e_registerChannel,
    03113       e_assignToken,
    03114       e_setParameter,
    03115       e_retrieveEntry,
    03116       e_deleteEntry,
    03117       e_monitorEntry
    03118     };
    03119
    03120     GCC_RegistryResponse_primitiveType & operator=(unsigned v);
    03121     PObject * Clone() const;
    03122 };
    03123
    03124
    03125 //
    03126 // RegistryResponse_result
    03127 //
    03128
    03129 class GCC_RegistryResponse_result : public PASN_Enumeration
    03130 {
    03131 #ifndef PASN_LEANANDMEAN
    03132     PCLASSINFO(GCC_RegistryResponse_result, PASN_Enumeration);
    03133 #endif
    03134   public:
    03135     GCC_RegistryResponse_result(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);
    03136
    03137     enum Enumerations {
    03138       e_successful,
    03139       e_belongsToOther,
    03140       e_tooManyEntries,
    03141       e_inconsistentType,
    03142       e_entryNotFound,
    03143       e_entryAlreadyExists,
    03144       e_invalidRequester
    03145     };
    03146
    03147     GCC_RegistryResponse_result & operator=(unsigned v);
    03148     PObject * Clone() const;
    03149 };
    03150
    03151
    03152 //
    03153 // NetworkAddress_subtype_transportConnection
    03154 //
    03155
    03156 class GCC_NetworkAddress_subtype_transportConnection : public PASN_Sequence
    03157 {
    03158 #ifndef PASN_LEANANDMEAN
    03159     PCLASSINFO(GCC_NetworkAddress_subtype_transportConnection, PASN_Sequence);
    03160 #endif
    03161   public:
    03162     GCC_NetworkAddress_subtype_transportConnection(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03163
    03164     enum OptionalFields {
    03165       e_transportSelector
    03166     };
    03167
    03168     PASN_OctetString m_nsapAddress;
    03169     PASN_OctetString m_transportSelector;
    03170
    03171     PINDEX GetDataLength() const;
    03172     PBoolean Decode(PASN_Stream & strm);
    03173     void Encode(PASN_Stream & strm) const;
    03174 #ifndef PASN_NOPRINTON
    03175     void PrintOn(ostream & strm) const;
    03176 #endif
    03177     Comparison Compare(const PObject & obj) const;
    03178     PObject * Clone() const;
    03179 };
    03180
    03181
    03182 //
    03183 // ApplicationRecord_nonCollapsingCapabilities_subtype
    03184 //
    03185
    03186 class GCC_ApplicationRecord_nonCollapsingCapabilities_subtype : public PASN_Sequence
    03187 {
    03188 #ifndef PASN_LEANANDMEAN
    03189     PCLASSINFO(GCC_ApplicationRecord_nonCollapsingCapabilities_subtype, PASN_Sequence);
    03190 #endif
    03191   public:
    03192     GCC_ApplicationRecord_nonCollapsingCapabilities_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03193
    03194     enum OptionalFields {
    03195       e_applicationData
    03196     };
    03197
    03198     GCC_CapabilityID m_capabilityID;
    03199     PASN_OctetString m_applicationData;
    03200
    03201     PINDEX GetDataLength() const;
    03202     PBoolean Decode(PASN_Stream & strm);
    03203     void Encode(PASN_Stream & strm) const;
    03204 #ifndef PASN_NOPRINTON
    03205     void PrintOn(ostream & strm) const;
    03206 #endif
    03207     Comparison Compare(const PObject & obj) const;
    03208     PObject * Clone() const;
    03209 };
    03210
    03211
    03212 //
    03213 // ApplicationInvokeSpecifier_expectedCapabilitySet_subtype
    03214 //
    03215
    03216 class GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype : public PASN_Sequence
    03217 {
    03218 #ifndef PASN_LEANANDMEAN
    03219     PCLASSINFO(GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype, PASN_Sequence);
    03220 #endif
    03221   public:
    03222     GCC_ApplicationInvokeSpecifier_expectedCapabilitySet_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03223
    03224     GCC_CapabilityID m_capabilityID;
    03225     GCC_CapabilityClass m_capabilityClass;
    03226
    03227     PINDEX GetDataLength() const;
    03228     PBoolean Decode(PASN_Stream & strm);
    03229     void Encode(PASN_Stream & strm) const;
    03230 #ifndef PASN_NOPRINTON
    03231     void PrintOn(ostream & strm) const;
    03232 #endif
    03233     Comparison Compare(const PObject & obj) const;
    03234     PObject * Clone() const;
    03235 };
    03236
    03237
    03238 //
    03239 // RosterUpdateIndication_nodeInformation_nodeRecordList
    03240 //
    03241
    03242 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh;
    03243 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update;
    03244
    03245 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList : public PASN_Choice
    03246 {
    03247 #ifndef PASN_LEANANDMEAN
    03248     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList, PASN_Choice);
    03249 #endif
    03250   public:
    03251     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    03252
    03253     enum Choices {
    03254       e_noChange,
    03255       e_refresh,
    03256       e_update
    03257     };
    03258
    03259 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03260     operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const;
    03261 #else
    03262     operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &();
    03263     operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh &() const;
    03264 #endif
    03265 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03266     operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const;
    03267 #else
    03268     operator GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &();
    03269     operator const GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update &() const;
    03270 #endif
    03271
    03272     PBoolean CreateObject();
    03273     PObject * Clone() const;
    03274 };
    03275
    03276
    03277 //
    03278 // NetworkAddress_subtype_aggregatedChannel_transferModes
    03279 //
    03280
    03281 class GCC_NetworkAddress_subtype_aggregatedChannel_transferModes : public PASN_Sequence
    03282 {
    03283 #ifndef PASN_LEANANDMEAN
    03284     PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_transferModes, PASN_Sequence);
    03285 #endif
    03286   public:
    03287     GCC_NetworkAddress_subtype_aggregatedChannel_transferModes(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03288
    03289     PASN_Boolean m_speech;
    03290     PASN_Boolean m_voice_band;
    03291     PASN_Boolean m_digital_56k;
    03292     PASN_Boolean m_digital_64k;
    03293     PASN_Boolean m_digital_128k;
    03294     PASN_Boolean m_digital_192k;
    03295     PASN_Boolean m_digital_256k;
    03296     PASN_Boolean m_digital_320k;
    03297     PASN_Boolean m_digital_384k;
    03298     PASN_Boolean m_digital_512k;
    03299     PASN_Boolean m_digital_768k;
    03300     PASN_Boolean m_digital_1152k;
    03301     PASN_Boolean m_digital_1472k;
    03302     PASN_Boolean m_digital_1536k;
    03303     PASN_Boolean m_digital_1920k;
    03304     PASN_Boolean m_packet_mode;
    03305     PASN_Boolean m_frame_mode;
    03306     PASN_Boolean m_atm;
    03307
    03308     PINDEX GetDataLength() const;
    03309     PBoolean Decode(PASN_Stream & strm);
    03310     void Encode(PASN_Stream & strm) const;
    03311 #ifndef PASN_NOPRINTON
    03312     void PrintOn(ostream & strm) const;
    03313 #endif
    03314     Comparison Compare(const PObject & obj) const;
    03315     PObject * Clone() const;
    03316 };
    03317
    03318
    03319 //
    03320 // NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility
    03321 //
    03322
    03323 class GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility : public PASN_Sequence
    03324 {
    03325 #ifndef PASN_LEANANDMEAN
    03326     PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility, PASN_Sequence);
    03327 #endif
    03328   public:
    03329     GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03330
    03331     PASN_Boolean m_telephony3kHz;
    03332     PASN_Boolean m_telephony7kHz;
    03333     PASN_Boolean m_videotelephony;
    03334     PASN_Boolean m_videoconference;
    03335     PASN_Boolean m_audiographic;
    03336     PASN_Boolean m_audiovisual;
    03337     PASN_Boolean m_multimedia;
    03338
    03339     PINDEX GetDataLength() const;
    03340     PBoolean Decode(PASN_Stream & strm);
    03341     void Encode(PASN_Stream & strm) const;
    03342 #ifndef PASN_NOPRINTON
    03343     void PrintOn(ostream & strm) const;
    03344 #endif
    03345     Comparison Compare(const PObject & obj) const;
    03346     PObject * Clone() const;
    03347 };
    03348
    03349
    03350 //
    03351 // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh
    03352 //
    03353
    03354 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype;
    03355
    03356 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh : public PASN_Array
    03357 {
    03358 #ifndef PASN_LEANANDMEAN
    03359     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh, PASN_Array);
    03360 #endif
    03361   public:
    03362     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03363
    03364     PASN_Object * CreateObject() const;
    03365     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype & operator[](PINDEX i) const;
    03366     PObject * Clone() const;
    03367 };
    03368
    03369
    03370 //
    03371 // RosterUpdateIndication_nodeInformation_nodeRecordList_update
    03372 //
    03373
    03374 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype;
    03375
    03376 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update : public PASN_Array
    03377 {
    03378 #ifndef PASN_LEANANDMEAN
    03379     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update, PASN_Array);
    03380 #endif
    03381   public:
    03382     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03383
    03384     PASN_Object * CreateObject() const;
    03385     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype & operator[](PINDEX i) const;
    03386     PObject * Clone() const;
    03387 };
    03388
    03389
    03390 //
    03391 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList
    03392 //
    03393
    03394 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh;
    03395 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update;
    03396
    03397 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList : public PASN_Choice
    03398 {
    03399 #ifndef PASN_LEANANDMEAN
    03400     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList, PASN_Choice);
    03401 #endif
    03402   public:
    03403     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    03404
    03405     enum Choices {
    03406       e_noChange,
    03407       e_refresh,
    03408       e_update
    03409     };
    03410
    03411 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03412     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const;
    03413 #else
    03414     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &();
    03415     operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh &() const;
    03416 #endif
    03417 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03418     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const;
    03419 #else
    03420     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &();
    03421     operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update &() const;
    03422 #endif
    03423
    03424     PBoolean CreateObject();
    03425     PObject * Clone() const;
    03426 };
    03427
    03428
    03429 //
    03430 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList
    03431 //
    03432
    03433 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh;
    03434
    03435 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList : public PASN_Choice
    03436 {
    03437 #ifndef PASN_LEANANDMEAN
    03438     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList, PASN_Choice);
    03439 #endif
    03440   public:
    03441     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    03442
    03443     enum Choices {
    03444       e_noChange,
    03445       e_refresh
    03446     };
    03447
    03448 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03449     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const;
    03450 #else
    03451     operator GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &();
    03452     operator const GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh &() const;
    03453 #endif
    03454
    03455     PBoolean CreateObject();
    03456     PObject * Clone() const;
    03457 };
    03458
    03459
    03460 //
    03461 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh
    03462 //
    03463
    03464 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype;
    03465
    03466 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh : public PASN_Array
    03467 {
    03468 #ifndef PASN_LEANANDMEAN
    03469     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh, PASN_Array);
    03470 #endif
    03471   public:
    03472     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03473
    03474     PASN_Object * CreateObject() const;
    03475     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype & operator[](PINDEX i) const;
    03476     PObject * Clone() const;
    03477 };
    03478
    03479
    03480 //
    03481 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update
    03482 //
    03483
    03484 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype;
    03485
    03486 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update : public PASN_Array
    03487 {
    03488 #ifndef PASN_LEANANDMEAN
    03489     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update, PASN_Array);
    03490 #endif
    03491   public:
    03492     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03493
    03494     PASN_Object * CreateObject() const;
    03495     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype & operator[](PINDEX i) const;
    03496     PObject * Clone() const;
    03497 };
    03498
    03499
    03500 //
    03501 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh
    03502 //
    03503
    03504 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype;
    03505
    03506 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh : public PASN_Array
    03507 {
    03508 #ifndef PASN_LEANANDMEAN
    03509     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh, PASN_Array);
    03510 #endif
    03511   public:
    03512     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);
    03513
    03514     PASN_Object * CreateObject() const;
    03515     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype & operator[](PINDEX i) const;
    03516     PObject * Clone() const;
    03517 };
    03518
    03519
    03520 //
    03521 // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate
    03522 //
    03523
    03524 class GCC_NodeRecord;
    03525
    03526 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate : public PASN_Choice
    03527 {
    03528 #ifndef PASN_LEANANDMEAN
    03529     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate, PASN_Choice);
    03530 #endif
    03531   public:
    03532     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    03533
    03534     enum Choices {
    03535       e_addRecord,
    03536       e_replaceRecord,
    03537       e_removeRecord
    03538     };
    03539
    03540 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03541     operator GCC_NodeRecord &() const;
    03542 #else
    03543     operator GCC_NodeRecord &();
    03544     operator const GCC_NodeRecord &() const;
    03545 #endif
    03546
    03547     PBoolean CreateObject();
    03548     PObject * Clone() const;
    03549 };
    03550
    03551
    03552 //
    03553 // RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype
    03554 //
    03555
    03556 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype : public PASN_Sequence
    03557 {
    03558 #ifndef PASN_LEANANDMEAN
    03559     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype, PASN_Sequence);
    03560 #endif
    03561   public:
    03562     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03563
    03564     GCC_CapabilityID m_capabilityID;
    03565     GCC_CapabilityClass m_capabilityClass;
    03566     PASN_Integer m_numberOfEntities;
    03567
    03568     PINDEX GetDataLength() const;
    03569     PBoolean Decode(PASN_Stream & strm);
    03570     void Encode(PASN_Stream & strm) const;
    03571 #ifndef PASN_NOPRINTON
    03572     void PrintOn(ostream & strm) const;
    03573 #endif
    03574     Comparison Compare(const PObject & obj) const;
    03575     PObject * Clone() const;
    03576 };
    03577
    03578
    03579 //
    03580 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate
    03581 //
    03582
    03583 class GCC_ApplicationRecord;
    03584
    03585 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate : public PASN_Choice
    03586 {
    03587 #ifndef PASN_LEANANDMEAN
    03588     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate, PASN_Choice);
    03589 #endif
    03590   public:
    03591     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate(unsigned tag = 0, TagClass tagClass = UniversalTagClass);
    03592
    03593     enum Choices {
    03594       e_addRecord,
    03595       e_replaceRecord,
    03596       e_removeRecord
    03597     };
    03598
    03599 #if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    03600     operator GCC_ApplicationRecord &() const;
    03601 #else
    03602     operator GCC_ApplicationRecord &();
    03603     operator const GCC_ApplicationRecord &() const;
    03604 #endif
    03605
    03606     PBoolean CreateObject();
    03607     PObject * Clone() const;
    03608 };
    03609
    03610
    03611 //
    03612 // ChallengeRequest
    03613 //
    03614
    03615 class GCC_ChallengeRequest : public PASN_Sequence
    03616 {
    03617 #ifndef PASN_LEANANDMEAN
    03618     PCLASSINFO(GCC_ChallengeRequest, PASN_Sequence);
    03619 #endif
    03620   public:
    03621     GCC_ChallengeRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03622
    03623     PASN_Integer m_challengeTag;
    03624     GCC_ArrayOf_ChallengeItem m_challengeSet;
    03625
    03626     PINDEX GetDataLength() const;
    03627     PBoolean Decode(PASN_Stream & strm);
    03628     void Encode(PASN_Stream & strm) const;
    03629 #ifndef PASN_NOPRINTON
    03630     void PrintOn(ostream & strm) const;
    03631 #endif
    03632     Comparison Compare(const PObject & obj) const;
    03633     PObject * Clone() const;
    03634 };
    03635
    03636
    03637 //
    03638 // NodeRecord
    03639 //
    03640
    03641 class GCC_NodeRecord : public PASN_Sequence
    03642 {
    03643 #ifndef PASN_LEANANDMEAN
    03644     PCLASSINFO(GCC_NodeRecord, PASN_Sequence);
    03645 #endif
    03646   public:
    03647     GCC_NodeRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03648
    03649     enum OptionalFields {
    03650       e_superiorNode,
    03651       e_nodeName,
    03652       e_participantsList,
    03653       e_siteInformation,
    03654       e_networkAddress,
    03655       e_alternativeNodeID,
    03656       e_userData
    03657     };
    03658
    03659     GCC_UserID m_superiorNode;
    03660     GCC_NodeType m_nodeType;
    03661     GCC_NodeProperties m_nodeProperties;
    03662     GCC_TextString m_nodeName;
    03663     GCC_ArrayOf_TextString m_participantsList;
    03664     GCC_TextString m_siteInformation;
    03665     GCC_NetworkAddress m_networkAddress;
    03666     GCC_AlternativeNodeID m_alternativeNodeID;
    03667     GCC_UserData m_userData;
    03668
    03669     PINDEX GetDataLength() const;
    03670     PBoolean Decode(PASN_Stream & strm);
    03671     void Encode(PASN_Stream & strm) const;
    03672 #ifndef PASN_NOPRINTON
    03673     void PrintOn(ostream & strm) const;
    03674 #endif
    03675     Comparison Compare(const PObject & obj) const;
    03676     PObject * Clone() const;
    03677 };
    03678
    03679
    03680 //
    03681 // ApplicationRecord
    03682 //
    03683
    03684 class GCC_ApplicationRecord : public PASN_Sequence
    03685 {
    03686 #ifndef PASN_LEANANDMEAN
    03687     PCLASSINFO(GCC_ApplicationRecord, PASN_Sequence);
    03688 #endif
    03689   public:
    03690     GCC_ApplicationRecord(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03691
    03692     enum OptionalFields {
    03693       e_startupChannel,
    03694       e_applicationUserID,
    03695       e_nonCollapsingCapabilities
    03696     };
    03697
    03698     PASN_Boolean m_applicationActive;
    03699     PASN_Boolean m_conductingOperationCapable;
    03700     GCC_ChannelType m_startupChannel;
    03701     GCC_UserID m_applicationUserID;
    03702     GCC_ApplicationRecord_nonCollapsingCapabilities m_nonCollapsingCapabilities;
    03703
    03704     PINDEX GetDataLength() const;
    03705     PBoolean Decode(PASN_Stream & strm);
    03706     void Encode(PASN_Stream & strm) const;
    03707 #ifndef PASN_NOPRINTON
    03708     void PrintOn(ostream & strm) const;
    03709 #endif
    03710     Comparison Compare(const PObject & obj) const;
    03711     PObject * Clone() const;
    03712 };
    03713
    03714
    03715 //
    03716 // ApplicationInvokeSpecifier
    03717 //
    03718
    03719 class GCC_ApplicationInvokeSpecifier : public PASN_Sequence
    03720 {
    03721 #ifndef PASN_LEANANDMEAN
    03722     PCLASSINFO(GCC_ApplicationInvokeSpecifier, PASN_Sequence);
    03723 #endif
    03724   public:
    03725     GCC_ApplicationInvokeSpecifier(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03726
    03727     enum OptionalFields {
    03728       e_expectedCapabilitySet,
    03729       e_startupChannel
    03730     };
    03731
    03732     GCC_SessionKey m_sessionKey;
    03733     GCC_ApplicationInvokeSpecifier_expectedCapabilitySet m_expectedCapabilitySet;
    03734     GCC_ChannelType m_startupChannel;
    03735     PASN_Boolean m_mandatoryFlag;
    03736
    03737     PINDEX GetDataLength() const;
    03738     PBoolean Decode(PASN_Stream & strm);
    03739     void Encode(PASN_Stream & strm) const;
    03740 #ifndef PASN_NOPRINTON
    03741     void PrintOn(ostream & strm) const;
    03742 #endif
    03743     Comparison Compare(const PObject & obj) const;
    03744     PObject * Clone() const;
    03745 };
    03746
    03747
    03748 //
    03749 // ConferenceCreateRequest
    03750 //
    03751
    03752 class GCC_ConferenceCreateRequest : public PASN_Sequence
    03753 {
    03754 #ifndef PASN_LEANANDMEAN
    03755     PCLASSINFO(GCC_ConferenceCreateRequest, PASN_Sequence);
    03756 #endif
    03757   public:
    03758     GCC_ConferenceCreateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03759
    03760     enum OptionalFields {
    03761       e_convenerPassword,
    03762       e_password,
    03763       e_conductorPrivileges,
    03764       e_conductedPrivileges,
    03765       e_nonConductedPrivileges,
    03766       e_conferenceDescription,
    03767       e_callerIdentifier,
    03768       e_userData,
    03769       e_conferencePriority
    03770     };
    03771
    03772     GCC_ConferenceName m_conferenceName;
    03773     GCC_Password m_convenerPassword;
    03774     GCC_Password m_password;
    03775     PASN_Boolean m_lockedConference;
    03776     PASN_Boolean m_listedConference;
    03777     PASN_Boolean m_conductibleConference;
    03778     GCC_TerminationMethod m_terminationMethod;
    03779     GCC_ArrayOf_Privilege m_conductorPrivileges;
    03780     GCC_ArrayOf_Privilege m_conductedPrivileges;
    03781     GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    03782     GCC_TextString m_conferenceDescription;
    03783     GCC_TextString m_callerIdentifier;
    03784     GCC_UserData m_userData;
    03785     GCC_ConferencePriority m_conferencePriority;
    03786
    03787     PINDEX GetDataLength() const;
    03788     PBoolean Decode(PASN_Stream & strm);
    03789     void Encode(PASN_Stream & strm) const;
    03790 #ifndef PASN_NOPRINTON
    03791     void PrintOn(ostream & strm) const;
    03792 #endif
    03793     Comparison Compare(const PObject & obj) const;
    03794     PObject * Clone() const;
    03795 };
    03796
    03797
    03798 //
    03799 // ConferenceCreateResponse
    03800 //
    03801
    03802 class GCC_ConferenceCreateResponse : public PASN_Sequence
    03803 {
    03804 #ifndef PASN_LEANANDMEAN
    03805     PCLASSINFO(GCC_ConferenceCreateResponse, PASN_Sequence);
    03806 #endif
    03807   public:
    03808     GCC_ConferenceCreateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03809
    03810     enum OptionalFields {
    03811       e_userData
    03812     };
    03813
    03814     GCC_UserID m_nodeID;
    03815     PASN_Integer m_tag;
    03816     GCC_ConferenceCreateResponse_result m_result;
    03817     GCC_UserData m_userData;
    03818
    03819     PINDEX GetDataLength() const;
    03820     PBoolean Decode(PASN_Stream & strm);
    03821     void Encode(PASN_Stream & strm) const;
    03822 #ifndef PASN_NOPRINTON
    03823     void PrintOn(ostream & strm) const;
    03824 #endif
    03825     Comparison Compare(const PObject & obj) const;
    03826     PObject * Clone() const;
    03827 };
    03828
    03829
    03830 //
    03831 // ConferenceQueryResponse
    03832 //
    03833
    03834 class GCC_ConferenceQueryResponse : public PASN_Sequence
    03835 {
    03836 #ifndef PASN_LEANANDMEAN
    03837     PCLASSINFO(GCC_ConferenceQueryResponse, PASN_Sequence);
    03838 #endif
    03839   public:
    03840     GCC_ConferenceQueryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03841
    03842     enum OptionalFields {
    03843       e_asymmetryIndicator,
    03844       e_userData,
    03845       e_waitForInvitationFlag,
    03846       e_noUnlistedConferenceFlag
    03847     };
    03848
    03849     GCC_NodeType m_nodeType;
    03850     GCC_AsymmetryIndicator m_asymmetryIndicator;
    03851     GCC_ArrayOf_ConferenceDescriptor m_conferenceList;
    03852     GCC_ConferenceQueryResponse_result m_result;
    03853     GCC_UserData m_userData;
    03854     PASN_Boolean m_waitForInvitationFlag;
    03855     PASN_Boolean m_noUnlistedConferenceFlag;
    03856
    03857     PINDEX GetDataLength() const;
    03858     PBoolean Decode(PASN_Stream & strm);
    03859     void Encode(PASN_Stream & strm) const;
    03860 #ifndef PASN_NOPRINTON
    03861     void PrintOn(ostream & strm) const;
    03862 #endif
    03863     Comparison Compare(const PObject & obj) const;
    03864     PObject * Clone() const;
    03865 };
    03866
    03867
    03868 //
    03869 // ConferenceJoinResponse
    03870 //
    03871
    03872 class GCC_ConferenceJoinResponse : public PASN_Sequence
    03873 {
    03874 #ifndef PASN_LEANANDMEAN
    03875     PCLASSINFO(GCC_ConferenceJoinResponse, PASN_Sequence);
    03876 #endif
    03877   public:
    03878     GCC_ConferenceJoinResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03879
    03880     enum OptionalFields {
    03881       e_nodeID,
    03882       e_conferenceNameAlias,
    03883       e_conductorPrivileges,
    03884       e_conductedPrivileges,
    03885       e_nonConductedPrivileges,
    03886       e_conferenceDescription,
    03887       e_password,
    03888       e_userData
    03889     };
    03890
    03891     GCC_UserID m_nodeID;
    03892     GCC_UserID m_topNodeID;
    03893     PASN_Integer m_tag;
    03894     GCC_ConferenceNameSelector m_conferenceNameAlias;
    03895     PASN_Boolean m_passwordInTheClearRequired;
    03896     PASN_Boolean m_lockedConference;
    03897     PASN_Boolean m_listedConference;
    03898     PASN_Boolean m_conductibleConference;
    03899     GCC_TerminationMethod m_terminationMethod;
    03900     GCC_ArrayOf_Privilege m_conductorPrivileges;
    03901     GCC_ArrayOf_Privilege m_conductedPrivileges;
    03902     GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    03903     GCC_TextString m_conferenceDescription;
    03904     GCC_PasswordChallengeRequestResponse m_password;
    03905     GCC_ConferenceJoinResponse_result m_result;
    03906     GCC_UserData m_userData;
    03907
    03908     PINDEX GetDataLength() const;
    03909     PBoolean Decode(PASN_Stream & strm);
    03910     void Encode(PASN_Stream & strm) const;
    03911 #ifndef PASN_NOPRINTON
    03912     void PrintOn(ostream & strm) const;
    03913 #endif
    03914     Comparison Compare(const PObject & obj) const;
    03915     PObject * Clone() const;
    03916 };
    03917
    03918
    03919 //
    03920 // ConferenceInviteRequest
    03921 //
    03922
    03923 class GCC_ConferenceInviteRequest : public PASN_Sequence
    03924 {
    03925 #ifndef PASN_LEANANDMEAN
    03926     PCLASSINFO(GCC_ConferenceInviteRequest, PASN_Sequence);
    03927 #endif
    03928   public:
    03929     GCC_ConferenceInviteRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03930
    03931     enum OptionalFields {
    03932       e_conductorPrivileges,
    03933       e_conductedPrivileges,
    03934       e_nonConductedPrivileges,
    03935       e_conferenceDescription,
    03936       e_callerIdentifier,
    03937       e_userData,
    03938       e_conferencePriority
    03939     };
    03940
    03941     GCC_ConferenceName m_conferenceName;
    03942     GCC_UserID m_nodeID;
    03943     GCC_UserID m_topNodeID;
    03944     PASN_Integer m_tag;
    03945     PASN_Boolean m_passwordInTheClearRequired;
    03946     PASN_Boolean m_lockedConference;
    03947     PASN_Boolean m_listedConference;
    03948     PASN_Boolean m_conductibleConference;
    03949     GCC_TerminationMethod m_terminationMethod;
    03950     GCC_ArrayOf_Privilege m_conductorPrivileges;
    03951     GCC_ArrayOf_Privilege m_conductedPrivileges;
    03952     GCC_ArrayOf_Privilege m_nonConductedPrivileges;
    03953     GCC_TextString m_conferenceDescription;
    03954     GCC_TextString m_callerIdentifier;
    03955     GCC_UserData m_userData;
    03956     GCC_ConferencePriority m_conferencePriority;
    03957
    03958     PINDEX GetDataLength() const;
    03959     PBoolean Decode(PASN_Stream & strm);
    03960     void Encode(PASN_Stream & strm) const;
    03961 #ifndef PASN_NOPRINTON
    03962     void PrintOn(ostream & strm) const;
    03963 #endif
    03964     Comparison Compare(const PObject & obj) const;
    03965     PObject * Clone() const;
    03966 };
    03967
    03968
    03969 //
    03970 // ConferenceInviteResponse
    03971 //
    03972
    03973 class GCC_ConferenceInviteResponse : public PASN_Sequence
    03974 {
    03975 #ifndef PASN_LEANANDMEAN
    03976     PCLASSINFO(GCC_ConferenceInviteResponse, PASN_Sequence);
    03977 #endif
    03978   public:
    03979     GCC_ConferenceInviteResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    03980
    03981     enum OptionalFields {
    03982       e_userData
    03983     };
    03984
    03985     GCC_ConferenceInviteResponse_result m_result;
    03986     GCC_UserData m_userData;
    03987
    03988     PINDEX GetDataLength() const;
    03989     PBoolean Decode(PASN_Stream & strm);
    03990     void Encode(PASN_Stream & strm) const;
    03991 #ifndef PASN_NOPRINTON
    03992     void PrintOn(ostream & strm) const;
    03993 #endif
    03994     Comparison Compare(const PObject & obj) const;
    03995     PObject * Clone() const;
    03996 };
    03997
    03998
    03999 //
    04000 // ConferenceAddResponse
    04001 //
    04002
    04003 class GCC_ConferenceAddResponse : public PASN_Sequence
    04004 {
    04005 #ifndef PASN_LEANANDMEAN
    04006     PCLASSINFO(GCC_ConferenceAddResponse, PASN_Sequence);
    04007 #endif
    04008   public:
    04009     GCC_ConferenceAddResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04010
    04011     enum OptionalFields {
    04012       e_userData
    04013     };
    04014
    04015     PASN_Integer m_tag;
    04016     GCC_ConferenceAddResponse_result m_result;
    04017     GCC_UserData m_userData;
    04018
    04019     PINDEX GetDataLength() const;
    04020     PBoolean Decode(PASN_Stream & strm);
    04021     void Encode(PASN_Stream & strm) const;
    04022 #ifndef PASN_NOPRINTON
    04023     void PrintOn(ostream & strm) const;
    04024 #endif
    04025     Comparison Compare(const PObject & obj) const;
    04026     PObject * Clone() const;
    04027 };
    04028
    04029
    04030 //
    04031 // ConferenceLockResponse
    04032 //
    04033
    04034 class GCC_ConferenceLockResponse : public PASN_Sequence
    04035 {
    04036 #ifndef PASN_LEANANDMEAN
    04037     PCLASSINFO(GCC_ConferenceLockResponse, PASN_Sequence);
    04038 #endif
    04039   public:
    04040     GCC_ConferenceLockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04041
    04042     GCC_ConferenceLockResponse_result m_result;
    04043
    04044     PINDEX GetDataLength() const;
    04045     PBoolean Decode(PASN_Stream & strm);
    04046     void Encode(PASN_Stream & strm) const;
    04047 #ifndef PASN_NOPRINTON
    04048     void PrintOn(ostream & strm) const;
    04049 #endif
    04050     Comparison Compare(const PObject & obj) const;
    04051     PObject * Clone() const;
    04052 };
    04053
    04054
    04055 //
    04056 // ConferenceUnlockResponse
    04057 //
    04058
    04059 class GCC_ConferenceUnlockResponse : public PASN_Sequence
    04060 {
    04061 #ifndef PASN_LEANANDMEAN
    04062     PCLASSINFO(GCC_ConferenceUnlockResponse, PASN_Sequence);
    04063 #endif
    04064   public:
    04065     GCC_ConferenceUnlockResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04066
    04067     GCC_ConferenceUnlockResponse_result m_result;
    04068
    04069     PINDEX GetDataLength() const;
    04070     PBoolean Decode(PASN_Stream & strm);
    04071     void Encode(PASN_Stream & strm) const;
    04072 #ifndef PASN_NOPRINTON
    04073     void PrintOn(ostream & strm) const;
    04074 #endif
    04075     Comparison Compare(const PObject & obj) const;
    04076     PObject * Clone() const;
    04077 };
    04078
    04079
    04080 //
    04081 // ConferenceTerminateRequest
    04082 //
    04083
    04084 class GCC_ConferenceTerminateRequest : public PASN_Sequence
    04085 {
    04086 #ifndef PASN_LEANANDMEAN
    04087     PCLASSINFO(GCC_ConferenceTerminateRequest, PASN_Sequence);
    04088 #endif
    04089   public:
    04090     GCC_ConferenceTerminateRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04091
    04092     GCC_ConferenceTerminateRequest_reason m_reason;
    04093
    04094     PINDEX GetDataLength() const;
    04095     PBoolean Decode(PASN_Stream & strm);
    04096     void Encode(PASN_Stream & strm) const;
    04097 #ifndef PASN_NOPRINTON
    04098     void PrintOn(ostream & strm) const;
    04099 #endif
    04100     Comparison Compare(const PObject & obj) const;
    04101     PObject * Clone() const;
    04102 };
    04103
    04104
    04105 //
    04106 // ConferenceTerminateResponse
    04107 //
    04108
    04109 class GCC_ConferenceTerminateResponse : public PASN_Sequence
    04110 {
    04111 #ifndef PASN_LEANANDMEAN
    04112     PCLASSINFO(GCC_ConferenceTerminateResponse, PASN_Sequence);
    04113 #endif
    04114   public:
    04115     GCC_ConferenceTerminateResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04116
    04117     GCC_ConferenceTerminateResponse_result m_result;
    04118
    04119     PINDEX GetDataLength() const;
    04120     PBoolean Decode(PASN_Stream & strm);
    04121     void Encode(PASN_Stream & strm) const;
    04122 #ifndef PASN_NOPRINTON
    04123     void PrintOn(ostream & strm) const;
    04124 #endif
    04125     Comparison Compare(const PObject & obj) const;
    04126     PObject * Clone() const;
    04127 };
    04128
    04129
    04130 //
    04131 // ConferenceTerminateIndication
    04132 //
    04133
    04134 class GCC_ConferenceTerminateIndication : public PASN_Sequence
    04135 {
    04136 #ifndef PASN_LEANANDMEAN
    04137     PCLASSINFO(GCC_ConferenceTerminateIndication, PASN_Sequence);
    04138 #endif
    04139   public:
    04140     GCC_ConferenceTerminateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04141
    04142     GCC_ConferenceTerminateIndication_reason m_reason;
    04143
    04144     PINDEX GetDataLength() const;
    04145     PBoolean Decode(PASN_Stream & strm);
    04146     void Encode(PASN_Stream & strm) const;
    04147 #ifndef PASN_NOPRINTON
    04148     void PrintOn(ostream & strm) const;
    04149 #endif
    04150     Comparison Compare(const PObject & obj) const;
    04151     PObject * Clone() const;
    04152 };
    04153
    04154
    04155 //
    04156 // ConferenceEjectUserRequest
    04157 //
    04158
    04159 class GCC_ConferenceEjectUserRequest : public PASN_Sequence
    04160 {
    04161 #ifndef PASN_LEANANDMEAN
    04162     PCLASSINFO(GCC_ConferenceEjectUserRequest, PASN_Sequence);
    04163 #endif
    04164   public:
    04165     GCC_ConferenceEjectUserRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04166
    04167     GCC_UserID m_nodeToEject;
    04168     GCC_ConferenceEjectUserRequest_reason m_reason;
    04169
    04170     PINDEX GetDataLength() const;
    04171     PBoolean Decode(PASN_Stream & strm);
    04172     void Encode(PASN_Stream & strm) const;
    04173 #ifndef PASN_NOPRINTON
    04174     void PrintOn(ostream & strm) const;
    04175 #endif
    04176     Comparison Compare(const PObject & obj) const;
    04177     PObject * Clone() const;
    04178 };
    04179
    04180
    04181 //
    04182 // ConferenceEjectUserResponse
    04183 //
    04184
    04185 class GCC_ConferenceEjectUserResponse : public PASN_Sequence
    04186 {
    04187 #ifndef PASN_LEANANDMEAN
    04188     PCLASSINFO(GCC_ConferenceEjectUserResponse, PASN_Sequence);
    04189 #endif
    04190   public:
    04191     GCC_ConferenceEjectUserResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04192
    04193     GCC_UserID m_nodeToEject;
    04194     GCC_ConferenceEjectUserResponse_result m_result;
    04195
    04196     PINDEX GetDataLength() const;
    04197     PBoolean Decode(PASN_Stream & strm);
    04198     void Encode(PASN_Stream & strm) const;
    04199 #ifndef PASN_NOPRINTON
    04200     void PrintOn(ostream & strm) const;
    04201 #endif
    04202     Comparison Compare(const PObject & obj) const;
    04203     PObject * Clone() const;
    04204 };
    04205
    04206
    04207 //
    04208 // ConferenceEjectUserIndication
    04209 //
    04210
    04211 class GCC_ConferenceEjectUserIndication : public PASN_Sequence
    04212 {
    04213 #ifndef PASN_LEANANDMEAN
    04214     PCLASSINFO(GCC_ConferenceEjectUserIndication, PASN_Sequence);
    04215 #endif
    04216   public:
    04217     GCC_ConferenceEjectUserIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04218
    04219     GCC_UserID m_nodeToEject;
    04220     GCC_ConferenceEjectUserIndication_reason m_reason;
    04221
    04222     PINDEX GetDataLength() const;
    04223     PBoolean Decode(PASN_Stream & strm);
    04224     void Encode(PASN_Stream & strm) const;
    04225 #ifndef PASN_NOPRINTON
    04226     void PrintOn(ostream & strm) const;
    04227 #endif
    04228     Comparison Compare(const PObject & obj) const;
    04229     PObject * Clone() const;
    04230 };
    04231
    04232
    04233 //
    04234 // ConferenceTransferRequest
    04235 //
    04236
    04237 class GCC_ConferenceTransferRequest : public PASN_Sequence
    04238 {
    04239 #ifndef PASN_LEANANDMEAN
    04240     PCLASSINFO(GCC_ConferenceTransferRequest, PASN_Sequence);
    04241 #endif
    04242   public:
    04243     GCC_ConferenceTransferRequest(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04244
    04245     enum OptionalFields {
    04246       e_conferenceNameModifier,
    04247       e_networkAddress,
    04248       e_transferringNodes,
    04249       e_password
    04250     };
    04251
    04252     GCC_ConferenceNameSelector m_conferenceName;
    04253     GCC_ConferenceNameModifier m_conferenceNameModifier;
    04254     GCC_NetworkAddress m_networkAddress;
    04255     GCC_ArrayOf_UserID m_transferringNodes;
    04256     GCC_PasswordSelector m_password;
    04257
    04258     PINDEX GetDataLength() const;
    04259     PBoolean Decode(PASN_Stream & strm);
    04260     void Encode(PASN_Stream & strm) const;
    04261 #ifndef PASN_NOPRINTON
    04262     void PrintOn(ostream & strm) const;
    04263 #endif
    04264     Comparison Compare(const PObject & obj) const;
    04265     PObject * Clone() const;
    04266 };
    04267
    04268
    04269 //
    04270 // ConferenceTransferResponse
    04271 //
    04272
    04273 class GCC_ConferenceTransferResponse : public PASN_Sequence
    04274 {
    04275 #ifndef PASN_LEANANDMEAN
    04276     PCLASSINFO(GCC_ConferenceTransferResponse, PASN_Sequence);
    04277 #endif
    04278   public:
    04279     GCC_ConferenceTransferResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04280
    04281     enum OptionalFields {
    04282       e_conferenceNameModifier,
    04283       e_transferringNodes
    04284     };
    04285
    04286     GCC_ConferenceNameSelector m_conferenceName;
    04287     GCC_ConferenceNameModifier m_conferenceNameModifier;
    04288     GCC_ArrayOf_UserID m_transferringNodes;
    04289     GCC_ConferenceTransferResponse_result m_result;
    04290
    04291     PINDEX GetDataLength() const;
    04292     PBoolean Decode(PASN_Stream & strm);
    04293     void Encode(PASN_Stream & strm) const;
    04294 #ifndef PASN_NOPRINTON
    04295     void PrintOn(ostream & strm) const;
    04296 #endif
    04297     Comparison Compare(const PObject & obj) const;
    04298     PObject * Clone() const;
    04299 };
    04300
    04301
    04302 //
    04303 // ConferenceTransferIndication
    04304 //
    04305
    04306 class GCC_ConferenceTransferIndication : public PASN_Sequence
    04307 {
    04308 #ifndef PASN_LEANANDMEAN
    04309     PCLASSINFO(GCC_ConferenceTransferIndication, PASN_Sequence);
    04310 #endif
    04311   public:
    04312     GCC_ConferenceTransferIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04313
    04314     enum OptionalFields {
    04315       e_conferenceNameModifier,
    04316       e_networkAddress,
    04317       e_transferringNodes,
    04318       e_password
    04319     };
    04320
    04321     GCC_ConferenceNameSelector m_conferenceName;
    04322     GCC_ConferenceNameModifier m_conferenceNameModifier;
    04323     GCC_NetworkAddress m_networkAddress;
    04324     GCC_ArrayOf_UserID m_transferringNodes;
    04325     GCC_PasswordSelector m_password;
    04326
    04327     PINDEX GetDataLength() const;
    04328     PBoolean Decode(PASN_Stream & strm);
    04329     void Encode(PASN_Stream & strm) const;
    04330 #ifndef PASN_NOPRINTON
    04331     void PrintOn(ostream & strm) const;
    04332 #endif
    04333     Comparison Compare(const PObject & obj) const;
    04334     PObject * Clone() const;
    04335 };
    04336
    04337
    04338 //
    04339 // ApplicationInvokeIndication
    04340 //
    04341
    04342 class GCC_ApplicationInvokeIndication : public PASN_Sequence
    04343 {
    04344 #ifndef PASN_LEANANDMEAN
    04345     PCLASSINFO(GCC_ApplicationInvokeIndication, PASN_Sequence);
    04346 #endif
    04347   public:
    04348     GCC_ApplicationInvokeIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04349
    04350     enum OptionalFields {
    04351       e_destinationNodes
    04352     };
    04353
    04354     GCC_ArrayOf_ApplicationInvokeSpecifier m_applicationProtocolEntiyList;
    04355     GCC_ArrayOf_UserID m_destinationNodes;
    04356
    04357     PINDEX GetDataLength() const;
    04358     PBoolean Decode(PASN_Stream & strm);
    04359     void Encode(PASN_Stream & strm) const;
    04360 #ifndef PASN_NOPRINTON
    04361     void PrintOn(ostream & strm) const;
    04362 #endif
    04363     Comparison Compare(const PObject & obj) const;
    04364     PObject * Clone() const;
    04365 };
    04366
    04367
    04368 //
    04369 // RegistryAllocateHandleResponse
    04370 //
    04371
    04372 class GCC_RegistryAllocateHandleResponse : public PASN_Sequence
    04373 {
    04374 #ifndef PASN_LEANANDMEAN
    04375     PCLASSINFO(GCC_RegistryAllocateHandleResponse, PASN_Sequence);
    04376 #endif
    04377   public:
    04378     GCC_RegistryAllocateHandleResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04379
    04380     GCC_EntityID m_entityID;
    04381     PASN_Integer m_numberOfHandles;
    04382     GCC_Handle m_firstHandle;
    04383     GCC_RegistryAllocateHandleResponse_result m_result;
    04384
    04385     PINDEX GetDataLength() const;
    04386     PBoolean Decode(PASN_Stream & strm);
    04387     void Encode(PASN_Stream & strm) const;
    04388 #ifndef PASN_NOPRINTON
    04389     void PrintOn(ostream & strm) const;
    04390 #endif
    04391     Comparison Compare(const PObject & obj) const;
    04392     PObject * Clone() const;
    04393 };
    04394
    04395
    04396 //
    04397 // RegistryResponse
    04398 //
    04399
    04400 class GCC_RegistryResponse : public PASN_Sequence
    04401 {
    04402 #ifndef PASN_LEANANDMEAN
    04403     PCLASSINFO(GCC_RegistryResponse, PASN_Sequence);
    04404 #endif
    04405   public:
    04406     GCC_RegistryResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04407
    04408     enum OptionalFields {
    04409       e_modificationRights
    04410     };
    04411
    04412     GCC_EntityID m_entityID;
    04413     GCC_RegistryResponse_primitiveType m_primitiveType;
    04414     GCC_RegistryKey m_key;
    04415     GCC_RegistryItem m_item;
    04416     GCC_RegistryEntryOwner m_owner;
    04417     GCC_RegistryModificationRights m_modificationRights;
    04418     GCC_RegistryResponse_result m_result;
    04419
    04420     PINDEX GetDataLength() const;
    04421     PBoolean Decode(PASN_Stream & strm);
    04422     void Encode(PASN_Stream & strm) const;
    04423 #ifndef PASN_NOPRINTON
    04424     void PrintOn(ostream & strm) const;
    04425 #endif
    04426     Comparison Compare(const PObject & obj) const;
    04427     PObject * Clone() const;
    04428 };
    04429
    04430
    04431 //
    04432 // ConductorPermissionGrantIndication
    04433 //
    04434
    04435 class GCC_ConductorPermissionGrantIndication : public PASN_Sequence
    04436 {
    04437 #ifndef PASN_LEANANDMEAN
    04438     PCLASSINFO(GCC_ConductorPermissionGrantIndication, PASN_Sequence);
    04439 #endif
    04440   public:
    04441     GCC_ConductorPermissionGrantIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04442
    04443     enum OptionalFields {
    04444       e_waitingList
    04445     };
    04446
    04447     GCC_ArrayOf_UserID m_permissionList;
    04448     GCC_ArrayOf_UserID m_waitingList;
    04449
    04450     PINDEX GetDataLength() const;
    04451     PBoolean Decode(PASN_Stream & strm);
    04452     void Encode(PASN_Stream & strm) const;
    04453 #ifndef PASN_NOPRINTON
    04454     void PrintOn(ostream & strm) const;
    04455 #endif
    04456     Comparison Compare(const PObject & obj) const;
    04457     PObject * Clone() const;
    04458 };
    04459
    04460
    04461 //
    04462 // FunctionNotSupportedResponse
    04463 //
    04464
    04465 class GCC_FunctionNotSupportedResponse : public PASN_Sequence
    04466 {
    04467 #ifndef PASN_LEANANDMEAN
    04468     PCLASSINFO(GCC_FunctionNotSupportedResponse, PASN_Sequence);
    04469 #endif
    04470   public:
    04471     GCC_FunctionNotSupportedResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04472
    04473     GCC_RequestPDU m_request;
    04474
    04475     PINDEX GetDataLength() const;
    04476     PBoolean Decode(PASN_Stream & strm);
    04477     void Encode(PASN_Stream & strm) const;
    04478 #ifndef PASN_NOPRINTON
    04479     void PrintOn(ostream & strm) const;
    04480 #endif
    04481     Comparison Compare(const PObject & obj) const;
    04482     PObject * Clone() const;
    04483 };
    04484
    04485
    04486 //
    04487 // PasswordChallengeRequestResponse_challengeRequestResponse
    04488 //
    04489
    04490 class GCC_PasswordChallengeRequestResponse_challengeRequestResponse : public PASN_Sequence
    04491 {
    04492 #ifndef PASN_LEANANDMEAN
    04493     PCLASSINFO(GCC_PasswordChallengeRequestResponse_challengeRequestResponse, PASN_Sequence);
    04494 #endif
    04495   public:
    04496     GCC_PasswordChallengeRequestResponse_challengeRequestResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04497
    04498     enum OptionalFields {
    04499       e_challengeRequest,
    04500       e_challengeResponse
    04501     };
    04502
    04503     GCC_ChallengeRequest m_challengeRequest;
    04504     GCC_ChallengeResponse m_challengeResponse;
    04505
    04506     PINDEX GetDataLength() const;
    04507     PBoolean Decode(PASN_Stream & strm);
    04508     void Encode(PASN_Stream & strm) const;
    04509 #ifndef PASN_NOPRINTON
    04510     void PrintOn(ostream & strm) const;
    04511 #endif
    04512     Comparison Compare(const PObject & obj) const;
    04513     PObject * Clone() const;
    04514 };
    04515
    04516
    04517 //
    04518 // RosterUpdateIndication_nodeInformation
    04519 //
    04520
    04521 class GCC_RosterUpdateIndication_nodeInformation : public PASN_Sequence
    04522 {
    04523 #ifndef PASN_LEANANDMEAN
    04524     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation, PASN_Sequence);
    04525 #endif
    04526   public:
    04527     GCC_RosterUpdateIndication_nodeInformation(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04528
    04529     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList m_nodeRecordList;
    04530     PASN_Integer m_rosterInstanceNumber;
    04531     PASN_Boolean m_nodesAdded;
    04532     PASN_Boolean m_nodesRemoved;
    04533
    04534     PINDEX GetDataLength() const;
    04535     PBoolean Decode(PASN_Stream & strm);
    04536     void Encode(PASN_Stream & strm) const;
    04537 #ifndef PASN_NOPRINTON
    04538     void PrintOn(ostream & strm) const;
    04539 #endif
    04540     Comparison Compare(const PObject & obj) const;
    04541     PObject * Clone() const;
    04542 };
    04543
    04544
    04545 //
    04546 // NetworkAddress_subtype_aggregatedChannel
    04547 //
    04548
    04549 class GCC_NetworkAddress_subtype_aggregatedChannel : public PASN_Sequence
    04550 {
    04551 #ifndef PASN_LEANANDMEAN
    04552     PCLASSINFO(GCC_NetworkAddress_subtype_aggregatedChannel, PASN_Sequence);
    04553 #endif
    04554   public:
    04555     GCC_NetworkAddress_subtype_aggregatedChannel(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04556
    04557     enum OptionalFields {
    04558       e_subAddress,
    04559       e_extraDialing,
    04560       e_highLayerCompatibility
    04561     };
    04562
    04563     GCC_NetworkAddress_subtype_aggregatedChannel_transferModes m_transferModes;
    04564     GCC_DialingString m_internationalNumber;
    04565     GCC_SubAddressString m_subAddress;
    04566     GCC_ExtraDialingString m_extraDialing;
    04567     GCC_NetworkAddress_subtype_aggregatedChannel_highLayerCompatibility m_highLayerCompatibility;
    04568
    04569     PINDEX GetDataLength() const;
    04570     PBoolean Decode(PASN_Stream & strm);
    04571     void Encode(PASN_Stream & strm) const;
    04572 #ifndef PASN_NOPRINTON
    04573     void PrintOn(ostream & strm) const;
    04574 #endif
    04575     Comparison Compare(const PObject & obj) const;
    04576     PObject * Clone() const;
    04577 };
    04578
    04579
    04580 //
    04581 // RosterUpdateIndication_applicationInformation_subtype
    04582 //
    04583
    04584 class GCC_RosterUpdateIndication_applicationInformation_subtype : public PASN_Sequence
    04585 {
    04586 #ifndef PASN_LEANANDMEAN
    04587     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype, PASN_Sequence);
    04588 #endif
    04589   public:
    04590     GCC_RosterUpdateIndication_applicationInformation_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04591
    04592     GCC_SessionKey m_sessionKey;
    04593     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList m_applicationRecordList;
    04594     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationCapabilitiesList m_applicationCapabilitiesList;
    04595     PASN_Integer m_rosterInstanceNumber;
    04596     PASN_Boolean m_peerEntitiesAdded;
    04597     PASN_Boolean m_peerEntitiesRemoved;
    04598
    04599     PINDEX GetDataLength() const;
    04600     PBoolean Decode(PASN_Stream & strm);
    04601     void Encode(PASN_Stream & strm) const;
    04602 #ifndef PASN_NOPRINTON
    04603     void PrintOn(ostream & strm) const;
    04604 #endif
    04605     Comparison Compare(const PObject & obj) const;
    04606     PObject * Clone() const;
    04607 };
    04608
    04609
    04610 //
    04611 // RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype
    04612 //
    04613
    04614 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype : public PASN_Sequence
    04615 {
    04616 #ifndef PASN_LEANANDMEAN
    04617     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype, PASN_Sequence);
    04618 #endif
    04619   public:
    04620     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04621
    04622     GCC_UserID m_nodeID;
    04623     GCC_NodeRecord m_nodeRecord;
    04624
    04625     PINDEX GetDataLength() const;
    04626     PBoolean Decode(PASN_Stream & strm);
    04627     void Encode(PASN_Stream & strm) const;
    04628 #ifndef PASN_NOPRINTON
    04629     void PrintOn(ostream & strm) const;
    04630 #endif
    04631     Comparison Compare(const PObject & obj) const;
    04632     PObject * Clone() const;
    04633 };
    04634
    04635
    04636 //
    04637 // RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype
    04638 //
    04639
    04640 class GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype : public PASN_Sequence
    04641 {
    04642 #ifndef PASN_LEANANDMEAN
    04643     PCLASSINFO(GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype, PASN_Sequence);
    04644 #endif
    04645   public:
    04646     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04647
    04648     GCC_UserID m_nodeID;
    04649     GCC_RosterUpdateIndication_nodeInformation_nodeRecordList_update_subtype_nodeUpdate m_nodeUpdate;
    04650
    04651     PINDEX GetDataLength() const;
    04652     PBoolean Decode(PASN_Stream & strm);
    04653     void Encode(PASN_Stream & strm) const;
    04654 #ifndef PASN_NOPRINTON
    04655     void PrintOn(ostream & strm) const;
    04656 #endif
    04657     Comparison Compare(const PObject & obj) const;
    04658     PObject * Clone() const;
    04659 };
    04660
    04661
    04662 //
    04663 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype
    04664 //
    04665
    04666 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype : public PASN_Sequence
    04667 {
    04668 #ifndef PASN_LEANANDMEAN
    04669     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype, PASN_Sequence);
    04670 #endif
    04671   public:
    04672     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_refresh_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04673
    04674     GCC_UserID m_nodeID;
    04675     GCC_EntityID m_entityID;
    04676     GCC_ApplicationRecord m_applicationRecord;
    04677
    04678     PINDEX GetDataLength() const;
    04679     PBoolean Decode(PASN_Stream & strm);
    04680     void Encode(PASN_Stream & strm) const;
    04681 #ifndef PASN_NOPRINTON
    04682     void PrintOn(ostream & strm) const;
    04683 #endif
    04684     Comparison Compare(const PObject & obj) const;
    04685     PObject * Clone() const;
    04686 };
    04687
    04688
    04689 //
    04690 // RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype
    04691 //
    04692
    04693 class GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype : public PASN_Sequence
    04694 {
    04695 #ifndef PASN_LEANANDMEAN
    04696     PCLASSINFO(GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype, PASN_Sequence);
    04697 #endif
    04698   public:
    04699     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04700
    04701     GCC_UserID m_nodeID;
    04702     GCC_EntityID m_entityID;
    04703     GCC_RosterUpdateIndication_applicationInformation_subtype_applicationRecordList_update_subtype_applicationUpdate m_applicationUpdate;
    04704
    04705     PINDEX GetDataLength() const;
    04706     PBoolean Decode(PASN_Stream & strm);
    04707     void Encode(PASN_Stream & strm) const;
    04708 #ifndef PASN_NOPRINTON
    04709     void PrintOn(ostream & strm) const;
    04710 #endif
    04711     Comparison Compare(const PObject & obj) const;
    04712     PObject * Clone() const;
    04713 };
    04714
    04715
    04716 //
    04717 // RosterUpdateIndication
    04718 //
    04719
    04720 class GCC_RosterUpdateIndication : public PASN_Sequence
    04721 {
    04722 #ifndef PASN_LEANANDMEAN
    04723     PCLASSINFO(GCC_RosterUpdateIndication, PASN_Sequence);
    04724 #endif
    04725   public:
    04726     GCC_RosterUpdateIndication(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);
    04727
    04728     PASN_Boolean m_fullRefresh;
    04729     GCC_RosterUpdateIndication_nodeInformation m_nodeInformation;
    04730     GCC_RosterUpdateIndication_applicationInformation m_applicationInformation;
    04731
    04732     PINDEX GetDataLength() const;
    04733     PBoolean Decode(PASN_Stream & strm);
    04734     void Encode(PASN_Stream & strm) const;
    04735 #ifndef PASN_NOPRINTON
    04736     void PrintOn(ostream & strm) const;
    04737 #endif
    04738     Comparison Compare(const PObject & obj) const;
    04739     PObject * Clone() const;
    04740 };
    04741
    04742
    04743 #endif // __GCC_H
    04744
    04745 #endif // if ! H323_DISABLE_GCC
    04746
    04747
    04748 // End of gccpdu.h