D:/Storage/CVS_Head/h323plus/src/gccpdu.cxx

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

#ifdef P_USE_PRAGMA
#pragma implementation "gccpdu.h"
#endif

#include <ptlib.h>
#include "gccpdu.h"

#define new PNEW


#if ! H323_DISABLE_GCC

//
// ChannelID
//

GCC_ChannelID::GCC_ChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
}


GCC_ChannelID & GCC_ChannelID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_ChannelID & GCC_ChannelID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_ChannelID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChannelID::Class()), PInvalidCast);
#endif
  return new GCC_ChannelID(*this);
}


//
// StaticChannelID
//

GCC_StaticChannelID::GCC_StaticChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 1000);
}


GCC_StaticChannelID & GCC_StaticChannelID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_StaticChannelID & GCC_StaticChannelID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_StaticChannelID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_StaticChannelID::Class()), PInvalidCast);
#endif
  return new GCC_StaticChannelID(*this);
}


//
// DynamicChannelID
//

GCC_DynamicChannelID::GCC_DynamicChannelID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1001, 65535);
}


GCC_DynamicChannelID & GCC_DynamicChannelID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_DynamicChannelID & GCC_DynamicChannelID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_DynamicChannelID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_DynamicChannelID::Class()), PInvalidCast);
#endif
  return new GCC_DynamicChannelID(*this);
}


//
// UserID
//

GCC_UserID::GCC_UserID(unsigned tag, PASN_Object::TagClass tagClass)
  : GCC_DynamicChannelID(tag, tagClass)
{
}


GCC_UserID & GCC_UserID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_UserID & GCC_UserID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_UserID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_UserID::Class()), PInvalidCast);
#endif
  return new GCC_UserID(*this);
}


//
// TokenID
//

GCC_TokenID::GCC_TokenID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
}


GCC_TokenID & GCC_TokenID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_TokenID & GCC_TokenID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_TokenID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_TokenID::Class()), PInvalidCast);
#endif
  return new GCC_TokenID(*this);
}


//
// StaticTokenID
//

GCC_StaticTokenID::GCC_StaticTokenID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 16383);
}


GCC_StaticTokenID & GCC_StaticTokenID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_StaticTokenID & GCC_StaticTokenID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_StaticTokenID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_StaticTokenID::Class()), PInvalidCast);
#endif
  return new GCC_StaticTokenID(*this);
}


//
// DynamicTokenID
//

GCC_DynamicTokenID::GCC_DynamicTokenID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 16384, 65535);
}


GCC_DynamicTokenID & GCC_DynamicTokenID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_DynamicTokenID & GCC_DynamicTokenID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_DynamicTokenID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_DynamicTokenID::Class()), PInvalidCast);
#endif
  return new GCC_DynamicTokenID(*this);
}


//
// Time
//

GCC_Time::GCC_Time(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, -2147483647, 2147483647);
}


GCC_Time & GCC_Time::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_Time & GCC_Time::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_Time::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_Time::Class()), PInvalidCast);
#endif
  return new GCC_Time(*this);
}


//
// Handle
//

GCC_Handle::GCC_Handle(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
}


GCC_Handle & GCC_Handle::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_Handle & GCC_Handle::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_Handle::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_Handle::Class()), PInvalidCast);
#endif
  return new GCC_Handle(*this);
}


//
// H221NonStandardIdentifier
//

GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_OctetString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 4, 255);
}


GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const char * v)
{
  SetValue(v);
}


GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const PString & v)
{
  SetValue(v);
}


GCC_H221NonStandardIdentifier::GCC_H221NonStandardIdentifier(const PBYTEArray & v)
{
  SetValue(v);
}


GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


GCC_H221NonStandardIdentifier & GCC_H221NonStandardIdentifier::operator=(const PBYTEArray & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_H221NonStandardIdentifier::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_H221NonStandardIdentifier::Class()), PInvalidCast);
#endif
  return new GCC_H221NonStandardIdentifier(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_Key[]={
      {"object",0}
     ,{"h221NonStandard",1}
};
#endif
//
// Key
//

GCC_Key::GCC_Key(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_Key,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_Key::operator GCC_H221NonStandardIdentifier &() const
#else
GCC_Key::operator GCC_H221NonStandardIdentifier &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_H221NonStandardIdentifier), PInvalidCast);
#endif
  return *(GCC_H221NonStandardIdentifier *)choice;
}


GCC_Key::operator const GCC_H221NonStandardIdentifier &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_H221NonStandardIdentifier), PInvalidCast);
#endif
  return *(GCC_H221NonStandardIdentifier *)choice;
}


BOOL GCC_Key::CreateObject()
{
  switch (tag) {
    case e_object :
      choice = new PASN_ObjectId();
      return TRUE;
    case e_h221NonStandard :
      choice = new GCC_H221NonStandardIdentifier();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_Key::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_Key::Class()), PInvalidCast);
#endif
  return new GCC_Key(*this);
}


//
// NonStandardParameter
//

GCC_NonStandardParameter::GCC_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_NonStandardParameter::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_NonStandardParameter::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_NonStandardParameter), PInvalidCast);
#endif
  const GCC_NonStandardParameter & other = (const GCC_NonStandardParameter &)obj;

  Comparison result;

  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;
  if ((result = m_data.Compare(other.m_data)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_NonStandardParameter::GetDataLength() const
{
  PINDEX length = 0;
  length += m_key.GetObjectLength();
  length += m_data.GetObjectLength();
  return length;
}


BOOL GCC_NonStandardParameter::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_key.Decode(strm))
    return FALSE;
  if (!m_data.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_NonStandardParameter::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_key.Encode(strm);
  m_data.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_NonStandardParameter::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_NonStandardParameter::Class()), PInvalidCast);
#endif
  return new GCC_NonStandardParameter(*this);
}


//
// TextString
//

GCC_TextString::GCC_TextString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_BMPString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 0, 255);
}


GCC_TextString & GCC_TextString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_TextString & GCC_TextString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


GCC_TextString & GCC_TextString::operator=(const PWORDArray & v)
{
  SetValue(v);
  return *this;
}


GCC_TextString & GCC_TextString::operator=(const PASN_BMPString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_TextString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_TextString::Class()), PInvalidCast);
#endif
  return new GCC_TextString(*this);
}


//
// SimpleTextString
//

GCC_SimpleTextString::GCC_SimpleTextString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_BMPString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 0, 255);
  SetCharacterSet(PASN_Object::FixedConstraint, 0, 255);
}


GCC_SimpleTextString & GCC_SimpleTextString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PWORDArray & v)
{
  SetValue(v);
  return *this;
}


GCC_SimpleTextString & GCC_SimpleTextString::operator=(const PASN_BMPString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_SimpleTextString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_SimpleTextString::Class()), PInvalidCast);
#endif
  return new GCC_SimpleTextString(*this);
}


//
// SimpleNumericString
//

GCC_SimpleNumericString::GCC_SimpleNumericString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_NumericString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
}


GCC_SimpleNumericString & GCC_SimpleNumericString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_SimpleNumericString & GCC_SimpleNumericString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_SimpleNumericString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_SimpleNumericString::Class()), PInvalidCast);
#endif
  return new GCC_SimpleNumericString(*this);
}


//
// DialingString
//

GCC_DialingString::GCC_DialingString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_NumericString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 16);
  SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
}


GCC_DialingString & GCC_DialingString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_DialingString & GCC_DialingString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_DialingString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_DialingString::Class()), PInvalidCast);
#endif
  return new GCC_DialingString(*this);
}


//
// SubAddressString
//

GCC_SubAddressString::GCC_SubAddressString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_NumericString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 40);
  SetCharacterSet(PASN_Object::FixedConstraint, "0123456789");
}


GCC_SubAddressString & GCC_SubAddressString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_SubAddressString & GCC_SubAddressString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_SubAddressString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_SubAddressString::Class()), PInvalidCast);
#endif
  return new GCC_SubAddressString(*this);
}


//
// ExtraDialingString
//

GCC_ExtraDialingString::GCC_ExtraDialingString(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_BMPString(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  SetCharacterSet(PASN_Object::FixedConstraint, "0123456789#*,");
}


GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PWORDArray & v)
{
  SetValue(v);
  return *this;
}


GCC_ExtraDialingString & GCC_ExtraDialingString::operator=(const PASN_BMPString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_ExtraDialingString::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ExtraDialingString::Class()), PInvalidCast);
#endif
  return new GCC_ExtraDialingString(*this);
}


//
// UserData
//

GCC_UserData::GCC_UserData(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Array(tag, tagClass)
{
}


PASN_Object * GCC_UserData::CreateObject() const
{
  return new GCC_UserData_subtype;
}


GCC_UserData_subtype & GCC_UserData::operator[](PINDEX i) const
{
  return (GCC_UserData_subtype &)array[i];
}


PObject * GCC_UserData::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_UserData::Class()), PInvalidCast);
#endif
  return new GCC_UserData(*this);
}


//
// Password
//

GCC_Password::GCC_Password(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_Password::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+10) << "numeric = " << setprecision(indent) << m_numeric << '\n';
  if (HasOptionalField(e_text))
    strm << setw(indent+7) << "text = " << setprecision(indent) << m_text << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_Password::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_Password), PInvalidCast);
#endif
  const GCC_Password & other = (const GCC_Password &)obj;

  Comparison result;

  if ((result = m_numeric.Compare(other.m_numeric)) != EqualTo)
    return result;
  if ((result = m_text.Compare(other.m_text)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_Password::GetDataLength() const
{
  PINDEX length = 0;
  length += m_numeric.GetObjectLength();
  if (HasOptionalField(e_text))
    length += m_text.GetObjectLength();
  return length;
}


BOOL GCC_Password::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_numeric.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_text) && !m_text.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_Password::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_numeric.Encode(strm);
  if (HasOptionalField(e_text))
    m_text.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_Password::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_Password::Class()), PInvalidCast);
#endif
  return new GCC_Password(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_PasswordSelector[]={
      {"numeric",0}
     ,{"text",1}
};
#endif
//
// PasswordSelector
//

GCC_PasswordSelector::GCC_PasswordSelector(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_PasswordSelector,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_PasswordSelector::operator GCC_SimpleNumericString &() const
#else
GCC_PasswordSelector::operator GCC_SimpleNumericString &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleNumericString), PInvalidCast);
#endif
  return *(GCC_SimpleNumericString *)choice;
}


GCC_PasswordSelector::operator const GCC_SimpleNumericString &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleNumericString), PInvalidCast);
#endif
  return *(GCC_SimpleNumericString *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_PasswordSelector::operator GCC_SimpleTextString &() const
#else
GCC_PasswordSelector::operator GCC_SimpleTextString &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleTextString), PInvalidCast);
#endif
  return *(GCC_SimpleTextString *)choice;
}


GCC_PasswordSelector::operator const GCC_SimpleTextString &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleTextString), PInvalidCast);
#endif
  return *(GCC_SimpleTextString *)choice;
}


BOOL GCC_PasswordSelector::CreateObject()
{
  switch (tag) {
    case e_numeric :
      choice = new GCC_SimpleNumericString();
      return TRUE;
    case e_text :
      choice = new GCC_SimpleTextString();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_PasswordSelector::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_PasswordSelector::Class()), PInvalidCast);
#endif
  return new GCC_PasswordSelector(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ChallengeResponseItem[]={
      {"passwordString",0}
     ,{"responseData",1}
};
#endif
//
// ChallengeResponseItem
//

GCC_ChallengeResponseItem::GCC_ChallengeResponseItem(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ChallengeResponseItem,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ChallengeResponseItem::operator GCC_PasswordSelector &() const
#else
GCC_ChallengeResponseItem::operator GCC_PasswordSelector &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordSelector), PInvalidCast);
#endif
  return *(GCC_PasswordSelector *)choice;
}


GCC_ChallengeResponseItem::operator const GCC_PasswordSelector &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordSelector), PInvalidCast);
#endif
  return *(GCC_PasswordSelector *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ChallengeResponseItem::operator GCC_UserData &() const
#else
GCC_ChallengeResponseItem::operator GCC_UserData &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_UserData), PInvalidCast);
#endif
  return *(GCC_UserData *)choice;
}


GCC_ChallengeResponseItem::operator const GCC_UserData &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_UserData), PInvalidCast);
#endif
  return *(GCC_UserData *)choice;
}


BOOL GCC_ChallengeResponseItem::CreateObject()
{
  switch (tag) {
    case e_passwordString :
      choice = new GCC_PasswordSelector();
      return TRUE;
    case e_responseData :
      choice = new GCC_UserData();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_ChallengeResponseItem::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChallengeResponseItem::Class()), PInvalidCast);
#endif
  return new GCC_ChallengeResponseItem(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ChallengeResponseAlgorithm[]={
      {"passwordInTheClear",0}
     ,{"nonStandardAlgorithm",1}
};
#endif
//
// ChallengeResponseAlgorithm
//

GCC_ChallengeResponseAlgorithm::GCC_ChallengeResponseAlgorithm(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ChallengeResponseAlgorithm,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ChallengeResponseAlgorithm::operator GCC_NonStandardParameter &() const
#else
GCC_ChallengeResponseAlgorithm::operator GCC_NonStandardParameter &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_NonStandardParameter), PInvalidCast);
#endif
  return *(GCC_NonStandardParameter *)choice;
}


GCC_ChallengeResponseAlgorithm::operator const GCC_NonStandardParameter &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_NonStandardParameter), PInvalidCast);
#endif
  return *(GCC_NonStandardParameter *)choice;
}


BOOL GCC_ChallengeResponseAlgorithm::CreateObject()
{
  switch (tag) {
    case e_passwordInTheClear :
      choice = new PASN_Null();
      return TRUE;
    case e_nonStandardAlgorithm :
      choice = new GCC_NonStandardParameter();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_ChallengeResponseAlgorithm::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChallengeResponseAlgorithm::Class()), PInvalidCast);
#endif
  return new GCC_ChallengeResponseAlgorithm(*this);
}


//
// ChallengeItem
//

GCC_ChallengeItem::GCC_ChallengeItem(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ChallengeItem::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+20) << "responseAlgorithm = " << setprecision(indent) << m_responseAlgorithm << '\n';
  strm << setw(indent+16) << "challengeData = " << setprecision(indent) << m_challengeData << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ChallengeItem::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ChallengeItem), PInvalidCast);
#endif
  const GCC_ChallengeItem & other = (const GCC_ChallengeItem &)obj;

  Comparison result;

  if ((result = m_responseAlgorithm.Compare(other.m_responseAlgorithm)) != EqualTo)
    return result;
  if ((result = m_challengeData.Compare(other.m_challengeData)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ChallengeItem::GetDataLength() const
{
  PINDEX length = 0;
  length += m_responseAlgorithm.GetObjectLength();
  length += m_challengeData.GetObjectLength();
  return length;
}


BOOL GCC_ChallengeItem::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_responseAlgorithm.Decode(strm))
    return FALSE;
  if (!m_challengeData.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ChallengeItem::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_responseAlgorithm.Encode(strm);
  m_challengeData.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ChallengeItem::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChallengeItem::Class()), PInvalidCast);
#endif
  return new GCC_ChallengeItem(*this);
}


//
// ChallengeResponse
//

GCC_ChallengeResponse::GCC_ChallengeResponse(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ChallengeResponse::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+15) << "challengeTag = " << setprecision(indent) << m_challengeTag << '\n';
  strm << setw(indent+20) << "responseAlgorithm = " << setprecision(indent) << m_responseAlgorithm << '\n';
  strm << setw(indent+15) << "responseItem = " << setprecision(indent) << m_responseItem << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ChallengeResponse::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ChallengeResponse), PInvalidCast);
#endif
  const GCC_ChallengeResponse & other = (const GCC_ChallengeResponse &)obj;

  Comparison result;

  if ((result = m_challengeTag.Compare(other.m_challengeTag)) != EqualTo)
    return result;
  if ((result = m_responseAlgorithm.Compare(other.m_responseAlgorithm)) != EqualTo)
    return result;
  if ((result = m_responseItem.Compare(other.m_responseItem)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ChallengeResponse::GetDataLength() const
{
  PINDEX length = 0;
  length += m_challengeTag.GetObjectLength();
  length += m_responseAlgorithm.GetObjectLength();
  length += m_responseItem.GetObjectLength();
  return length;
}


BOOL GCC_ChallengeResponse::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_challengeTag.Decode(strm))
    return FALSE;
  if (!m_responseAlgorithm.Decode(strm))
    return FALSE;
  if (!m_responseItem.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ChallengeResponse::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_challengeTag.Encode(strm);
  m_responseAlgorithm.Encode(strm);
  m_responseItem.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ChallengeResponse::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChallengeResponse::Class()), PInvalidCast);
#endif
  return new GCC_ChallengeResponse(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_PasswordChallengeRequestResponse[]={
      {"passwordInTheClear",0}
     ,{"challengeRequestResponse",1}
};
#endif
//
// PasswordChallengeRequestResponse
//

GCC_PasswordChallengeRequestResponse::GCC_PasswordChallengeRequestResponse(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_PasswordChallengeRequestResponse,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_PasswordChallengeRequestResponse::operator GCC_PasswordSelector &() const
#else
GCC_PasswordChallengeRequestResponse::operator GCC_PasswordSelector &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordSelector), PInvalidCast);
#endif
  return *(GCC_PasswordSelector *)choice;
}


GCC_PasswordChallengeRequestResponse::operator const GCC_PasswordSelector &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordSelector), PInvalidCast);
#endif
  return *(GCC_PasswordSelector *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_PasswordChallengeRequestResponse::operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const
#else
GCC_PasswordChallengeRequestResponse::operator GCC_PasswordChallengeRequestResponse_challengeRequestResponse &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordChallengeRequestResponse_challengeRequestResponse), PInvalidCast);
#endif
  return *(GCC_PasswordChallengeRequestResponse_challengeRequestResponse *)choice;
}


GCC_PasswordChallengeRequestResponse::operator const GCC_PasswordChallengeRequestResponse_challengeRequestResponse &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_PasswordChallengeRequestResponse_challengeRequestResponse), PInvalidCast);
#endif
  return *(GCC_PasswordChallengeRequestResponse_challengeRequestResponse *)choice;
}


BOOL GCC_PasswordChallengeRequestResponse::CreateObject()
{
  switch (tag) {
    case e_passwordInTheClear :
      choice = new GCC_PasswordSelector();
      return TRUE;
    case e_challengeRequestResponse :
      choice = new GCC_PasswordChallengeRequestResponse_challengeRequestResponse();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_PasswordChallengeRequestResponse::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_PasswordChallengeRequestResponse::Class()), PInvalidCast);
#endif
  return new GCC_PasswordChallengeRequestResponse(*this);
}


//
// ConferenceName
//

GCC_ConferenceName::GCC_ConferenceName(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceName::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+10) << "numeric = " << setprecision(indent) << m_numeric << '\n';
  if (HasOptionalField(e_text))
    strm << setw(indent+7) << "text = " << setprecision(indent) << m_text << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceName::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceName), PInvalidCast);
#endif
  const GCC_ConferenceName & other = (const GCC_ConferenceName &)obj;

  Comparison result;

  if ((result = m_numeric.Compare(other.m_numeric)) != EqualTo)
    return result;
  if ((result = m_text.Compare(other.m_text)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceName::GetDataLength() const
{
  PINDEX length = 0;
  length += m_numeric.GetObjectLength();
  if (HasOptionalField(e_text))
    length += m_text.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceName::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_numeric.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_text) && !m_text.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceName::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_numeric.Encode(strm);
  if (HasOptionalField(e_text))
    m_text.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceName::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceName::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceName(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ConferenceNameSelector[]={
      {"numeric",0}
     ,{"text",1}
};
#endif
//
// ConferenceNameSelector
//

GCC_ConferenceNameSelector::GCC_ConferenceNameSelector(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ConferenceNameSelector,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConferenceNameSelector::operator GCC_SimpleNumericString &() const
#else
GCC_ConferenceNameSelector::operator GCC_SimpleNumericString &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleNumericString), PInvalidCast);
#endif
  return *(GCC_SimpleNumericString *)choice;
}


GCC_ConferenceNameSelector::operator const GCC_SimpleNumericString &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleNumericString), PInvalidCast);
#endif
  return *(GCC_SimpleNumericString *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConferenceNameSelector::operator GCC_SimpleTextString &() const
#else
GCC_ConferenceNameSelector::operator GCC_SimpleTextString &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleTextString), PInvalidCast);
#endif
  return *(GCC_SimpleTextString *)choice;
}


GCC_ConferenceNameSelector::operator const GCC_SimpleTextString &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_SimpleTextString), PInvalidCast);
#endif
  return *(GCC_SimpleTextString *)choice;
}


BOOL GCC_ConferenceNameSelector::CreateObject()
{
  switch (tag) {
    case e_numeric :
      choice = new GCC_SimpleNumericString();
      return TRUE;
    case e_text :
      choice = new GCC_SimpleTextString();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_ConferenceNameSelector::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceNameSelector::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceNameSelector(*this);
}


//
// ConferenceNameModifier
//

GCC_ConferenceNameModifier::GCC_ConferenceNameModifier(unsigned tag, PASN_Object::TagClass tagClass)
  : GCC_SimpleNumericString(tag, tagClass)
{
}


GCC_ConferenceNameModifier & GCC_ConferenceNameModifier::operator=(const char * v)
{
  SetValue(v);
  return *this;
}


GCC_ConferenceNameModifier & GCC_ConferenceNameModifier::operator=(const PString & v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_ConferenceNameModifier::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceNameModifier::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceNameModifier(*this);
}


#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_Privilege[]={
        {"terminate",0}
       ,{"ejectUser",1}
       ,{"add",2}
       ,{"lockUnlock",3}
       ,{"transfer",4}
};
#endif
//
// Privilege
//

GCC_Privilege::GCC_Privilege(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Enumeration(tag, tagClass, 4, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_Privilege,5
#endif
    )
{
}


GCC_Privilege & GCC_Privilege::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_Privilege::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_Privilege::Class()), PInvalidCast);
#endif
  return new GCC_Privilege(*this);
}


#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_TerminationMethod[]={
        {"automatic",0}
       ,{"manual",1}
};
#endif
//
// TerminationMethod
//

GCC_TerminationMethod::GCC_TerminationMethod(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Enumeration(tag, tagClass, 1, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_TerminationMethod,2
#endif
    )
{
}


GCC_TerminationMethod & GCC_TerminationMethod::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_TerminationMethod::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_TerminationMethod::Class()), PInvalidCast);
#endif
  return new GCC_TerminationMethod(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ConferencePriorityScheme[]={
      {"nonStandardScheme",0}
};
#endif
//
// ConferencePriorityScheme
//

GCC_ConferencePriorityScheme::GCC_ConferencePriorityScheme(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 1, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ConferencePriorityScheme,1
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConferencePriorityScheme::operator GCC_NonStandardParameter &() const
#else
GCC_ConferencePriorityScheme::operator GCC_NonStandardParameter &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_NonStandardParameter), PInvalidCast);
#endif
  return *(GCC_NonStandardParameter *)choice;
}


GCC_ConferencePriorityScheme::operator const GCC_NonStandardParameter &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_NonStandardParameter), PInvalidCast);
#endif
  return *(GCC_NonStandardParameter *)choice;
}


BOOL GCC_ConferencePriorityScheme::CreateObject()
{
  switch (tag) {
    case e_nonStandardScheme :
      choice = new GCC_NonStandardParameter();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_ConferencePriorityScheme::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferencePriorityScheme::Class()), PInvalidCast);
#endif
  return new GCC_ConferencePriorityScheme(*this);
}


//
// ConferencePriority
//

GCC_ConferencePriority::GCC_ConferencePriority(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
  m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
}


#ifndef PASN_NOPRINTON
void GCC_ConferencePriority::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
  strm << setw(indent+9) << "scheme = " << setprecision(indent) << m_scheme << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferencePriority::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferencePriority), PInvalidCast);
#endif
  const GCC_ConferencePriority & other = (const GCC_ConferencePriority &)obj;

  Comparison result;

  if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
    return result;
  if ((result = m_scheme.Compare(other.m_scheme)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferencePriority::GetDataLength() const
{
  PINDEX length = 0;
  length += m_priority.GetObjectLength();
  length += m_scheme.GetObjectLength();
  return length;
}


BOOL GCC_ConferencePriority::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_priority.Decode(strm))
    return FALSE;
  if (!m_scheme.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferencePriority::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_priority.Encode(strm);
  m_scheme.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferencePriority::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferencePriority::Class()), PInvalidCast);
#endif
  return new GCC_ConferencePriority(*this);
}


//
// NetworkAddress
//

GCC_NetworkAddress::GCC_NetworkAddress(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Array(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 1, 64);
}


PASN_Object * GCC_NetworkAddress::CreateObject() const
{
  return new GCC_NetworkAddress_subtype;
}


GCC_NetworkAddress_subtype & GCC_NetworkAddress::operator[](PINDEX i) const
{
  return (GCC_NetworkAddress_subtype &)array[i];
}


PObject * GCC_NetworkAddress::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_NetworkAddress::Class()), PInvalidCast);
#endif
  return new GCC_NetworkAddress(*this);
}


#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_NodeType[]={
        {"terminal",0}
       ,{"multiportTerminal",1}
       ,{"mcu",2}
};
#endif
//
// NodeType
//

GCC_NodeType::GCC_NodeType(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Enumeration(tag, tagClass, 2, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_NodeType,3
#endif
    )
{
}


GCC_NodeType & GCC_NodeType::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_NodeType::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_NodeType::Class()), PInvalidCast);
#endif
  return new GCC_NodeType(*this);
}


//
// NodeProperties
//

GCC_NodeProperties::GCC_NodeProperties(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_NodeProperties::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+19) << "managementDevice = " << setprecision(indent) << m_managementDevice << '\n';
  strm << setw(indent+19) << "peripheralDevice = " << setprecision(indent) << m_peripheralDevice << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_NodeProperties::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_NodeProperties), PInvalidCast);
#endif
  const GCC_NodeProperties & other = (const GCC_NodeProperties &)obj;

  Comparison result;

  if ((result = m_managementDevice.Compare(other.m_managementDevice)) != EqualTo)
    return result;
  if ((result = m_peripheralDevice.Compare(other.m_peripheralDevice)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_NodeProperties::GetDataLength() const
{
  PINDEX length = 0;
  length += m_managementDevice.GetObjectLength();
  length += m_peripheralDevice.GetObjectLength();
  return length;
}


BOOL GCC_NodeProperties::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_managementDevice.Decode(strm))
    return FALSE;
  if (!m_peripheralDevice.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_NodeProperties::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_managementDevice.Encode(strm);
  m_peripheralDevice.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_NodeProperties::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_NodeProperties::Class()), PInvalidCast);
#endif
  return new GCC_NodeProperties(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_AsymmetryIndicator[]={
      {"callingNode",0}
     ,{"calledNode",1}
     ,{"unknown",2}
};
#endif
//
// AsymmetryIndicator
//

GCC_AsymmetryIndicator::GCC_AsymmetryIndicator(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 3, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_AsymmetryIndicator,3
#endif
)
{
}


BOOL GCC_AsymmetryIndicator::CreateObject()
{
  switch (tag) {
    case e_callingNode :
    case e_calledNode :
      choice = new PASN_Null();
      return TRUE;
    case e_unknown :
      choice = new PASN_Integer();
      choice->SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_AsymmetryIndicator::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_AsymmetryIndicator::Class()), PInvalidCast);
#endif
  return new GCC_AsymmetryIndicator(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_AlternativeNodeID[]={
      {"h243NodeID",0}
};
#endif
//
// AlternativeNodeID
//

GCC_AlternativeNodeID::GCC_AlternativeNodeID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 1, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_AlternativeNodeID,1
#endif
)
{
}


BOOL GCC_AlternativeNodeID::CreateObject()
{
  switch (tag) {
    case e_h243NodeID :
      choice = new PASN_OctetString();
      choice->SetConstraints(PASN_Object::FixedConstraint, 2);
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_AlternativeNodeID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_AlternativeNodeID::Class()), PInvalidCast);
#endif
  return new GCC_AlternativeNodeID(*this);
}


//
// ConferenceDescriptor
//

GCC_ConferenceDescriptor::GCC_ConferenceDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 3, TRUE, 1)
{
  IncludeOptionalField(e_defaultConferenceFlag);
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceDescriptor::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  if (HasOptionalField(e_conferenceNameModifier))
    strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  if (HasOptionalField(e_conferenceDescription))
    strm << setw(indent+24) << "conferenceDescription = " << setprecision(indent) << m_conferenceDescription << '\n';
  strm << setw(indent+19) << "lockedConference = " << setprecision(indent) << m_lockedConference << '\n';
  strm << setw(indent+29) << "passwordInTheClearRequired = " << setprecision(indent) << m_passwordInTheClearRequired << '\n';
  if (HasOptionalField(e_networkAddress))
    strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  if (HasOptionalField(e_defaultConferenceFlag))
    strm << setw(indent+24) << "defaultConferenceFlag = " << setprecision(indent) << m_defaultConferenceFlag << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceDescriptor::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceDescriptor), PInvalidCast);
#endif
  const GCC_ConferenceDescriptor & other = (const GCC_ConferenceDescriptor &)obj;

  Comparison result;

  if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
    return result;
  if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
    return result;
  if ((result = m_conferenceDescription.Compare(other.m_conferenceDescription)) != EqualTo)
    return result;
  if ((result = m_lockedConference.Compare(other.m_lockedConference)) != EqualTo)
    return result;
  if ((result = m_passwordInTheClearRequired.Compare(other.m_passwordInTheClearRequired)) != EqualTo)
    return result;
  if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceDescriptor::GetDataLength() const
{
  PINDEX length = 0;
  length += m_conferenceName.GetObjectLength();
  if (HasOptionalField(e_conferenceNameModifier))
    length += m_conferenceNameModifier.GetObjectLength();
  if (HasOptionalField(e_conferenceDescription))
    length += m_conferenceDescription.GetObjectLength();
  length += m_lockedConference.GetObjectLength();
  length += m_passwordInTheClearRequired.GetObjectLength();
  if (HasOptionalField(e_networkAddress))
    length += m_networkAddress.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceDescriptor::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_conferenceName.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_conferenceDescription) && !m_conferenceDescription.Decode(strm))
    return FALSE;
  if (!m_lockedConference.Decode(strm))
    return FALSE;
  if (!m_passwordInTheClearRequired.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_networkAddress) && !m_networkAddress.Decode(strm))
    return FALSE;
  if (!KnownExtensionDecode(strm, e_defaultConferenceFlag, m_defaultConferenceFlag))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceDescriptor::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_conferenceName.Encode(strm);
  if (HasOptionalField(e_conferenceNameModifier))
    m_conferenceNameModifier.Encode(strm);
  if (HasOptionalField(e_conferenceDescription))
    m_conferenceDescription.Encode(strm);
  m_lockedConference.Encode(strm);
  m_passwordInTheClearRequired.Encode(strm);
  if (HasOptionalField(e_networkAddress))
    m_networkAddress.Encode(strm);
  KnownExtensionEncode(strm, e_defaultConferenceFlag, m_defaultConferenceFlag);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceDescriptor::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceDescriptor::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceDescriptor(*this);
}


//
// SessionKey
//

GCC_SessionKey::GCC_SessionKey(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, FALSE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_SessionKey::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+25) << "applicationProtocolKey = " << setprecision(indent) << m_applicationProtocolKey << '\n';
  if (HasOptionalField(e_sessionID))
    strm << setw(indent+12) << "sessionID = " << setprecision(indent) << m_sessionID << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_SessionKey::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_SessionKey), PInvalidCast);
#endif
  const GCC_SessionKey & other = (const GCC_SessionKey &)obj;

  Comparison result;

  if ((result = m_applicationProtocolKey.Compare(other.m_applicationProtocolKey)) != EqualTo)
    return result;
  if ((result = m_sessionID.Compare(other.m_sessionID)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_SessionKey::GetDataLength() const
{
  PINDEX length = 0;
  length += m_applicationProtocolKey.GetObjectLength();
  if (HasOptionalField(e_sessionID))
    length += m_sessionID.GetObjectLength();
  return length;
}


BOOL GCC_SessionKey::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_applicationProtocolKey.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_sessionID) && !m_sessionID.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_SessionKey::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_applicationProtocolKey.Encode(strm);
  if (HasOptionalField(e_sessionID))
    m_sessionID.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_SessionKey::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_SessionKey::Class()), PInvalidCast);
#endif
  return new GCC_SessionKey(*this);
}


#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ChannelType[]={
        {"static",0}
       ,{"dynamicMulticast",1}
       ,{"dynamicPrivate",2}
       ,{"dynamicUserId",3}
};
#endif
//
// ChannelType
//

GCC_ChannelType::GCC_ChannelType(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Enumeration(tag, tagClass, 3, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ChannelType,4
#endif
    )
{
}


GCC_ChannelType & GCC_ChannelType::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_ChannelType::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ChannelType::Class()), PInvalidCast);
#endif
  return new GCC_ChannelType(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_CapabilityID[]={
      {"standard",0}
     ,{"nonStandard",1}
};
#endif
//
// CapabilityID
//

GCC_CapabilityID::GCC_CapabilityID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_CapabilityID,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_CapabilityID::operator GCC_Key &() const
#else
GCC_CapabilityID::operator GCC_Key &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_Key), PInvalidCast);
#endif
  return *(GCC_Key *)choice;
}


GCC_CapabilityID::operator const GCC_Key &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_Key), PInvalidCast);
#endif
  return *(GCC_Key *)choice;
}


BOOL GCC_CapabilityID::CreateObject()
{
  switch (tag) {
    case e_standard :
      choice = new PASN_Integer();
      choice->SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
      return TRUE;
    case e_nonStandard :
      choice = new GCC_Key();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_CapabilityID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_CapabilityID::Class()), PInvalidCast);
#endif
  return new GCC_CapabilityID(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_CapabilityClass[]={
      {"logical",0}
     ,{"unsignedMin",1}
     ,{"unsignedMax",2}
};
#endif
//
// CapabilityClass
//

GCC_CapabilityClass::GCC_CapabilityClass(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 3, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_CapabilityClass,3
#endif
)
{
}


BOOL GCC_CapabilityClass::CreateObject()
{
  switch (tag) {
    case e_logical :
      choice = new PASN_Null();
      return TRUE;
    case e_unsignedMin :
      choice = new PASN_Integer();
      choice->SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
      return TRUE;
    case e_unsignedMax :
      choice = new PASN_Integer();
      choice->SetConstraints(PASN_Object::FixedConstraint, 0, MaximumValue);
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_CapabilityClass::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_CapabilityClass::Class()), PInvalidCast);
#endif
  return new GCC_CapabilityClass(*this);
}


//
// EntityID
//

GCC_EntityID::GCC_EntityID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Integer(tag, tagClass)
{
  SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
}


GCC_EntityID & GCC_EntityID::operator=(int v)
{
  SetValue(v);
  return *this;
}


GCC_EntityID & GCC_EntityID::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_EntityID::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_EntityID::Class()), PInvalidCast);
#endif
  return new GCC_EntityID(*this);
}


//
// RegistryKey
//

GCC_RegistryKey::GCC_RegistryKey(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
{
  m_resourceID.SetConstraints(PASN_Object::FixedConstraint, 0, 64);
}


#ifndef PASN_NOPRINTON
void GCC_RegistryKey::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+13) << "sessionKey = " << setprecision(indent) << m_sessionKey << '\n';
  strm << setw(indent+13) << "resourceID = " << setprecision(indent) << m_resourceID << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryKey::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryKey), PInvalidCast);
#endif
  const GCC_RegistryKey & other = (const GCC_RegistryKey &)obj;

  Comparison result;

  if ((result = m_sessionKey.Compare(other.m_sessionKey)) != EqualTo)
    return result;
  if ((result = m_resourceID.Compare(other.m_resourceID)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryKey::GetDataLength() const
{
  PINDEX length = 0;
  length += m_sessionKey.GetObjectLength();
  length += m_resourceID.GetObjectLength();
  return length;
}


BOOL GCC_RegistryKey::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_sessionKey.Decode(strm))
    return FALSE;
  if (!m_resourceID.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryKey::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_sessionKey.Encode(strm);
  m_resourceID.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryKey::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryKey::Class()), PInvalidCast);
#endif
  return new GCC_RegistryKey(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_RegistryItem[]={
      {"channelID",0}
     ,{"tokenID",1}
     ,{"parameter",2}
     ,{"vacant",3}
};
#endif
//
// RegistryItem
//

GCC_RegistryItem::GCC_RegistryItem(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 4, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_RegistryItem,4
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_RegistryItem::operator GCC_DynamicChannelID &() const
#else
GCC_RegistryItem::operator GCC_DynamicChannelID &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_DynamicChannelID), PInvalidCast);
#endif
  return *(GCC_DynamicChannelID *)choice;
}


GCC_RegistryItem::operator const GCC_DynamicChannelID &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_DynamicChannelID), PInvalidCast);
#endif
  return *(GCC_DynamicChannelID *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_RegistryItem::operator GCC_DynamicTokenID &() const
#else
GCC_RegistryItem::operator GCC_DynamicTokenID &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_DynamicTokenID), PInvalidCast);
#endif
  return *(GCC_DynamicTokenID *)choice;
}


GCC_RegistryItem::operator const GCC_DynamicTokenID &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_DynamicTokenID), PInvalidCast);
#endif
  return *(GCC_DynamicTokenID *)choice;
}


BOOL GCC_RegistryItem::CreateObject()
{
  switch (tag) {
    case e_channelID :
      choice = new GCC_DynamicChannelID();
      return TRUE;
    case e_tokenID :
      choice = new GCC_DynamicTokenID();
      return TRUE;
    case e_parameter :
      choice = new PASN_OctetString();
      choice->SetConstraints(PASN_Object::FixedConstraint, 0, 64);
      return TRUE;
    case e_vacant :
      choice = new PASN_Null();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_RegistryItem::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryItem::Class()), PInvalidCast);
#endif
  return new GCC_RegistryItem(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_RegistryEntryOwner[]={
      {"owned",0}
     ,{"notOwned",1}
};
#endif
//
// RegistryEntryOwner
//

GCC_RegistryEntryOwner::GCC_RegistryEntryOwner(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 2, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_RegistryEntryOwner,2
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_RegistryEntryOwner::operator GCC_RegistryEntryOwner_owned &() const
#else
GCC_RegistryEntryOwner::operator GCC_RegistryEntryOwner_owned &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_RegistryEntryOwner_owned), PInvalidCast);
#endif
  return *(GCC_RegistryEntryOwner_owned *)choice;
}


GCC_RegistryEntryOwner::operator const GCC_RegistryEntryOwner_owned &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_RegistryEntryOwner_owned), PInvalidCast);
#endif
  return *(GCC_RegistryEntryOwner_owned *)choice;
}


BOOL GCC_RegistryEntryOwner::CreateObject()
{
  switch (tag) {
    case e_owned :
      choice = new GCC_RegistryEntryOwner_owned();
      return TRUE;
    case e_notOwned :
      choice = new PASN_Null();
      return TRUE;
  }

  choice = NULL;
  return FALSE;
}


PObject * GCC_RegistryEntryOwner::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryEntryOwner::Class()), PInvalidCast);
#endif
  return new GCC_RegistryEntryOwner(*this);
}


#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_RegistryModificationRights[]={
        {"owner",0}
       ,{"session",1}
       ,{"public",2}
};
#endif
//
// RegistryModificationRights
//

GCC_RegistryModificationRights::GCC_RegistryModificationRights(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Enumeration(tag, tagClass, 2, FALSE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_RegistryModificationRights,3
#endif
    )
{
}


GCC_RegistryModificationRights & GCC_RegistryModificationRights::operator=(unsigned v)
{
  SetValue(v);
  return *this;
}


PObject * GCC_RegistryModificationRights::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryModificationRights::Class()), PInvalidCast);
#endif
  return new GCC_RegistryModificationRights(*this);
}


//
// UserIDIndication
//

GCC_UserIDIndication::GCC_UserIDIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_UserIDIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_UserIDIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_UserIDIndication), PInvalidCast);
#endif
  const GCC_UserIDIndication & other = (const GCC_UserIDIndication &)obj;

  Comparison result;

  if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_UserIDIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_tag.GetObjectLength();
  return length;
}


BOOL GCC_UserIDIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_tag.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_UserIDIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_tag.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_UserIDIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_UserIDIndication::Class()), PInvalidCast);
#endif
  return new GCC_UserIDIndication(*this);
}


//
// ConferenceQueryRequest
//

GCC_ConferenceQueryRequest::GCC_ConferenceQueryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceQueryRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "nodeType = " << setprecision(indent) << m_nodeType << '\n';
  if (HasOptionalField(e_asymmetryIndicator))
    strm << setw(indent+21) << "asymmetryIndicator = " << setprecision(indent) << m_asymmetryIndicator << '\n';
  if (HasOptionalField(e_userData))
    strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceQueryRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceQueryRequest), PInvalidCast);
#endif
  const GCC_ConferenceQueryRequest & other = (const GCC_ConferenceQueryRequest &)obj;

  Comparison result;

  if ((result = m_nodeType.Compare(other.m_nodeType)) != EqualTo)
    return result;
  if ((result = m_asymmetryIndicator.Compare(other.m_asymmetryIndicator)) != EqualTo)
    return result;
  if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceQueryRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_nodeType.GetObjectLength();
  if (HasOptionalField(e_asymmetryIndicator))
    length += m_asymmetryIndicator.GetObjectLength();
  if (HasOptionalField(e_userData))
    length += m_userData.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceQueryRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_nodeType.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_asymmetryIndicator) && !m_asymmetryIndicator.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceQueryRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_nodeType.Encode(strm);
  if (HasOptionalField(e_asymmetryIndicator))
    m_asymmetryIndicator.Encode(strm);
  if (HasOptionalField(e_userData))
    m_userData.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceQueryRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceQueryRequest::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceQueryRequest(*this);
}


//
// ConferenceJoinRequest
//

GCC_ConferenceJoinRequest::GCC_ConferenceJoinRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 7, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceJoinRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_conferenceName))
    strm << setw(indent+17) << "conferenceName = " << setprecision(indent) << m_conferenceName << '\n';
  if (HasOptionalField(e_conferenceNameModifier))
    strm << setw(indent+25) << "conferenceNameModifier = " << setprecision(indent) << m_conferenceNameModifier << '\n';
  if (HasOptionalField(e_tag))
    strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  if (HasOptionalField(e_password))
    strm << setw(indent+11) << "password = " << setprecision(indent) << m_password << '\n';
  if (HasOptionalField(e_convenerPassword))
    strm << setw(indent+19) << "convenerPassword = " << setprecision(indent) << m_convenerPassword << '\n';
  if (HasOptionalField(e_callerIdentifier))
    strm << setw(indent+19) << "callerIdentifier = " << setprecision(indent) << m_callerIdentifier << '\n';
  if (HasOptionalField(e_userData))
    strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceJoinRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceJoinRequest), PInvalidCast);
#endif
  const GCC_ConferenceJoinRequest & other = (const GCC_ConferenceJoinRequest &)obj;

  Comparison result;

  if ((result = m_conferenceName.Compare(other.m_conferenceName)) != EqualTo)
    return result;
  if ((result = m_conferenceNameModifier.Compare(other.m_conferenceNameModifier)) != EqualTo)
    return result;
  if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
    return result;
  if ((result = m_password.Compare(other.m_password)) != EqualTo)
    return result;
  if ((result = m_convenerPassword.Compare(other.m_convenerPassword)) != EqualTo)
    return result;
  if ((result = m_callerIdentifier.Compare(other.m_callerIdentifier)) != EqualTo)
    return result;
  if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceJoinRequest::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_conferenceName))
    length += m_conferenceName.GetObjectLength();
  if (HasOptionalField(e_conferenceNameModifier))
    length += m_conferenceNameModifier.GetObjectLength();
  if (HasOptionalField(e_tag))
    length += m_tag.GetObjectLength();
  if (HasOptionalField(e_password))
    length += m_password.GetObjectLength();
  if (HasOptionalField(e_convenerPassword))
    length += m_convenerPassword.GetObjectLength();
  if (HasOptionalField(e_callerIdentifier))
    length += m_callerIdentifier.GetObjectLength();
  if (HasOptionalField(e_userData))
    length += m_userData.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceJoinRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (HasOptionalField(e_conferenceName) && !m_conferenceName.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_conferenceNameModifier) && !m_conferenceNameModifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_tag) && !m_tag.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_password) && !m_password.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_convenerPassword) && !m_convenerPassword.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_callerIdentifier) && !m_callerIdentifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceJoinRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  if (HasOptionalField(e_conferenceName))
    m_conferenceName.Encode(strm);
  if (HasOptionalField(e_conferenceNameModifier))
    m_conferenceNameModifier.Encode(strm);
  if (HasOptionalField(e_tag))
    m_tag.Encode(strm);
  if (HasOptionalField(e_password))
    m_password.Encode(strm);
  if (HasOptionalField(e_convenerPassword))
    m_convenerPassword.Encode(strm);
  if (HasOptionalField(e_callerIdentifier))
    m_callerIdentifier.Encode(strm);
  if (HasOptionalField(e_userData))
    m_userData.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceJoinRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceJoinRequest::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceJoinRequest(*this);
}


//
// ConferenceAddRequest
//

GCC_ConferenceAddRequest::GCC_ConferenceAddRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceAddRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+17) << "networkAddress = " << setprecision(indent) << m_networkAddress << '\n';
  strm << setw(indent+17) << "requestingNode = " << setprecision(indent) << m_requestingNode << '\n';
  strm << setw(indent+6) << "tag = " << setprecision(indent) << m_tag << '\n';
  if (HasOptionalField(e_addingMCU))
    strm << setw(indent+12) << "addingMCU = " << setprecision(indent) << m_addingMCU << '\n';
  if (HasOptionalField(e_userData))
    strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceAddRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceAddRequest), PInvalidCast);
#endif
  const GCC_ConferenceAddRequest & other = (const GCC_ConferenceAddRequest &)obj;

  Comparison result;

  if ((result = m_networkAddress.Compare(other.m_networkAddress)) != EqualTo)
    return result;
  if ((result = m_requestingNode.Compare(other.m_requestingNode)) != EqualTo)
    return result;
  if ((result = m_tag.Compare(other.m_tag)) != EqualTo)
    return result;
  if ((result = m_addingMCU.Compare(other.m_addingMCU)) != EqualTo)
    return result;
  if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceAddRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_networkAddress.GetObjectLength();
  length += m_requestingNode.GetObjectLength();
  length += m_tag.GetObjectLength();
  if (HasOptionalField(e_addingMCU))
    length += m_addingMCU.GetObjectLength();
  if (HasOptionalField(e_userData))
    length += m_userData.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceAddRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_networkAddress.Decode(strm))
    return FALSE;
  if (!m_requestingNode.Decode(strm))
    return FALSE;
  if (!m_tag.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_addingMCU) && !m_addingMCU.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceAddRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_networkAddress.Encode(strm);
  m_requestingNode.Encode(strm);
  m_tag.Encode(strm);
  if (HasOptionalField(e_addingMCU))
    m_addingMCU.Encode(strm);
  if (HasOptionalField(e_userData))
    m_userData.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceAddRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceAddRequest::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceAddRequest(*this);
}


//
// ConferenceLockRequest
//

GCC_ConferenceLockRequest::GCC_ConferenceLockRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceLockRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PINDEX GCC_ConferenceLockRequest::GetDataLength() const
{
  PINDEX length = 0;
  return length;
}


BOOL GCC_ConferenceLockRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;


  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceLockRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);


  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceLockRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceLockRequest::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceLockRequest(*this);
}


//
// ConferenceLockIndication
//

GCC_ConferenceLockIndication::GCC_ConferenceLockIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceLockIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PINDEX GCC_ConferenceLockIndication::GetDataLength() const
{
  PINDEX length = 0;
  return length;
}


BOOL GCC_ConferenceLockIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;


  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceLockIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);


  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceLockIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceLockIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceLockIndication(*this);
}


//
// ConferenceUnlockRequest
//

GCC_ConferenceUnlockRequest::GCC_ConferenceUnlockRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceUnlockRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PINDEX GCC_ConferenceUnlockRequest::GetDataLength() const
{
  PINDEX length = 0;
  return length;
}


BOOL GCC_ConferenceUnlockRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;


  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceUnlockRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);


  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceUnlockRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceUnlockRequest::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceUnlockRequest(*this);
}


//
// ConferenceUnlockIndication
//

GCC_ConferenceUnlockIndication::GCC_ConferenceUnlockIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceUnlockIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PINDEX GCC_ConferenceUnlockIndication::GetDataLength() const
{
  PINDEX length = 0;
  return length;
}


BOOL GCC_ConferenceUnlockIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;


  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceUnlockIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);


  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceUnlockIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceUnlockIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceUnlockIndication(*this);
}


//
// RegistryRegisterChannelRequest
//

GCC_RegistryRegisterChannelRequest::GCC_RegistryRegisterChannelRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryRegisterChannelRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent+12) << "channelID = " << setprecision(indent) << m_channelID << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryRegisterChannelRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryRegisterChannelRequest), PInvalidCast);
#endif
  const GCC_RegistryRegisterChannelRequest & other = (const GCC_RegistryRegisterChannelRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;
  if ((result = m_channelID.Compare(other.m_channelID)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryRegisterChannelRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  length += m_channelID.GetObjectLength();
  return length;
}


BOOL GCC_RegistryRegisterChannelRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;
  if (!m_channelID.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryRegisterChannelRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);
  m_channelID.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryRegisterChannelRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryRegisterChannelRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryRegisterChannelRequest(*this);
}


//
// RegistryAssignTokenRequest
//

GCC_RegistryAssignTokenRequest::GCC_RegistryAssignTokenRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryAssignTokenRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryAssignTokenRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryAssignTokenRequest), PInvalidCast);
#endif
  const GCC_RegistryAssignTokenRequest & other = (const GCC_RegistryAssignTokenRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryAssignTokenRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  return length;
}


BOOL GCC_RegistryAssignTokenRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryAssignTokenRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryAssignTokenRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryAssignTokenRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryAssignTokenRequest(*this);
}


//
// RegistrySetParameterRequest
//

GCC_RegistrySetParameterRequest::GCC_RegistrySetParameterRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
  m_parameter.SetConstraints(PASN_Object::FixedConstraint, 0, 64);
}


#ifndef PASN_NOPRINTON
void GCC_RegistrySetParameterRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent+12) << "parameter = " << setprecision(indent) << m_parameter << '\n';
  if (HasOptionalField(e_modificationRights))
    strm << setw(indent+21) << "modificationRights = " << setprecision(indent) << m_modificationRights << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistrySetParameterRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistrySetParameterRequest), PInvalidCast);
#endif
  const GCC_RegistrySetParameterRequest & other = (const GCC_RegistrySetParameterRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;
  if ((result = m_parameter.Compare(other.m_parameter)) != EqualTo)
    return result;
  if ((result = m_modificationRights.Compare(other.m_modificationRights)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistrySetParameterRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  length += m_parameter.GetObjectLength();
  if (HasOptionalField(e_modificationRights))
    length += m_modificationRights.GetObjectLength();
  return length;
}


BOOL GCC_RegistrySetParameterRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;
  if (!m_parameter.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_modificationRights) && !m_modificationRights.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistrySetParameterRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);
  m_parameter.Encode(strm);
  if (HasOptionalField(e_modificationRights))
    m_modificationRights.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistrySetParameterRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistrySetParameterRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistrySetParameterRequest(*this);
}


//
// RegistryRetrieveEntryRequest
//

GCC_RegistryRetrieveEntryRequest::GCC_RegistryRetrieveEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryRetrieveEntryRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryRetrieveEntryRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryRetrieveEntryRequest), PInvalidCast);
#endif
  const GCC_RegistryRetrieveEntryRequest & other = (const GCC_RegistryRetrieveEntryRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryRetrieveEntryRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  return length;
}


BOOL GCC_RegistryRetrieveEntryRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryRetrieveEntryRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryRetrieveEntryRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryRetrieveEntryRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryRetrieveEntryRequest(*this);
}


//
// RegistryDeleteEntryRequest
//

GCC_RegistryDeleteEntryRequest::GCC_RegistryDeleteEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryDeleteEntryRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryDeleteEntryRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryDeleteEntryRequest), PInvalidCast);
#endif
  const GCC_RegistryDeleteEntryRequest & other = (const GCC_RegistryDeleteEntryRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryDeleteEntryRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  return length;
}


BOOL GCC_RegistryDeleteEntryRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryDeleteEntryRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryDeleteEntryRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryDeleteEntryRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryDeleteEntryRequest(*this);
}


//
// RegistryMonitorEntryRequest
//

GCC_RegistryMonitorEntryRequest::GCC_RegistryMonitorEntryRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryMonitorEntryRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryMonitorEntryRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryMonitorEntryRequest), PInvalidCast);
#endif
  const GCC_RegistryMonitorEntryRequest & other = (const GCC_RegistryMonitorEntryRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryMonitorEntryRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_key.GetObjectLength();
  return length;
}


BOOL GCC_RegistryMonitorEntryRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_key.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryMonitorEntryRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_key.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryMonitorEntryRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryMonitorEntryRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryMonitorEntryRequest(*this);
}


//
// RegistryMonitorEntryIndication
//

GCC_RegistryMonitorEntryIndication::GCC_RegistryMonitorEntryIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_RegistryMonitorEntryIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+6) << "key = " << setprecision(indent) << m_key << '\n';
  strm << setw(indent+7) << "item = " << setprecision(indent) << m_item << '\n';
  strm << setw(indent+8) << "owner = " << setprecision(indent) << m_owner << '\n';
  if (HasOptionalField(e_modificationRights))
    strm << setw(indent+21) << "modificationRights = " << setprecision(indent) << m_modificationRights << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryMonitorEntryIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryMonitorEntryIndication), PInvalidCast);
#endif
  const GCC_RegistryMonitorEntryIndication & other = (const GCC_RegistryMonitorEntryIndication &)obj;

  Comparison result;

  if ((result = m_key.Compare(other.m_key)) != EqualTo)
    return result;
  if ((result = m_item.Compare(other.m_item)) != EqualTo)
    return result;
  if ((result = m_owner.Compare(other.m_owner)) != EqualTo)
    return result;
  if ((result = m_modificationRights.Compare(other.m_modificationRights)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryMonitorEntryIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_key.GetObjectLength();
  length += m_item.GetObjectLength();
  length += m_owner.GetObjectLength();
  if (HasOptionalField(e_modificationRights))
    length += m_modificationRights.GetObjectLength();
  return length;
}


BOOL GCC_RegistryMonitorEntryIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_key.Decode(strm))
    return FALSE;
  if (!m_item.Decode(strm))
    return FALSE;
  if (!m_owner.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_modificationRights) && !m_modificationRights.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryMonitorEntryIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_key.Encode(strm);
  m_item.Encode(strm);
  m_owner.Encode(strm);
  if (HasOptionalField(e_modificationRights))
    m_modificationRights.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryMonitorEntryIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryMonitorEntryIndication::Class()), PInvalidCast);
#endif
  return new GCC_RegistryMonitorEntryIndication(*this);
}


//
// RegistryAllocateHandleRequest
//

GCC_RegistryAllocateHandleRequest::GCC_RegistryAllocateHandleRequest(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
  m_numberOfHandles.SetConstraints(PASN_Object::FixedConstraint, 1, 1024);
}


#ifndef PASN_NOPRINTON
void GCC_RegistryAllocateHandleRequest::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "entityID = " << setprecision(indent) << m_entityID << '\n';
  strm << setw(indent+18) << "numberOfHandles = " << setprecision(indent) << m_numberOfHandles << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_RegistryAllocateHandleRequest::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_RegistryAllocateHandleRequest), PInvalidCast);
#endif
  const GCC_RegistryAllocateHandleRequest & other = (const GCC_RegistryAllocateHandleRequest &)obj;

  Comparison result;

  if ((result = m_entityID.Compare(other.m_entityID)) != EqualTo)
    return result;
  if ((result = m_numberOfHandles.Compare(other.m_numberOfHandles)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_RegistryAllocateHandleRequest::GetDataLength() const
{
  PINDEX length = 0;
  length += m_entityID.GetObjectLength();
  length += m_numberOfHandles.GetObjectLength();
  return length;
}


BOOL GCC_RegistryAllocateHandleRequest::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_entityID.Decode(strm))
    return FALSE;
  if (!m_numberOfHandles.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_RegistryAllocateHandleRequest::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_entityID.Encode(strm);
  m_numberOfHandles.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_RegistryAllocateHandleRequest::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_RegistryAllocateHandleRequest::Class()), PInvalidCast);
#endif
  return new GCC_RegistryAllocateHandleRequest(*this);
}


//
// ConductorAssignIndication
//

GCC_ConductorAssignIndication::GCC_ConductorAssignIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConductorAssignIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+17) << "conductingNode = " << setprecision(indent) << m_conductingNode << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConductorAssignIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConductorAssignIndication), PInvalidCast);
#endif
  const GCC_ConductorAssignIndication & other = (const GCC_ConductorAssignIndication &)obj;

  Comparison result;

  if ((result = m_conductingNode.Compare(other.m_conductingNode)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConductorAssignIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_conductingNode.GetObjectLength();
  return length;
}


BOOL GCC_ConductorAssignIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_conductingNode.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConductorAssignIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_conductingNode.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConductorAssignIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConductorAssignIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConductorAssignIndication(*this);
}


//
// ConductorReleaseIndication
//

GCC_ConductorReleaseIndication::GCC_ConductorReleaseIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConductorReleaseIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PINDEX GCC_ConductorReleaseIndication::GetDataLength() const
{
  PINDEX length = 0;
  return length;
}


BOOL GCC_ConductorReleaseIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;


  return UnknownExtensionsDecode(strm);
}


void GCC_ConductorReleaseIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);


  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConductorReleaseIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConductorReleaseIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConductorReleaseIndication(*this);
}


//
// ConductorPermissionAskIndication
//

GCC_ConductorPermissionAskIndication::GCC_ConductorPermissionAskIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConductorPermissionAskIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+12) << "grantFlag = " << setprecision(indent) << m_grantFlag << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConductorPermissionAskIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConductorPermissionAskIndication), PInvalidCast);
#endif
  const GCC_ConductorPermissionAskIndication & other = (const GCC_ConductorPermissionAskIndication &)obj;

  Comparison result;

  if ((result = m_grantFlag.Compare(other.m_grantFlag)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConductorPermissionAskIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_grantFlag.GetObjectLength();
  return length;
}


BOOL GCC_ConductorPermissionAskIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_grantFlag.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConductorPermissionAskIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_grantFlag.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConductorPermissionAskIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConductorPermissionAskIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConductorPermissionAskIndication(*this);
}


//
// ConferenceTimeRemainingIndication
//

GCC_ConferenceTimeRemainingIndication::GCC_ConferenceTimeRemainingIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceTimeRemainingIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+16) << "timeRemaining = " << setprecision(indent) << m_timeRemaining << '\n';
  if (HasOptionalField(e_nodeID))
    strm << setw(indent+9) << "nodeID = " << setprecision(indent) << m_nodeID << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceTimeRemainingIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceTimeRemainingIndication), PInvalidCast);
#endif
  const GCC_ConferenceTimeRemainingIndication & other = (const GCC_ConferenceTimeRemainingIndication &)obj;

  Comparison result;

  if ((result = m_timeRemaining.Compare(other.m_timeRemaining)) != EqualTo)
    return result;
  if ((result = m_nodeID.Compare(other.m_nodeID)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceTimeRemainingIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_timeRemaining.GetObjectLength();
  if (HasOptionalField(e_nodeID))
    length += m_nodeID.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceTimeRemainingIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_timeRemaining.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_nodeID) && !m_nodeID.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceTimeRemainingIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_timeRemaining.Encode(strm);
  if (HasOptionalField(e_nodeID))
    m_nodeID.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceTimeRemainingIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceTimeRemainingIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceTimeRemainingIndication(*this);
}


//
// ConferenceTimeInquireIndication
//

GCC_ConferenceTimeInquireIndication::GCC_ConferenceTimeInquireIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceTimeInquireIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+23) << "nodeSpecificTimeFlag = " << setprecision(indent) << m_nodeSpecificTimeFlag << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceTimeInquireIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceTimeInquireIndication), PInvalidCast);
#endif
  const GCC_ConferenceTimeInquireIndication & other = (const GCC_ConferenceTimeInquireIndication &)obj;

  Comparison result;

  if ((result = m_nodeSpecificTimeFlag.Compare(other.m_nodeSpecificTimeFlag)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceTimeInquireIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_nodeSpecificTimeFlag.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceTimeInquireIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_nodeSpecificTimeFlag.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceTimeInquireIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_nodeSpecificTimeFlag.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceTimeInquireIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceTimeInquireIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceTimeInquireIndication(*this);
}


//
// ConferenceTimeExtendIndication
//

GCC_ConferenceTimeExtendIndication::GCC_ConferenceTimeExtendIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceTimeExtendIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+15) << "timeToExtend = " << setprecision(indent) << m_timeToExtend << '\n';
  strm << setw(indent+23) << "nodeSpecificTimeFlag = " << setprecision(indent) << m_nodeSpecificTimeFlag << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceTimeExtendIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceTimeExtendIndication), PInvalidCast);
#endif
  const GCC_ConferenceTimeExtendIndication & other = (const GCC_ConferenceTimeExtendIndication &)obj;

  Comparison result;

  if ((result = m_timeToExtend.Compare(other.m_timeToExtend)) != EqualTo)
    return result;
  if ((result = m_nodeSpecificTimeFlag.Compare(other.m_nodeSpecificTimeFlag)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceTimeExtendIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_timeToExtend.GetObjectLength();
  length += m_nodeSpecificTimeFlag.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceTimeExtendIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_timeToExtend.Decode(strm))
    return FALSE;
  if (!m_nodeSpecificTimeFlag.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceTimeExtendIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_timeToExtend.Encode(strm);
  m_nodeSpecificTimeFlag.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceTimeExtendIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceTimeExtendIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceTimeExtendIndication(*this);
}


//
// ConferenceAssistanceIndication
//

GCC_ConferenceAssistanceIndication::GCC_ConferenceAssistanceIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConferenceAssistanceIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_userData))
    strm << setw(indent+11) << "userData = " << setprecision(indent) << m_userData << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConferenceAssistanceIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConferenceAssistanceIndication), PInvalidCast);
#endif
  const GCC_ConferenceAssistanceIndication & other = (const GCC_ConferenceAssistanceIndication &)obj;

  Comparison result;

  if ((result = m_userData.Compare(other.m_userData)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConferenceAssistanceIndication::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_userData))
    length += m_userData.GetObjectLength();
  return length;
}


BOOL GCC_ConferenceAssistanceIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (HasOptionalField(e_userData) && !m_userData.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConferenceAssistanceIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  if (HasOptionalField(e_userData))
    m_userData.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConferenceAssistanceIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConferenceAssistanceIndication::Class()), PInvalidCast);
#endif
  return new GCC_ConferenceAssistanceIndication(*this);
}


//
// TextMessageIndication
//

GCC_TextMessageIndication::GCC_TextMessageIndication(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_TextMessageIndication::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+10) << "message = " << setprecision(indent) << m_message << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_TextMessageIndication::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_TextMessageIndication), PInvalidCast);
#endif
  const GCC_TextMessageIndication & other = (const GCC_TextMessageIndication &)obj;

  Comparison result;

  if ((result = m_message.Compare(other.m_message)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_TextMessageIndication::GetDataLength() const
{
  PINDEX length = 0;
  length += m_message.GetObjectLength();
  return length;
}


BOOL GCC_TextMessageIndication::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_message.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_TextMessageIndication::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_message.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_TextMessageIndication::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_TextMessageIndication::Class()), PInvalidCast);
#endif
  return new GCC_TextMessageIndication(*this);
}


//
// NonStandardPDU
//

GCC_NonStandardPDU::GCC_NonStandardPDU(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_NonStandardPDU::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_NonStandardPDU::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_NonStandardPDU), PInvalidCast);
#endif
  const GCC_NonStandardPDU & other = (const GCC_NonStandardPDU &)obj;

  Comparison result;

  if ((result = m_data.Compare(other.m_data)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_NonStandardPDU::GetDataLength() const
{
  PINDEX length = 0;
  length += m_data.GetObjectLength();
  return length;
}


BOOL GCC_NonStandardPDU::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_data.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_NonStandardPDU::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_data.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_NonStandardPDU::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_NonStandardPDU::Class()), PInvalidCast);
#endif
  return new GCC_NonStandardPDU(*this);
}


//
// ConnectData
//

GCC_ConnectData::GCC_ConnectData(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
{
}


#ifndef PASN_NOPRINTON
void GCC_ConnectData::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+17) << "t124Identifier = " << setprecision(indent) << m_t124Identifier << '\n';
  strm << setw(indent+13) << "connectPDU = " << setprecision(indent) << m_connectPDU << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


PObject::Comparison GCC_ConnectData::Compare(const PObject & obj) const
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(&obj, GCC_ConnectData), PInvalidCast);
#endif
  const GCC_ConnectData & other = (const GCC_ConnectData &)obj;

  Comparison result;

  if ((result = m_t124Identifier.Compare(other.m_t124Identifier)) != EqualTo)
    return result;
  if ((result = m_connectPDU.Compare(other.m_connectPDU)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX GCC_ConnectData::GetDataLength() const
{
  PINDEX length = 0;
  length += m_t124Identifier.GetObjectLength();
  length += m_connectPDU.GetObjectLength();
  return length;
}


BOOL GCC_ConnectData::Decode(PASN_Stream & strm)
{
  if (!PreambleDecode(strm))
    return FALSE;

  if (!m_t124Identifier.Decode(strm))
    return FALSE;
  if (!m_connectPDU.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


void GCC_ConnectData::Encode(PASN_Stream & strm) const
{
  PreambleEncode(strm);

  m_t124Identifier.Encode(strm);
  m_connectPDU.Encode(strm);

  UnknownExtensionsEncode(strm);
}


PObject * GCC_ConnectData::Clone() const
{
#ifndef PASN_LEANANDMEAN
  PAssert(IsClass(GCC_ConnectData::Class()), PInvalidCast);
#endif
  return new GCC_ConnectData(*this);
}



#ifndef PASN_NOPRINTON
const static PASN_Names Names_GCC_ConnectGCCPDU[]={
      {"conferenceCreateRequest",0}
     ,{"conferenceCreateResponse",1}
     ,{"conferenceQueryRequest",2}
     ,{"conferenceQueryResponse",3}
     ,{"conferenceJoinRequest",4}
     ,{"conferenceJoinResponse",5}
     ,{"conferenceInviteRequest",6}
     ,{"conferenceInviteResponse",7}
};
#endif
//
// ConnectGCCPDU
//

GCC_ConnectGCCPDU::GCC_ConnectGCCPDU(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 8, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_GCC_ConnectGCCPDU,8
#endif
)
{
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceCreateRequest &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceCreateRequest &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceCreateRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceCreateRequest *)choice;
}


GCC_ConnectGCCPDU::operator const GCC_ConferenceCreateRequest &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceCreateRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceCreateRequest *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceCreateResponse &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceCreateResponse &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceCreateResponse), PInvalidCast);
#endif
  return *(GCC_ConferenceCreateResponse *)choice;
}


GCC_ConnectGCCPDU::operator const GCC_ConferenceCreateResponse &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceCreateResponse), PInvalidCast);
#endif
  return *(GCC_ConferenceCreateResponse *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceQueryRequest &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceQueryRequest &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceQueryRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceQueryRequest *)choice;
}


GCC_ConnectGCCPDU::operator const GCC_ConferenceQueryRequest &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceQueryRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceQueryRequest *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceQueryResponse &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceQueryResponse &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceQueryResponse), PInvalidCast);
#endif
  return *(GCC_ConferenceQueryResponse *)choice;
}


GCC_ConnectGCCPDU::operator const GCC_ConferenceQueryResponse &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceQueryResponse), PInvalidCast);
#endif
  return *(GCC_ConferenceQueryResponse *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceJoinRequest &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceJoinRequest &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceJoinRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceJoinRequest *)choice;
}


GCC_ConnectGCCPDU::operator const GCC_ConferenceJoinRequest &() const
#endif
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceJoinRequest), PInvalidCast);
#endif
  return *(GCC_ConferenceJoinRequest *)choice;
}


#if defined(__GNUC__) && __GNUC__ <= 2 && __GNUC_MINOR__ < 9
GCC_ConnectGCCPDU::operator GCC_ConferenceJoinResponse &() const
#else
GCC_ConnectGCCPDU::operator GCC_ConferenceJoinResponse &()
{
#ifndef PASN_LEANANDMEAN
  PAssert(PIsDescendant(PAssertNULL(choice), GCC_ConferenceJoinResponse), PInvalidCast);
#endif
  return *(GCC_ConferenceJoinResponse *)choice;
}