D:/Storage/CVS_Head/h323plus/include/gccpdu.h

//
// gccpdu.h
//
// Code automatically generated by asnparse.
//

#if ! H323_DISABLE_GCC

#ifndef __GCC_H
#define __GCC_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <ptclib/asner.h>

//
// ChannelID
//

class GCC_ChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChannelID, PASN_Integer);
#endif
  public:
    GCC_ChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_ChannelID & operator=(int v);
    GCC_ChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// StaticChannelID
//

class GCC_StaticChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_StaticChannelID, PASN_Integer);
#endif
  public:
    GCC_StaticChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_StaticChannelID & operator=(int v);
    GCC_StaticChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// DynamicChannelID
//

class GCC_DynamicChannelID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DynamicChannelID, PASN_Integer);
#endif
  public:
    GCC_DynamicChannelID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_DynamicChannelID & operator=(int v);
    GCC_DynamicChannelID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// UserID
//

class GCC_UserID : public GCC_DynamicChannelID
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserID, GCC_DynamicChannelID);
#endif
  public:
    GCC_UserID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_UserID & operator=(int v);
    GCC_UserID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// TokenID
//

class GCC_TokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TokenID, PASN_Integer);
#endif
  public:
    GCC_TokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_TokenID & operator=(int v);
    GCC_TokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// StaticTokenID
//

class GCC_StaticTokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_StaticTokenID, PASN_Integer);
#endif
  public:
    GCC_StaticTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_StaticTokenID & operator=(int v);
    GCC_StaticTokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// DynamicTokenID
//

class GCC_DynamicTokenID : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DynamicTokenID, PASN_Integer);
#endif
  public:
    GCC_DynamicTokenID(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_DynamicTokenID & operator=(int v);
    GCC_DynamicTokenID & operator=(unsigned v);
    PObject * Clone() const;
};


//
// Time
//

class GCC_Time : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Time, PASN_Integer);
#endif
  public:
    GCC_Time(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_Time & operator=(int v);
    GCC_Time & operator=(unsigned v);
    PObject * Clone() const;
};


//
// Handle
//

class GCC_Handle : public PASN_Integer
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Handle, PASN_Integer);
#endif
  public:
    GCC_Handle(unsigned tag = UniversalInteger, TagClass tagClass = UniversalTagClass);

    GCC_Handle & operator=(int v);
    GCC_Handle & operator=(unsigned v);
    PObject * Clone() const;
};


//
// H221NonStandardIdentifier
//

class GCC_H221NonStandardIdentifier : public PASN_OctetString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_H221NonStandardIdentifier, PASN_OctetString);
#endif
  public:
    GCC_H221NonStandardIdentifier(unsigned tag = UniversalOctetString, TagClass tagClass = UniversalTagClass);

    GCC_H221NonStandardIdentifier(const char * v);
    GCC_H221NonStandardIdentifier(const PString & v);
    GCC_H221NonStandardIdentifier(const PBYTEArray & v);

    GCC_H221NonStandardIdentifier & operator=(const char * v);
    GCC_H221NonStandardIdentifier & operator=(const PString & v);
    GCC_H221NonStandardIdentifier & operator=(const PBYTEArray & v);
    PObject * Clone() const;
};


//
// Key
//

class GCC_H221NonStandardIdentifier;

class GCC_Key : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Key, PASN_Choice);
#endif
  public:
    GCC_Key(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_object,
      e_h221NonStandard
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_H221NonStandardIdentifier &() const;
#else
    operator GCC_H221NonStandardIdentifier &();
    operator const GCC_H221NonStandardIdentifier &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// NonStandardParameter
//

class GCC_NonStandardParameter : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NonStandardParameter, PASN_Sequence);
#endif
  public:
    GCC_NonStandardParameter(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_Key m_key;
    PASN_OctetString m_data;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// TextString
//

class GCC_TextString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TextString, PASN_BMPString);
#endif
  public:
    GCC_TextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_TextString & operator=(const char * v);
    GCC_TextString & operator=(const PString & v);
    GCC_TextString & operator=(const PWORDArray & v);
    GCC_TextString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// SimpleTextString
//

class GCC_SimpleTextString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SimpleTextString, PASN_BMPString);
#endif
  public:
    GCC_SimpleTextString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_SimpleTextString & operator=(const char * v);
    GCC_SimpleTextString & operator=(const PString & v);
    GCC_SimpleTextString & operator=(const PWORDArray & v);
    GCC_SimpleTextString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// SimpleNumericString
//

class GCC_SimpleNumericString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SimpleNumericString, PASN_NumericString);
#endif
  public:
    GCC_SimpleNumericString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_SimpleNumericString & operator=(const char * v);
    GCC_SimpleNumericString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// DialingString
//

class GCC_DialingString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_DialingString, PASN_NumericString);
#endif
  public:
    GCC_DialingString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_DialingString & operator=(const char * v);
    GCC_DialingString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// SubAddressString
//

class GCC_SubAddressString : public PASN_NumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SubAddressString, PASN_NumericString);
#endif
  public:
    GCC_SubAddressString(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_SubAddressString & operator=(const char * v);
    GCC_SubAddressString & operator=(const PString & v);
    PObject * Clone() const;
};


//
// ExtraDialingString
//

class GCC_ExtraDialingString : public PASN_BMPString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ExtraDialingString, PASN_BMPString);
#endif
  public:
    GCC_ExtraDialingString(unsigned tag = UniversalBMPString, TagClass tagClass = UniversalTagClass);

    GCC_ExtraDialingString & operator=(const char * v);
    GCC_ExtraDialingString & operator=(const PString & v);
    GCC_ExtraDialingString & operator=(const PWORDArray & v);
    GCC_ExtraDialingString & operator=(const PASN_BMPString & v);
    PObject * Clone() const;
};


//
// UserData
//

class GCC_UserData_subtype;

class GCC_UserData : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_UserData, PASN_Array);
#endif
  public:
    GCC_UserData(unsigned tag = UniversalSet, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_UserData_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// Password
//

class GCC_Password : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Password, PASN_Sequence);
#endif
  public:
    GCC_Password(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_text
    };

    GCC_SimpleNumericString m_numeric;
    GCC_SimpleTextString m_text;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// PasswordSelector
//

class GCC_SimpleNumericString;
class GCC_SimpleTextString;

class GCC_PasswordSelector : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_PasswordSelector, PASN_Choice);
#endif
  public:
    GCC_PasswordSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_numeric,
      e_text
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleNumericString &() const;
#else
    operator GCC_SimpleNumericString &();
    operator const GCC_SimpleNumericString &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleTextString &() const;
#else
    operator GCC_SimpleTextString &();
    operator const GCC_SimpleTextString &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ChallengeResponseItem
//

class GCC_PasswordSelector;
class GCC_UserData;

class GCC_ChallengeResponseItem : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponseItem, PASN_Choice);
#endif
  public:
    GCC_ChallengeResponseItem(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordString,
      e_responseData
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordSelector &() const;
#else
    operator GCC_PasswordSelector &();
    operator const GCC_PasswordSelector &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_UserData &() const;
#else
    operator GCC_UserData &();
    operator const GCC_UserData &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ChallengeResponseAlgorithm
//

class GCC_NonStandardParameter;

class GCC_ChallengeResponseAlgorithm : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponseAlgorithm, PASN_Choice);
#endif
  public:
    GCC_ChallengeResponseAlgorithm(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordInTheClear,
      e_nonStandardAlgorithm
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardParameter &() const;
#else
    operator GCC_NonStandardParameter &();
    operator const GCC_NonStandardParameter &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ChallengeItem
//

class GCC_ChallengeItem : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeItem, PASN_Sequence);
#endif
  public:
    GCC_ChallengeItem(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    GCC_UserData m_challengeData;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ChallengeResponse
//

class GCC_ChallengeResponse : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChallengeResponse, PASN_Sequence);
#endif
  public:
    GCC_ChallengeResponse(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_challengeTag;
    GCC_ChallengeResponseAlgorithm m_responseAlgorithm;
    GCC_ChallengeResponseItem m_responseItem;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// PasswordChallengeRequestResponse
//

class GCC_PasswordSelector;
class GCC_PasswordChallengeRequestResponse_challengeRequestResponse;

class GCC_PasswordChallengeRequestResponse : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_PasswordChallengeRequestResponse, PASN_Choice);
#endif
  public:
    GCC_PasswordChallengeRequestResponse(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_passwordInTheClear,
      e_challengeRequestResponse
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordSelector &() const;
#else
    operator GCC_PasswordSelector &();
    operator const GCC_PasswordSelector &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
#else
    operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &();
    operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ConferenceName
//

class GCC_ConferenceName : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceName, PASN_Sequence);
#endif
  public:
    GCC_ConferenceName(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_text
    };

    GCC_SimpleNumericString m_numeric;
    GCC_SimpleTextString m_text;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ConferenceNameSelector
//

class GCC_SimpleNumericString;
class GCC_SimpleTextString;

class GCC_ConferenceNameSelector : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceNameSelector, PASN_Choice);
#endif
  public:
    GCC_ConferenceNameSelector(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_numeric,
      e_text
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleNumericString &() const;
#else
    operator GCC_SimpleNumericString &();
    operator const GCC_SimpleNumericString &() const;
#endif
#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_SimpleTextString &() const;
#else
    operator GCC_SimpleTextString &();
    operator const GCC_SimpleTextString &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ConferenceNameModifier
//

class GCC_ConferenceNameModifier : public GCC_SimpleNumericString
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceNameModifier, GCC_SimpleNumericString);
#endif
  public:
    GCC_ConferenceNameModifier(unsigned tag = UniversalNumericString, TagClass tagClass = UniversalTagClass);

    GCC_ConferenceNameModifier & operator=(const char * v);
    GCC_ConferenceNameModifier & operator=(const PString & v);
    PObject * Clone() const;
};


//
// Privilege
//

class GCC_Privilege : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_Privilege, PASN_Enumeration);
#endif
  public:
    GCC_Privilege(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_terminate,
      e_ejectUser,
      e_add,
      e_lockUnlock,
      e_transfer
    };

    GCC_Privilege & operator=(unsigned v);
    PObject * Clone() const;
};


//
// TerminationMethod
//

class GCC_TerminationMethod : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_TerminationMethod, PASN_Enumeration);
#endif
  public:
    GCC_TerminationMethod(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_automatic,
      e_manual
    };

    GCC_TerminationMethod & operator=(unsigned v);
    PObject * Clone() const;
};


//
// ConferencePriorityScheme
//

class GCC_NonStandardParameter;

class GCC_ConferencePriorityScheme : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferencePriorityScheme, PASN_Choice);
#endif
  public:
    GCC_ConferencePriorityScheme(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_nonStandardScheme
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_NonStandardParameter &() const;
#else
    operator GCC_NonStandardParameter &();
    operator const GCC_NonStandardParameter &() const;
#endif

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ConferencePriority
//

class GCC_ConferencePriority : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferencePriority, PASN_Sequence);
#endif
  public:
    GCC_ConferencePriority(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Integer m_priority;
    GCC_ConferencePriorityScheme m_scheme;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// NetworkAddress
//

class GCC_NetworkAddress_subtype;

class GCC_NetworkAddress : public PASN_Array
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NetworkAddress, PASN_Array);
#endif
  public:
    GCC_NetworkAddress(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Object * CreateObject() const;
    GCC_NetworkAddress_subtype & operator[](PINDEX i) const;
    PObject * Clone() const;
};


//
// NodeType
//

class GCC_NodeType : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NodeType, PASN_Enumeration);
#endif
  public:
    GCC_NodeType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_terminal,
      e_multiportTerminal,
      e_mcu
    };

    GCC_NodeType & operator=(unsigned v);
    PObject * Clone() const;
};


//
// NodeProperties
//

class GCC_NodeProperties : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_NodeProperties, PASN_Sequence);
#endif
  public:
    GCC_NodeProperties(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    PASN_Boolean m_managementDevice;
    PASN_Boolean m_peripheralDevice;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// AsymmetryIndicator
//

class GCC_AsymmetryIndicator : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_AsymmetryIndicator, PASN_Choice);
#endif
  public:
    GCC_AsymmetryIndicator(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_callingNode,
      e_calledNode,
      e_unknown
    };

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// AlternativeNodeID
//

class GCC_AlternativeNodeID : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_AlternativeNodeID, PASN_Choice);
#endif
  public:
    GCC_AlternativeNodeID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_h243NodeID
    };

    BOOL CreateObject();
    PObject * Clone() const;
};


//
// ConferenceDescriptor
//

class GCC_ConferenceDescriptor : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ConferenceDescriptor, PASN_Sequence);
#endif
  public:
    GCC_ConferenceDescriptor(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_conferenceNameModifier,
      e_conferenceDescription,
      e_networkAddress,
      e_defaultConferenceFlag
    };

    GCC_ConferenceName m_conferenceName;
    GCC_ConferenceNameModifier m_conferenceNameModifier;
    GCC_TextString m_conferenceDescription;
    PASN_Boolean m_lockedConference;
    PASN_Boolean m_passwordInTheClearRequired;
    GCC_NetworkAddress m_networkAddress;
    PASN_Boolean m_defaultConferenceFlag;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// SessionKey
//

class GCC_SessionKey : public PASN_Sequence
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_SessionKey, PASN_Sequence);
#endif
  public:
    GCC_SessionKey(unsigned tag = UniversalSequence, TagClass tagClass = UniversalTagClass);

    enum OptionalFields {
      e_sessionID
    };

    GCC_Key m_applicationProtocolKey;
    GCC_ChannelID m_sessionID;

    PINDEX GetDataLength() const;
    BOOL Decode(PASN_Stream & strm);
    void Encode(PASN_Stream & strm) const;
#ifndef PASN_NOPRINTON
    void PrintOn(ostream & strm) const;
#endif
    Comparison Compare(const PObject & obj) const;
    PObject * Clone() const;
};


//
// ChannelType
//

class GCC_ChannelType : public PASN_Enumeration
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_ChannelType, PASN_Enumeration);
#endif
  public:
    GCC_ChannelType(unsigned tag = UniversalEnumeration, TagClass tagClass = UniversalTagClass);

    enum Enumerations {
      e_static,
      e_dynamicMulticast,
      e_dynamicPrivate,
      e_dynamicUserId
    };

    GCC_ChannelType & operator=(unsigned v);
    PObject * Clone() const;
};


//
// CapabilityID
//

class GCC_Key;

class GCC_CapabilityID : public PASN_Choice
{
#ifndef PASN_LEANANDMEAN
    PCLASSINFO(GCC_CapabilityID, PASN_Choice);
#endif
  public:
    GCC_CapabilityID(unsigned tag = 0, TagClass tagClass = UniversalTagClass);

    enum Choices {
      e_standard,
      e_nonStandard
    };

#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
    operator GCC_Key &() const;
#else
    operator GCC_Key &();
    operator const GCC_Key &() const;
#endif

    BOOL CreateObject();
    PObject *