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

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

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

#define new PNEW


#if ! H323_DISABLE_H225

//
// ArrayOf_EnumeratedParameter
//

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


PASN_Object * H225_ArrayOf_EnumeratedParameter::CreateObject() const
{
  return new H225_EnumeratedParameter;
}


H225_EnumeratedParameter & H225_ArrayOf_EnumeratedParameter::operator[](PINDEX i) const
{
  return (H225_EnumeratedParameter &)array[i];
}


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


//
// RTPSession_associatedSessionIds
//

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


PASN_Object * H225_RTPSession_associatedSessionIds::CreateObject() const
{
  PASN_Integer * obj = new PASN_Integer;
  obj->SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  return obj;
}


PASN_Integer & H225_RTPSession_associatedSessionIds::operator[](PINDEX i) const
{
  return (PASN_Integer &)array[i];
}


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


//
// ArrayOf_AdmissionConfirm
//

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


PASN_Object * H225_ArrayOf_AdmissionConfirm::CreateObject() const
{
  return new H225_AdmissionConfirm;
}


H225_AdmissionConfirm & H225_ArrayOf_AdmissionConfirm::operator[](PINDEX i) const
{
  return (H225_AdmissionConfirm &)array[i];
}


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


//
// ArrayOf_Endpoint
//

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


PASN_Object * H225_ArrayOf_Endpoint::CreateObject() const
{
  return new H225_Endpoint;
}


H225_Endpoint & H225_ArrayOf_Endpoint::operator[](PINDEX i) const
{
  return (H225_Endpoint &)array[i];
}


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


//
// ArrayOf_AuthenticationMechanism
//

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


PASN_Object * H225_ArrayOf_AuthenticationMechanism::CreateObject() const
{
  return new H235_AuthenticationMechanism;
}


H235_AuthenticationMechanism & H225_ArrayOf_AuthenticationMechanism::operator[](PINDEX i) const
{
  return (H235_AuthenticationMechanism &)array[i];
}


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


//
// ArrayOf_PASN_ObjectId
//

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


PASN_Object * H225_ArrayOf_PASN_ObjectId::CreateObject() const
{
  return new PASN_ObjectId;
}


PASN_ObjectId & H225_ArrayOf_PASN_ObjectId::operator[](PINDEX i) const
{
  return (PASN_ObjectId &)array[i];
}


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


//
// ArrayOf_IntegrityMechanism
//

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


PASN_Object * H225_ArrayOf_IntegrityMechanism::CreateObject() const
{
  return new H225_IntegrityMechanism;
}


H225_IntegrityMechanism & H225_ArrayOf_IntegrityMechanism::operator[](PINDEX i) const
{
  return (H225_IntegrityMechanism &)array[i];
}


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


//
// ArrayOf_AddressPattern
//

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


PASN_Object * H225_ArrayOf_AddressPattern::CreateObject() const
{
  return new H225_AddressPattern;
}


H225_AddressPattern & H225_ArrayOf_AddressPattern::operator[](PINDEX i) const
{
  return (H225_AddressPattern &)array[i];
}


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


//
// ArrayOf_H248PackagesDescriptor
//

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


PASN_Object * H225_ArrayOf_H248PackagesDescriptor::CreateObject() const
{
  return new H225_H248PackagesDescriptor;
}


H225_H248PackagesDescriptor & H225_ArrayOf_H248PackagesDescriptor::operator[](PINDEX i) const
{
  return (H225_H248PackagesDescriptor &)array[i];
}


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


//
// RegistrationRequest_language
//

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


PASN_Object * H225_RegistrationRequest_language::CreateObject() const
{
  PASN_IA5String * obj = new PASN_IA5String;
  obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
  return obj;
}


PASN_IA5String & H225_RegistrationRequest_language::operator[](PINDEX i) const
{
  return (PASN_IA5String &)array[i];
}


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


//
// ArrayOf_RasUsageSpecification
//

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


PASN_Object * H225_ArrayOf_RasUsageSpecification::CreateObject() const
{
  return new H225_RasUsageSpecification;
}


H225_RasUsageSpecification & H225_ArrayOf_RasUsageSpecification::operator[](PINDEX i) const
{
  return (H225_RasUsageSpecification &)array[i];
}


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


//
// RegistrationRejectReason_invalidTerminalAliases
//

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


#ifndef PASN_NOPRINTON
void H225_RegistrationRejectReason_invalidTerminalAliases::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_terminalAlias))
    strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
  if (HasOptionalField(e_terminalAliasPattern))
    strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
  if (HasOptionalField(e_supportedPrefixes))
    strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
    return result;
  if ((result = m_terminalAliasPattern.Compare(other.m_terminalAliasPattern)) != EqualTo)
    return result;
  if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_RegistrationRejectReason_invalidTerminalAliases::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_terminalAlias))
    length += m_terminalAlias.GetObjectLength();
  if (HasOptionalField(e_terminalAliasPattern))
    length += m_terminalAliasPattern.GetObjectLength();
  if (HasOptionalField(e_supportedPrefixes))
    length += m_supportedPrefixes.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_terminalAliasPattern) && !m_terminalAliasPattern.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_supportedPrefixes) && !m_supportedPrefixes.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_terminalAlias))
    m_terminalAlias.Encode(strm);
  if (HasOptionalField(e_terminalAliasPattern))
    m_terminalAliasPattern.Encode(strm);
  if (HasOptionalField(e_supportedPrefixes))
    m_supportedPrefixes.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// ArrayOf_QOSCapability
//

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


PASN_Object * H225_ArrayOf_QOSCapability::CreateObject() const
{
  return new H245_QOSCapability;
}


H245_QOSCapability & H225_ArrayOf_QOSCapability::operator[](PINDEX i) const
{
  return (H245_QOSCapability &)array[i];
}


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


//
// AdmissionConfirm_language
//

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


PASN_Object * H225_AdmissionConfirm_language::CreateObject() const
{
  PASN_IA5String * obj = new PASN_IA5String;
  obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
  return obj;
}


PASN_IA5String & H225_AdmissionConfirm_language::operator[](PINDEX i) const
{
  return (PASN_IA5String &)array[i];
}


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


//
// ArrayOf_PartyNumber
//

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


PASN_Object * H225_ArrayOf_PartyNumber::CreateObject() const
{
  return new H225_PartyNumber;
}


H225_PartyNumber & H225_ArrayOf_PartyNumber::operator[](PINDEX i) const
{
  return (H225_PartyNumber &)array[i];
}


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


//
// ArrayOf_BandwidthDetails
//

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


PASN_Object * H225_ArrayOf_BandwidthDetails::CreateObject() const
{
  return new H225_BandwidthDetails;
}


H225_BandwidthDetails & H225_ArrayOf_BandwidthDetails::operator[](PINDEX i) const
{
  return (H225_BandwidthDetails &)array[i];
}


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


//
// LocationRequest_language
//

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


PASN_Object * H225_LocationRequest_language::CreateObject() const
{
  PASN_IA5String * obj = new PASN_IA5String;
  obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
  return obj;
}


PASN_IA5String & H225_LocationRequest_language::operator[](PINDEX i) const
{
  return (PASN_IA5String &)array[i];
}


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


//
// InfoRequestResponse_perCallInfo
//

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


PASN_Object * H225_InfoRequestResponse_perCallInfo::CreateObject() const
{
  return new H225_InfoRequestResponse_perCallInfo_subtype;
}


H225_InfoRequestResponse_perCallInfo_subtype & H225_InfoRequestResponse_perCallInfo::operator[](PINDEX i) const
{
  return (H225_InfoRequestResponse_perCallInfo_subtype &)array[i];
}


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


//
// ServiceControlIndication_callSpecific
//

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


#ifndef PASN_NOPRINTON
void H225_ServiceControlIndication_callSpecific::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
  strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
    return result;
  if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
    return result;
  if ((result = m_answeredCall.Compare(other.m_answeredCall)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_ServiceControlIndication_callSpecific::GetDataLength() const
{
  PINDEX length = 0;
  length += m_callIdentifier.GetObjectLength();
  length += m_conferenceID.GetObjectLength();
  length += m_answeredCall.GetObjectLength();
  return length;
}


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

  if (!m_callIdentifier.Decode(strm))
    return FALSE;
  if (!m_conferenceID.Decode(strm))
    return FALSE;
  if (!m_answeredCall.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_callIdentifier.Encode(strm);
  m_conferenceID.Encode(strm);
  m_answeredCall.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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



#ifndef PASN_NOPRINTON
const static PASN_Names Names_H225_ServiceControlResponse_result[]={
      {"started",0}
     ,{"failed",1}
     ,{"stopped",2}
     ,{"notAvailable",3}
     ,{"neededFeatureNotSupported",4}
};
#endif
//
// ServiceControlResponse_result
//

H225_ServiceControlResponse_result::H225_ServiceControlResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Choice(tag, tagClass, 5, TRUE
#ifndef PASN_NOPRINTON
    ,(const PASN_Names *)Names_H225_ServiceControlResponse_result,5
#endif
)
{
}


BOOL H225_ServiceControlResponse_result::CreateObject()
{
  choice = (tag <= e_neededFeatureNotSupported) ? new PASN_Null() : NULL;
  return choice != NULL;
}


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


//
// TransportAddress_ipSourceRoute_route
//

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


PASN_Object * H225_TransportAddress_ipSourceRoute_route::CreateObject() const
{
  PASN_OctetString * obj = new PASN_OctetString;
  obj->SetConstraints(PASN_Object::FixedConstraint, 4);
  return obj;
}


PASN_OctetString & H225_TransportAddress_ipSourceRoute_route::operator[](PINDEX i) const
{
  return (PASN_OctetString &)array[i];
}


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



#ifndef PASN_NOPRINTON
const static PASN_Names Names_H225_TransportAddress_ipSourceRoute_routing[]={
      {"strict",0}
     ,{"loose",1}
};
#endif
//
// TransportAddress_ipSourceRoute_routing
//

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


BOOL H225_TransportAddress_ipSourceRoute_routing::CreateObject()
{
  choice = (tag <= e_loose) ? new PASN_Null() : NULL;
  return choice != NULL;
}


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


//
// ArrayOf_RTPSession
//

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


PASN_Object * H225_ArrayOf_RTPSession::CreateObject() const
{
  return new H225_RTPSession;
}


H225_RTPSession & H225_ArrayOf_RTPSession::operator[](PINDEX i) const
{
  return (H225_RTPSession &)array[i];
}


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


//
// ArrayOf_TransportChannelInfo
//

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


PASN_Object * H225_ArrayOf_TransportChannelInfo::CreateObject() const
{
  return new H225_TransportChannelInfo;
}


H225_TransportChannelInfo & H225_ArrayOf_TransportChannelInfo::operator[](PINDEX i) const
{
  return (H225_TransportChannelInfo &)array[i];
}


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


//
// ArrayOf_ConferenceIdentifier
//

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


PASN_Object * H225_ArrayOf_ConferenceIdentifier::CreateObject() const
{
  return new H225_ConferenceIdentifier;
}


H225_ConferenceIdentifier & H225_ArrayOf_ConferenceIdentifier::operator[](PINDEX i) const
{
  return (H225_ConferenceIdentifier &)array[i];
}


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


//
// InfoRequestResponse_perCallInfo_subtype_pdu
//

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


PASN_Object * H225_InfoRequestResponse_perCallInfo_subtype_pdu::CreateObject() const
{
  return new H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype;
}


H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype & H225_InfoRequestResponse_perCallInfo_subtype_pdu::operator[](PINDEX i) const
{
  return (H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype &)array[i];
}


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


//
// Status-UUIE
//

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


#ifndef PASN_NOPRINTON
void H225_Status_UUIE::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  if (HasOptionalField(e_tokens))
    strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  if (HasOptionalField(e_cryptoTokens))
    strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
    return result;
  if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
    return result;
  if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
    return result;
  if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_Status_UUIE::GetDataLength() const
{
  PINDEX length = 0;
  length += m_protocolIdentifier.GetObjectLength();
  length += m_callIdentifier.GetObjectLength();
  if (HasOptionalField(e_tokens))
    length += m_tokens.GetObjectLength();
  if (HasOptionalField(e_cryptoTokens))
    length += m_cryptoTokens.GetObjectLength();
  return length;
}


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

  if (!m_protocolIdentifier.Decode(strm))
    return FALSE;
  if (!m_callIdentifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_protocolIdentifier.Encode(strm);
  m_callIdentifier.Encode(strm);
  if (HasOptionalField(e_tokens))
    m_tokens.Encode(strm);
  if (HasOptionalField(e_cryptoTokens))
    m_cryptoTokens.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// StatusInquiry-UUIE
//

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


#ifndef PASN_NOPRINTON
void H225_StatusInquiry_UUIE::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  if (HasOptionalField(e_tokens))
    strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  if (HasOptionalField(e_cryptoTokens))
    strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
    return result;
  if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
    return result;
  if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
    return result;
  if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_StatusInquiry_UUIE::GetDataLength() const
{
  PINDEX length = 0;
  length += m_protocolIdentifier.GetObjectLength();
  length += m_callIdentifier.GetObjectLength();
  if (HasOptionalField(e_tokens))
    length += m_tokens.GetObjectLength();
  if (HasOptionalField(e_cryptoTokens))
    length += m_cryptoTokens.GetObjectLength();
  return length;
}


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

  if (!m_protocolIdentifier.Decode(strm))
    return FALSE;
  if (!m_callIdentifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_protocolIdentifier.Encode(strm);
  m_callIdentifier.Encode(strm);
  if (HasOptionalField(e_tokens))
    m_tokens.Encode(strm);
  if (HasOptionalField(e_cryptoTokens))
    m_cryptoTokens.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// SetupAcknowledge-UUIE
//

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


#ifndef PASN_NOPRINTON
void H225_SetupAcknowledge_UUIE::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  if (HasOptionalField(e_tokens))
    strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  if (HasOptionalField(e_cryptoTokens))
    strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
    return result;
  if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
    return result;
  if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
    return result;
  if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_SetupAcknowledge_UUIE::GetDataLength() const
{
  PINDEX length = 0;
  length += m_protocolIdentifier.GetObjectLength();
  length += m_callIdentifier.GetObjectLength();
  if (HasOptionalField(e_tokens))
    length += m_tokens.GetObjectLength();
  if (HasOptionalField(e_cryptoTokens))
    length += m_cryptoTokens.GetObjectLength();
  return length;
}


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

  if (!m_protocolIdentifier.Decode(strm))
    return FALSE;
  if (!m_callIdentifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_protocolIdentifier.Encode(strm);
  m_callIdentifier.Encode(strm);
  if (HasOptionalField(e_tokens))
    m_tokens.Encode(strm);
  if (HasOptionalField(e_cryptoTokens))
    m_cryptoTokens.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// Notify-UUIE
//

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


#ifndef PASN_NOPRINTON
void H225_Notify_UUIE::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
  strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
  if (HasOptionalField(e_tokens))
    strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
  if (HasOptionalField(e_cryptoTokens))
    strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
    return result;
  if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
    return result;
  if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
    return result;
  if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_Notify_UUIE::GetDataLength() const
{
  PINDEX length = 0;
  length += m_protocolIdentifier.GetObjectLength();
  length += m_callIdentifier.GetObjectLength();
  if (HasOptionalField(e_tokens))
    length += m_tokens.GetObjectLength();
  if (HasOptionalField(e_cryptoTokens))
    length += m_cryptoTokens.GetObjectLength();
  return length;
}


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

  if (!m_protocolIdentifier.Decode(strm))
    return FALSE;
  if (!m_callIdentifier.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_protocolIdentifier.Encode(strm);
  m_callIdentifier.Encode(strm);
  if (HasOptionalField(e_tokens))
    m_tokens.Encode(strm);
  if (HasOptionalField(e_cryptoTokens))
    m_cryptoTokens.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// VendorIdentifier
//

H225_VendorIdentifier::H225_VendorIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 2, TRUE, 1)
{
  m_productId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
  m_versionId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
}


#ifndef PASN_NOPRINTON
void H225_VendorIdentifier::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+9) << "vendor = " << setprecision(indent) << m_vendor << '\n';
  if (HasOptionalField(e_productId))
    strm << setw(indent+12) << "productId = " << setprecision(indent) << m_productId << '\n';
  if (HasOptionalField(e_versionId))
    strm << setw(indent+12) << "versionId = " << setprecision(indent) << m_versionId << '\n';
  if (HasOptionalField(e_enterpriseNumber))
    strm << setw(indent+19) << "enterpriseNumber = " << setprecision(indent) << m_enterpriseNumber << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_vendor.Compare(other.m_vendor)) != EqualTo)
    return result;
  if ((result = m_productId.Compare(other.m_productId)) != EqualTo)
    return result;
  if ((result = m_versionId.Compare(other.m_versionId)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_VendorIdentifier::GetDataLength() const
{
  PINDEX length = 0;
  length += m_vendor.GetObjectLength();
  if (HasOptionalField(e_productId))
    length += m_productId.GetObjectLength();
  if (HasOptionalField(e_versionId))
    length += m_versionId.GetObjectLength();
  return length;
}


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

  if (!m_vendor.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_productId) && !m_productId.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_versionId) && !m_versionId.Decode(strm))
    return FALSE;
  if (!KnownExtensionDecode(strm, e_enterpriseNumber, m_enterpriseNumber))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_vendor.Encode(strm);
  if (HasOptionalField(e_productId))
    m_productId.Encode(strm);
  if (HasOptionalField(e_versionId))
    m_versionId.Encode(strm);
  KnownExtensionEncode(strm, e_enterpriseNumber, m_enterpriseNumber);

  UnknownExtensionsEncode(strm);
}


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


//
// TunnelledProtocol
//

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


#ifndef PASN_NOPRINTON
void H225_TunnelledProtocol::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  if (HasOptionalField(e_subIdentifier))
    strm << setw(indent+16) << "subIdentifier = " << setprecision(indent) << m_subIdentifier << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_TunnelledProtocol::GetDataLength() const
{
  PINDEX length = 0;
  length += m_id.GetObjectLength();
  if (HasOptionalField(e_subIdentifier))
    length += m_subIdentifier.GetObjectLength();
  return length;
}


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

  if (!m_id.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_subIdentifier) && !m_subIdentifier.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_id.Encode(strm);
  if (HasOptionalField(e_subIdentifier))
    m_subIdentifier.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// NonStandardParameter
//

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


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


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


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


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

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

  return UnknownExtensionsDecode(strm);
}


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

  m_nonStandardIdentifier.Encode(strm);
  m_data.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// PublicPartyNumber
//

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


#ifndef PASN_NOPRINTON
void H225_PublicPartyNumber::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+21) << "publicTypeOfNumber = " << setprecision(indent) << m_publicTypeOfNumber << '\n';
  strm << setw(indent+21) << "publicNumberDigits = " << setprecision(indent) << m_publicNumberDigits << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_PublicPartyNumber::GetDataLength() const
{
  PINDEX length = 0;
  length += m_publicTypeOfNumber.GetObjectLength();
  length += m_publicNumberDigits.GetObjectLength();
  return length;
}


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

  if (!m_publicTypeOfNumber.Decode(strm))
    return FALSE;
  if (!m_publicNumberDigits.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_publicTypeOfNumber.Encode(strm);
  m_publicNumberDigits.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// PrivatePartyNumber
//

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


#ifndef PASN_NOPRINTON
void H225_PrivatePartyNumber::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+22) << "privateTypeOfNumber = " << setprecision(indent) << m_privateTypeOfNumber << '\n';
  strm << setw(indent+22) << "privateNumberDigits = " << setprecision(indent) << m_privateNumberDigits << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_PrivatePartyNumber::GetDataLength() const
{
  PINDEX length = 0;
  length += m_privateTypeOfNumber.GetObjectLength();
  length += m_privateNumberDigits.GetObjectLength();
  return length;
}


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

  if (!m_privateTypeOfNumber.Decode(strm))
    return FALSE;
  if (!m_privateNumberDigits.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_privateTypeOfNumber.Encode(strm);
  m_privateNumberDigits.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// ANSI-41-UIM
//

H225_ANSI_41_UIM::H225_ANSI_41_UIM(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 11, TRUE, 0)
{
  m_imsi.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  m_min.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  m_mdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  m_msisdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  m_esn.SetConstraints(PASN_Object::FixedConstraint, 16);
  m_mscid.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
  m_systemMyTypeCode.SetConstraints(PASN_Object::FixedConstraint, 1);
  m_systemAccessType.SetConstraints(PASN_Object::FixedConstraint, 1);
  m_qualificationInformationCode.SetConstraints(PASN_Object::FixedConstraint, 1);
  m_sesn.SetConstraints(PASN_Object::FixedConstraint, 16);
  m_soc.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
}


#ifndef PASN_NOPRINTON
void H225_ANSI_41_UIM::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_imsi))
    strm << setw(indent+7) << "imsi = " << setprecision(indent) << m_imsi << '\n';
  if (HasOptionalField(e_min))
    strm << setw(indent+6) << "min = " << setprecision(indent) << m_min << '\n';
  if (HasOptionalField(e_mdn))
    strm << setw(indent+6) << "mdn = " << setprecision(indent) << m_mdn << '\n';
  if (HasOptionalField(e_msisdn))
    strm << setw(indent+9) << "msisdn = " << setprecision(indent) << m_msisdn << '\n';
  if (HasOptionalField(e_esn))
    strm << setw(indent+6) << "esn = " << setprecision(indent) << m_esn << '\n';
  if (HasOptionalField(e_mscid))
    strm << setw(indent+8) << "mscid = " << setprecision(indent) << m_mscid << '\n';
  strm << setw(indent+12) << "system_id = " << setprecision(indent) << m_system_id << '\n';
  if (HasOptionalField(e_systemMyTypeCode))
    strm << setw(indent+19) << "systemMyTypeCode = " << setprecision(indent) << m_systemMyTypeCode << '\n';
  if (HasOptionalField(e_systemAccessType))
    strm << setw(indent+19) << "systemAccessType = " << setprecision(indent) << m_systemAccessType << '\n';
  if (HasOptionalField(e_qualificationInformationCode))
    strm << setw(indent+31) << "qualificationInformationCode = " << setprecision(indent) << m_qualificationInformationCode << '\n';
  if (HasOptionalField(e_sesn))
    strm << setw(indent+7) << "sesn = " << setprecision(indent) << m_sesn << '\n';
  if (HasOptionalField(e_soc))
    strm << setw(indent+6) << "soc = " << setprecision(indent) << m_soc << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_imsi.Compare(other.m_imsi)) != EqualTo)
    return result;
  if ((result = m_min.Compare(other.m_min)) != EqualTo)
    return result;
  if ((result = m_mdn.Compare(other.m_mdn)) != EqualTo)
    return result;
  if ((result = m_msisdn.Compare(other.m_msisdn)) != EqualTo)
    return result;
  if ((result = m_esn.Compare(other.m_esn)) != EqualTo)
    return result;
  if ((result = m_mscid.Compare(other.m_mscid)) != EqualTo)
    return result;
  if ((result = m_system_id.Compare(other.m_system_id)) != EqualTo)
    return result;
  if ((result = m_systemMyTypeCode.Compare(other.m_systemMyTypeCode)) != EqualTo)
    return result;
  if ((result = m_systemAccessType.Compare(other.m_systemAccessType)) != EqualTo)
    return result;
  if ((result = m_qualificationInformationCode.Compare(other.m_qualificationInformationCode)) != EqualTo)
    return result;
  if ((result = m_sesn.Compare(other.m_sesn)) != EqualTo)
    return result;
  if ((result = m_soc.Compare(other.m_soc)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_ANSI_41_UIM::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_imsi))
    length += m_imsi.GetObjectLength();
  if (HasOptionalField(e_min))
    length += m_min.GetObjectLength();
  if (HasOptionalField(e_mdn))
    length += m_mdn.GetObjectLength();
  if (HasOptionalField(e_msisdn))
    length += m_msisdn.GetObjectLength();
  if (HasOptionalField(e_esn))
    length += m_esn.GetObjectLength();
  if (HasOptionalField(e_mscid))
    length += m_mscid.GetObjectLength();
  length += m_system_id.GetObjectLength();
  if (HasOptionalField(e_systemMyTypeCode))
    length += m_systemMyTypeCode.GetObjectLength();
  if (HasOptionalField(e_systemAccessType))
    length += m_systemAccessType.GetObjectLength();
  if (HasOptionalField(e_qualificationInformationCode))
    length += m_qualificationInformationCode.GetObjectLength();
  if (HasOptionalField(e_sesn))
    length += m_sesn.GetObjectLength();
  if (HasOptionalField(e_soc))
    length += m_soc.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_imsi) && !m_imsi.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_min) && !m_min.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_mdn) && !m_mdn.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_msisdn) && !m_msisdn.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_esn) && !m_esn.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_mscid) && !m_mscid.Decode(strm))
    return FALSE;
  if (!m_system_id.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_systemMyTypeCode) && !m_systemMyTypeCode.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_systemAccessType) && !m_systemAccessType.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_qualificationInformationCode) && !m_qualificationInformationCode.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_sesn) && !m_sesn.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_soc) && !m_soc.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_imsi))
    m_imsi.Encode(strm);
  if (HasOptionalField(e_min))
    m_min.Encode(strm);
  if (HasOptionalField(e_mdn))
    m_mdn.Encode(strm);
  if (HasOptionalField(e_msisdn))
    m_msisdn.Encode(strm);
  if (HasOptionalField(e_esn))
    m_esn.Encode(strm);
  if (HasOptionalField(e_mscid))
    m_mscid.Encode(strm);
  m_system_id.Encode(strm);
  if (HasOptionalField(e_systemMyTypeCode))
    m_systemMyTypeCode.Encode(strm);
  if (HasOptionalField(e_systemAccessType))
    m_systemAccessType.Encode(strm);
  if (HasOptionalField(e_qualificationInformationCode))
    m_qualificationInformationCode.Encode(strm);
  if (HasOptionalField(e_sesn))
    m_sesn.Encode(strm);
  if (HasOptionalField(e_soc))
    m_soc.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// IsupPublicPartyNumber
//

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


#ifndef PASN_NOPRINTON
void H225_IsupPublicPartyNumber::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+18) << "natureOfAddress = " << setprecision(indent) << m_natureOfAddress << '\n';
  strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_IsupPublicPartyNumber::GetDataLength() const
{
  PINDEX length = 0;
  length += m_natureOfAddress.GetObjectLength();
  length += m_address.GetObjectLength();
  return length;
}


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

  if (!m_natureOfAddress.Decode(strm))
    return FALSE;
  if (!m_address.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_natureOfAddress.Encode(strm);
  m_address.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// IsupPrivatePartyNumber
//

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


#ifndef PASN_NOPRINTON
void H225_IsupPrivatePartyNumber::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+22) << "privateTypeOfNumber = " << setprecision(indent) << m_privateTypeOfNumber << '\n';
  strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_IsupPrivatePartyNumber::GetDataLength() const
{
  PINDEX length = 0;
  length += m_privateTypeOfNumber.GetObjectLength();
  length += m_address.GetObjectLength();
  return length;
}


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

  if (!m_privateTypeOfNumber.Decode(strm))
    return FALSE;
  if (!m_address.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_privateTypeOfNumber.Encode(strm);
  m_address.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// AlternateTransportAddresses
//

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


#ifndef PASN_NOPRINTON
void H225_AlternateTransportAddresses::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_annexE))
    strm << setw(indent+9) << "annexE = " << setprecision(indent) << m_annexE << '\n';
  if (HasOptionalField(e_sctp))
    strm << setw(indent+7) << "sctp = " << setprecision(indent) << m_sctp << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_AlternateTransportAddresses::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_annexE))
    length += m_annexE.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_annexE) && !m_annexE.Decode(strm))
    return FALSE;
  if (!KnownExtensionDecode(strm, e_sctp, m_sctp))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_annexE))
    m_annexE.Encode(strm);
  KnownExtensionEncode(strm, e_sctp, m_sctp);

  UnknownExtensionsEncode(strm);
}


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


//
// AlternateGK
//

H225_AlternateGK::H225_AlternateGK(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
  m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 127);
}


#ifndef PASN_NOPRINTON
void H225_AlternateGK::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
  if (HasOptionalField(e_gatekeeperIdentifier))
    strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
  strm << setw(indent+17) << "needToRegister = " << setprecision(indent) << m_needToRegister << '\n';
  strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
    return result;
  if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
    return result;
  if ((result = m_needToRegister.Compare(other.m_needToRegister)) != EqualTo)
    return result;
  if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_AlternateGK::GetDataLength() const
{
  PINDEX length = 0;
  length += m_rasAddress.GetObjectLength();
  if (HasOptionalField(e_gatekeeperIdentifier))
    length += m_gatekeeperIdentifier.GetObjectLength();
  length += m_needToRegister.GetObjectLength();
  length += m_priority.GetObjectLength();
  return length;
}


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

  if (!m_rasAddress.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
    return FALSE;
  if (!m_needToRegister.Decode(strm))
    return FALSE;
  if (!m_priority.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_rasAddress.Encode(strm);
  if (HasOptionalField(e_gatekeeperIdentifier))
    m_gatekeeperIdentifier.Encode(strm);
  m_needToRegister.Encode(strm);
  m_priority.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// AltGKInfo
//

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


#ifndef PASN_NOPRINTON
void H225_AltGKInfo::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
  strm << setw(indent+19) << "altGKisPermanent = " << setprecision(indent) << m_altGKisPermanent << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_AltGKInfo::GetDataLength() const
{
  PINDEX length = 0;
  length += m_alternateGatekeeper.GetObjectLength();
  length += m_altGKisPermanent.GetObjectLength();
  return length;
}


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

  if (!m_alternateGatekeeper.Decode(strm))
    return FALSE;
  if (!m_altGKisPermanent.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_alternateGatekeeper.Encode(strm);
  m_altGKisPermanent.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// SecurityCapabilities
//

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


#ifndef PASN_NOPRINTON
void H225_SecurityCapabilities::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_nonStandard))
    strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
  strm << setw(indent+13) << "encryption = " << setprecision(indent) << m_encryption << '\n';
  strm << setw(indent+16) << "authenticaton = " << setprecision(indent) << m_authenticaton << '\n';
  strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
    return result;
  if ((result = m_encryption.Compare(other.m_encryption)) != EqualTo)
    return result;
  if ((result = m_authenticaton.Compare(other.m_authenticaton)) != EqualTo)
    return result;
  if ((result = m_integrity.Compare(other.m_integrity)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_SecurityCapabilities::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_nonStandard))
    length += m_nonStandard.GetObjectLength();
  length += m_encryption.GetObjectLength();
  length += m_authenticaton.GetObjectLength();
  length += m_integrity.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
    return FALSE;
  if (!m_encryption.Decode(strm))
    return FALSE;
  if (!m_authenticaton.Decode(strm))
    return FALSE;
  if (!m_integrity.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_nonStandard))
    m_nonStandard.Encode(strm);
  m_encryption.Encode(strm);
  m_authenticaton.Encode(strm);
  m_integrity.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// QseriesOptions
//

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


#ifndef PASN_NOPRINTON
void H225_QseriesOptions::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+11) << "q932Full = " << setprecision(indent) << m_q932Full << '\n';
  strm << setw(indent+11) << "q951Full = " << setprecision(indent) << m_q951Full << '\n';
  strm << setw(indent+11) << "q952Full = " << setprecision(indent) << m_q952Full << '\n';
  strm << setw(indent+11) << "q953Full = " << setprecision(indent) << m_q953Full << '\n';
  strm << setw(indent+11) << "q955Full = " << setprecision(indent) << m_q955Full << '\n';
  strm << setw(indent+11) << "q956Full = " << setprecision(indent) << m_q956Full << '\n';
  strm << setw(indent+11) << "q957Full = " << setprecision(indent) << m_q957Full << '\n';
  strm << setw(indent+11) << "q954Info = " << setprecision(indent) << m_q954Info << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_q932Full.Compare(other.m_q932Full)) != EqualTo)
    return result;
  if ((result = m_q951Full.Compare(other.m_q951Full)) != EqualTo)
    return result;
  if ((result = m_q952Full.Compare(other.m_q952Full)) != EqualTo)
    return result;
  if ((result = m_q953Full.Compare(other.m_q953Full)) != EqualTo)
    return result;
  if ((result = m_q955Full.Compare(other.m_q955Full)) != EqualTo)
    return result;
  if ((result = m_q956Full.Compare(other.m_q956Full)) != EqualTo)
    return result;
  if ((result = m_q957Full.Compare(other.m_q957Full)) != EqualTo)
    return result;
  if ((result = m_q954Info.Compare(other.m_q954Info)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_QseriesOptions::GetDataLength() const
{
  PINDEX length = 0;
  length += m_q932Full.GetObjectLength();
  length += m_q951Full.GetObjectLength();
  length += m_q952Full.GetObjectLength();
  length += m_q953Full.GetObjectLength();
  length += m_q955Full.GetObjectLength();
  length += m_q956Full.GetObjectLength();
  length += m_q957Full.GetObjectLength();
  length += m_q954Info.GetObjectLength();
  return length;
}


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

  if (!m_q932Full.Decode(strm))
    return FALSE;
  if (!m_q951Full.Decode(strm))
    return FALSE;
  if (!m_q952Full.Decode(strm))
    return FALSE;
  if (!m_q953Full.Decode(strm))
    return FALSE;
  if (!m_q955Full.Decode(strm))
    return FALSE;
  if (!m_q956Full.Decode(strm))
    return FALSE;
  if (!m_q957Full.Decode(strm))
    return FALSE;
  if (!m_q954Info.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_q932Full.Encode(strm);
  m_q951Full.Encode(strm);
  m_q952Full.Encode(strm);
  m_q953Full.Encode(strm);
  m_q955Full.Encode(strm);
  m_q956Full.Encode(strm);
  m_q957Full.Encode(strm);
  m_q954Info.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// DataRate
//

H225_DataRate::H225_DataRate(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
{
  m_channelMultiplier.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
}


#ifndef PASN_NOPRINTON
void H225_DataRate::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_nonStandardData))
    strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  strm << setw(indent+14) << "channelRate = " << setprecision(indent) << m_channelRate << '\n';
  if (HasOptionalField(e_channelMultiplier))
    strm << setw(indent+20) << "channelMultiplier = " << setprecision(indent) << m_channelMultiplier << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
    return result;
  if ((result = m_channelRate.Compare(other.m_channelRate)) != EqualTo)
    return result;
  if ((result = m_channelMultiplier.Compare(other.m_channelMultiplier)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_DataRate::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_nonStandardData))
    length += m_nonStandardData.GetObjectLength();
  length += m_channelRate.GetObjectLength();
  if (HasOptionalField(e_channelMultiplier))
    length += m_channelMultiplier.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
    return FALSE;
  if (!m_channelRate.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_channelMultiplier) && !m_channelMultiplier.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_nonStandardData))
    m_nonStandardData.Encode(strm);
  m_channelRate.Encode(strm);
  if (HasOptionalField(e_channelMultiplier))
    m_channelMultiplier.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// SupportedPrefix
//

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


#ifndef PASN_NOPRINTON
void H225_SupportedPrefix::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_nonStandardData))
    strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
  strm << setw(indent+9) << "prefix = " << setprecision(indent) << m_prefix << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_SupportedPrefix::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_nonStandardData))
    length += m_nonStandardData.GetObjectLength();
  length += m_prefix.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
    return FALSE;
  if (!m_prefix.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_nonStandardData))
    m_nonStandardData.Encode(strm);
  m_prefix.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// CapacityReportingSpecification
//

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


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


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


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


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

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

  return UnknownExtensionsDecode(strm);
}


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

  m_when.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// CallCapacityInfo
//

H225_CallCapacityInfo::H225_CallCapacityInfo(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 11, TRUE, 1)
{
}


#ifndef PASN_NOPRINTON
void H225_CallCapacityInfo::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_voiceGwCallsAvailable))
    strm << setw(indent+24) << "voiceGwCallsAvailable = " << setprecision(indent) << m_voiceGwCallsAvailable << '\n';
  if (HasOptionalField(e_h310GwCallsAvailable))
    strm << setw(indent+23) << "h310GwCallsAvailable = " << setprecision(indent) << m_h310GwCallsAvailable << '\n';
  if (HasOptionalField(e_h320GwCallsAvailable))
    strm << setw(indent+23) << "h320GwCallsAvailable = " << setprecision(indent) << m_h320GwCallsAvailable << '\n';
  if (HasOptionalField(e_h321GwCallsAvailable))
    strm << setw(indent+23) << "h321GwCallsAvailable = " << setprecision(indent) << m_h321GwCallsAvailable << '\n';
  if (HasOptionalField(e_h322GwCallsAvailable))
    strm << setw(indent+23) << "h322GwCallsAvailable = " << setprecision(indent) << m_h322GwCallsAvailable << '\n';
  if (HasOptionalField(e_h323GwCallsAvailable))
    strm << setw(indent+23) << "h323GwCallsAvailable = " << setprecision(indent) << m_h323GwCallsAvailable << '\n';
  if (HasOptionalField(e_h324GwCallsAvailable))
    strm << setw(indent+23) << "h324GwCallsAvailable = " << setprecision(indent) << m_h324GwCallsAvailable << '\n';
  if (HasOptionalField(e_t120OnlyGwCallsAvailable))
    strm << setw(indent+27) << "t120OnlyGwCallsAvailable = " << setprecision(indent) << m_t120OnlyGwCallsAvailable << '\n';
  if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
    strm << setw(indent+35) << "t38FaxAnnexbOnlyGwCallsAvailable = " << setprecision(indent) << m_t38FaxAnnexbOnlyGwCallsAvailable << '\n';
  if (HasOptionalField(e_terminalCallsAvailable))
    strm << setw(indent+25) << "terminalCallsAvailable = " << setprecision(indent) << m_terminalCallsAvailable << '\n';
  if (HasOptionalField(e_mcuCallsAvailable))
    strm << setw(indent+20) << "mcuCallsAvailable = " << setprecision(indent) << m_mcuCallsAvailable << '\n';
  if (HasOptionalField(e_sipGwCallsAvailable))
    strm << setw(indent+22) << "sipGwCallsAvailable = " << setprecision(indent) << m_sipGwCallsAvailable << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_voiceGwCallsAvailable.Compare(other.m_voiceGwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h310GwCallsAvailable.Compare(other.m_h310GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h320GwCallsAvailable.Compare(other.m_h320GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h321GwCallsAvailable.Compare(other.m_h321GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h322GwCallsAvailable.Compare(other.m_h322GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h323GwCallsAvailable.Compare(other.m_h323GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_h324GwCallsAvailable.Compare(other.m_h324GwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_t120OnlyGwCallsAvailable.Compare(other.m_t120OnlyGwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_t38FaxAnnexbOnlyGwCallsAvailable.Compare(other.m_t38FaxAnnexbOnlyGwCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_terminalCallsAvailable.Compare(other.m_terminalCallsAvailable)) != EqualTo)
    return result;
  if ((result = m_mcuCallsAvailable.Compare(other.m_mcuCallsAvailable)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_CallCapacityInfo::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_voiceGwCallsAvailable))
    length += m_voiceGwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h310GwCallsAvailable))
    length += m_h310GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h320GwCallsAvailable))
    length += m_h320GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h321GwCallsAvailable))
    length += m_h321GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h322GwCallsAvailable))
    length += m_h322GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h323GwCallsAvailable))
    length += m_h323GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_h324GwCallsAvailable))
    length += m_h324GwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_t120OnlyGwCallsAvailable))
    length += m_t120OnlyGwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
    length += m_t38FaxAnnexbOnlyGwCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_terminalCallsAvailable))
    length += m_terminalCallsAvailable.GetObjectLength();
  if (HasOptionalField(e_mcuCallsAvailable))
    length += m_mcuCallsAvailable.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_voiceGwCallsAvailable) && !m_voiceGwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h310GwCallsAvailable) && !m_h310GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h320GwCallsAvailable) && !m_h320GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h321GwCallsAvailable) && !m_h321GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h322GwCallsAvailable) && !m_h322GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h323GwCallsAvailable) && !m_h323GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_h324GwCallsAvailable) && !m_h324GwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_t120OnlyGwCallsAvailable) && !m_t120OnlyGwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable) && !m_t38FaxAnnexbOnlyGwCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_terminalCallsAvailable) && !m_terminalCallsAvailable.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_mcuCallsAvailable) && !m_mcuCallsAvailable.Decode(strm))
    return FALSE;
  if (!KnownExtensionDecode(strm, e_sipGwCallsAvailable, m_sipGwCallsAvailable))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_voiceGwCallsAvailable))
    m_voiceGwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h310GwCallsAvailable))
    m_h310GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h320GwCallsAvailable))
    m_h320GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h321GwCallsAvailable))
    m_h321GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h322GwCallsAvailable))
    m_h322GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h323GwCallsAvailable))
    m_h323GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_h324GwCallsAvailable))
    m_h324GwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_t120OnlyGwCallsAvailable))
    m_t120OnlyGwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
    m_t38FaxAnnexbOnlyGwCallsAvailable.Encode(strm);
  if (HasOptionalField(e_terminalCallsAvailable))
    m_terminalCallsAvailable.Encode(strm);
  if (HasOptionalField(e_mcuCallsAvailable))
    m_mcuCallsAvailable.Encode(strm);
  KnownExtensionEncode(strm, e_sipGwCallsAvailable, m_sipGwCallsAvailable);

  UnknownExtensionsEncode(strm);
}


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


//
// CallsAvailable
//

H225_CallsAvailable::H225_CallsAvailable(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
{
  m_calls.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
  m_group.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
}


#ifndef PASN_NOPRINTON
void H225_CallsAvailable::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+8) << "calls = " << setprecision(indent) << m_calls << '\n';
  if (HasOptionalField(e_group))
    strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
  if (HasOptionalField(e_carrier))
    strm << setw(indent+10) << "carrier = " << setprecision(indent) << m_carrier << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_CallsAvailable::GetDataLength() const
{
  PINDEX length = 0;
  length += m_calls.GetObjectLength();
  if (HasOptionalField(e_group))
    length += m_group.GetObjectLength();
  return length;
}


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

  if (!m_calls.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_group) && !m_group.Decode(strm))
    return FALSE;
  if (!KnownExtensionDecode(strm, e_carrier, m_carrier))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_calls.Encode(strm);
  if (HasOptionalField(e_group))
    m_group.Encode(strm);
  KnownExtensionEncode(strm, e_carrier, m_carrier);

  UnknownExtensionsEncode(strm);
}


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


//
// CicInfo
//

H225_CicInfo::H225_CicInfo(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
{
  m_pointCode.SetConstraints(PASN_Object::FixedConstraint, 2, 5);
}


#ifndef PASN_NOPRINTON
void H225_CicInfo::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+6) << "cic = " << setprecision(indent) << m_cic << '\n';
  strm << setw(indent+12) << "pointCode = " << setprecision(indent) << m_pointCode << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_CicInfo::GetDataLength() const
{
  PINDEX length = 0;
  length += m_cic.GetObjectLength();
  length += m_pointCode.GetObjectLength();
  return length;
}


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

  if (!m_cic.Decode(strm))
    return FALSE;
  if (!m_pointCode.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_cic.Encode(strm);
  m_pointCode.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// GroupID
//

H225_GroupID::H225_GroupID(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
  m_group.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
}


#ifndef PASN_NOPRINTON
void H225_GroupID::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_member))
    strm << setw(indent+9) << "member = " << setprecision(indent) << m_member << '\n';
  strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_GroupID::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_member))
    length += m_member.GetObjectLength();
  length += m_group.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_member) && !m_member.Decode(strm))
    return FALSE;
  if (!m_group.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_member))
    m_member.Encode(strm);
  m_group.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// ServiceControlSession
//

H225_ServiceControlSession::H225_ServiceControlSession(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
  m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
}


#ifndef PASN_NOPRINTON
void H225_ServiceControlSession::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
  if (HasOptionalField(e_contents))
    strm << setw(indent+11) << "contents = " << setprecision(indent) << m_contents << '\n';
  strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
    return result;
  if ((result = m_contents.Compare(other.m_contents)) != EqualTo)
    return result;
  if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_ServiceControlSession::GetDataLength() const
{
  PINDEX length = 0;
  length += m_sessionId.GetObjectLength();
  if (HasOptionalField(e_contents))
    length += m_contents.GetObjectLength();
  length += m_reason.GetObjectLength();
  return length;
}


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

  if (!m_sessionId.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_contents) && !m_contents.Decode(strm))
    return FALSE;
  if (!m_reason.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_sessionId.Encode(strm);
  if (HasOptionalField(e_contents))
    m_contents.Encode(strm);
  m_reason.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// RasUsageInfoTypes
//

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


#ifndef PASN_NOPRINTON
void H225_RasUsageInfoTypes::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+24) << "nonStandardUsageTypes = " << setprecision(indent) << m_nonStandardUsageTypes << '\n';
  if (HasOptionalField(e_startTime))
    strm << setw(indent+12) << "startTime = " << setprecision(indent) << m_startTime << '\n';
  if (HasOptionalField(e_endTime))
    strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
  if (HasOptionalField(e_terminationCause))
    strm << setw(indent+19) << "terminationCause = " << setprecision(indent) << m_terminationCause << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_nonStandardUsageTypes.Compare(other.m_nonStandardUsageTypes)) != EqualTo)
    return result;
  if ((result = m_startTime.Compare(other.m_startTime)) != EqualTo)
    return result;
  if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
    return result;
  if ((result = m_terminationCause.Compare(other.m_terminationCause)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_RasUsageInfoTypes::GetDataLength() const
{
  PINDEX length = 0;
  length += m_nonStandardUsageTypes.GetObjectLength();
  if (HasOptionalField(e_startTime))
    length += m_startTime.GetObjectLength();
  if (HasOptionalField(e_endTime))
    length += m_endTime.GetObjectLength();
  if (HasOptionalField(e_terminationCause))
    length += m_terminationCause.GetObjectLength();
  return length;
}


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

  if (!m_nonStandardUsageTypes.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_startTime) && !m_startTime.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_terminationCause) && !m_terminationCause.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_nonStandardUsageTypes.Encode(strm);
  if (HasOptionalField(e_startTime))
    m_startTime.Encode(strm);
  if (HasOptionalField(e_endTime))
    m_endTime.Encode(strm);
  if (HasOptionalField(e_terminationCause))
    m_terminationCause.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// RasUsageSpecification
//

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


#ifndef PASN_NOPRINTON
void H225_RasUsageSpecification::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+7) << "when = " << setprecision(indent) << m_when << '\n';
  if (HasOptionalField(e_callStartingPoint))
    strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
  strm << setw(indent+11) << "required = " << setprecision(indent) << m_required << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_when.Compare(other.m_when)) != EqualTo)
    return result;
  if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
    return result;
  if ((result = m_required.Compare(other.m_required)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_RasUsageSpecification::GetDataLength() const
{
  PINDEX length = 0;
  length += m_when.GetObjectLength();
  if (HasOptionalField(e_callStartingPoint))
    length += m_callStartingPoint.GetObjectLength();
  length += m_required.GetObjectLength();
  return length;
}


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

  if (!m_when.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
    return FALSE;
  if (!m_required.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_when.Encode(strm);
  if (HasOptionalField(e_callStartingPoint))
    m_callStartingPoint.Encode(strm);
  m_required.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// RasUsageInformation
//

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


#ifndef PASN_NOPRINTON
void H225_RasUsageInformation::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+25) << "nonStandardUsageFields = " << setprecision(indent) << m_nonStandardUsageFields << '\n';
  if (HasOptionalField(e_alertingTime))
    strm << setw(indent+15) << "alertingTime = " << setprecision(indent) << m_alertingTime << '\n';
  if (HasOptionalField(e_connectTime))
    strm << setw(indent+14) << "connectTime = " << setprecision(indent) << m_connectTime << '\n';
  if (HasOptionalField(e_endTime))
    strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_nonStandardUsageFields.Compare(other.m_nonStandardUsageFields)) != EqualTo)
    return result;
  if ((result = m_alertingTime.Compare(other.m_alertingTime)) != EqualTo)
    return result;
  if ((result = m_connectTime.Compare(other.m_connectTime)) != EqualTo)
    return result;
  if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_RasUsageInformation::GetDataLength() const
{
  PINDEX length = 0;
  length += m_nonStandardUsageFields.GetObjectLength();
  if (HasOptionalField(e_alertingTime))
    length += m_alertingTime.GetObjectLength();
  if (HasOptionalField(e_connectTime))
    length += m_connectTime.GetObjectLength();
  if (HasOptionalField(e_endTime))
    length += m_endTime.GetObjectLength();
  return length;
}


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

  if (!m_nonStandardUsageFields.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_alertingTime) && !m_alertingTime.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_connectTime) && !m_connectTime.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_nonStandardUsageFields.Encode(strm);
  if (HasOptionalField(e_alertingTime))
    m_alertingTime.Encode(strm);
  if (HasOptionalField(e_connectTime))
    m_connectTime.Encode(strm);
  if (HasOptionalField(e_endTime))
    m_endTime.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// BandwidthDetails
//

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


#ifndef PASN_NOPRINTON
void H225_BandwidthDetails::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+9) << "sender = " << setprecision(indent) << m_sender << '\n';
  strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
  strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
  strm << setw(indent+16) << "rtcpAddresses = " << setprecision(indent) << m_rtcpAddresses << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_sender.Compare(other.m_sender)) != EqualTo)
    return result;
  if ((result = m_multicast.Compare(other.m_multicast)) != EqualTo)
    return result;
  if ((result = m_bandwidth.Compare(other.m_bandwidth)) != EqualTo)
    return result;
  if ((result = m_rtcpAddresses.Compare(other.m_rtcpAddresses)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_BandwidthDetails::GetDataLength() const
{
  PINDEX length = 0;
  length += m_sender.GetObjectLength();
  length += m_multicast.GetObjectLength();
  length += m_bandwidth.GetObjectLength();
  length += m_rtcpAddresses.GetObjectLength();
  return length;
}


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

  if (!m_sender.Decode(strm))
    return FALSE;
  if (!m_multicast.Decode(strm))
    return FALSE;
  if (!m_bandwidth.Decode(strm))
    return FALSE;
  if (!m_rtcpAddresses.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_sender.Encode(strm);
  m_multicast.Encode(strm);
  m_bandwidth.Encode(strm);
  m_rtcpAddresses.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// CallCreditServiceControl
//

H225_CallCreditServiceControl::H225_CallCreditServiceControl(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
{
  m_amountString.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
  m_callDurationLimit.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
}


#ifndef PASN_NOPRINTON
void H225_CallCreditServiceControl::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  if (HasOptionalField(e_amountString))
    strm << setw(indent+15) << "amountString = " << setprecision(indent) << m_amountString << '\n';
  if (HasOptionalField(e_billingMode))
    strm << setw(indent+14) << "billingMode = " << setprecision(indent) << m_billingMode << '\n';
  if (HasOptionalField(e_callDurationLimit))
    strm << setw(indent+20) << "callDurationLimit = " << setprecision(indent) << m_callDurationLimit << '\n';
  if (HasOptionalField(e_enforceCallDurationLimit))
    strm << setw(indent+27) << "enforceCallDurationLimit = " << setprecision(indent) << m_enforceCallDurationLimit << '\n';
  if (HasOptionalField(e_callStartingPoint))
    strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_amountString.Compare(other.m_amountString)) != EqualTo)
    return result;
  if ((result = m_billingMode.Compare(other.m_billingMode)) != EqualTo)
    return result;
  if ((result = m_callDurationLimit.Compare(other.m_callDurationLimit)) != EqualTo)
    return result;
  if ((result = m_enforceCallDurationLimit.Compare(other.m_enforceCallDurationLimit)) != EqualTo)
    return result;
  if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_CallCreditServiceControl::GetDataLength() const
{
  PINDEX length = 0;
  if (HasOptionalField(e_amountString))
    length += m_amountString.GetObjectLength();
  if (HasOptionalField(e_billingMode))
    length += m_billingMode.GetObjectLength();
  if (HasOptionalField(e_callDurationLimit))
    length += m_callDurationLimit.GetObjectLength();
  if (HasOptionalField(e_enforceCallDurationLimit))
    length += m_enforceCallDurationLimit.GetObjectLength();
  if (HasOptionalField(e_callStartingPoint))
    length += m_callStartingPoint.GetObjectLength();
  return length;
}


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

  if (HasOptionalField(e_amountString) && !m_amountString.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_billingMode) && !m_billingMode.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_callDurationLimit) && !m_callDurationLimit.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_enforceCallDurationLimit) && !m_enforceCallDurationLimit.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  if (HasOptionalField(e_amountString))
    m_amountString.Encode(strm);
  if (HasOptionalField(e_billingMode))
    m_billingMode.Encode(strm);
  if (HasOptionalField(e_callDurationLimit))
    m_callDurationLimit.Encode(strm);
  if (HasOptionalField(e_enforceCallDurationLimit))
    m_enforceCallDurationLimit.Encode(strm);
  if (HasOptionalField(e_callStartingPoint))
    m_callStartingPoint.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// GenericData
//

H225_GenericData::H225_GenericData(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
{
  m_parameters.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
}


#ifndef PASN_NOPRINTON
void H225_GenericData::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  if (HasOptionalField(e_parameters))
    strm << setw(indent+13) << "parameters = " << setprecision(indent) << m_parameters << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_GenericData::GetDataLength() const
{
  PINDEX length = 0;
  length += m_id.GetObjectLength();
  if (HasOptionalField(e_parameters))
    length += m_parameters.GetObjectLength();
  return length;
}


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

  if (!m_id.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_parameters) && !m_parameters.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_id.Encode(strm);
  if (HasOptionalField(e_parameters))
    m_parameters.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// EnumeratedParameter
//

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


#ifndef PASN_NOPRINTON
void H225_EnumeratedParameter::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
  if (HasOptionalField(e_content))
    strm << setw(indent+10) << "content = " << setprecision(indent) << m_content << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

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

  return PASN_Sequence::Compare(other);
}


PINDEX H225_EnumeratedParameter::GetDataLength() const
{
  PINDEX length = 0;
  length += m_id.GetObjectLength();
  if (HasOptionalField(e_content))
    length += m_content.GetObjectLength();
  return length;
}


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

  if (!m_id.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_content) && !m_content.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_id.Encode(strm);
  if (HasOptionalField(e_content))
    m_content.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// FeatureSet
//

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


#ifndef PASN_NOPRINTON
void H225_FeatureSet::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+24) << "replacementFeatureSet = " << setprecision(indent) << m_replacementFeatureSet << '\n';
  if (HasOptionalField(e_neededFeatures))
    strm << setw(indent+17) << "neededFeatures = " << setprecision(indent) << m_neededFeatures << '\n';
  if (HasOptionalField(e_desiredFeatures))
    strm << setw(indent+18) << "desiredFeatures = " << setprecision(indent) << m_desiredFeatures << '\n';
  if (HasOptionalField(e_supportedFeatures))
    strm << setw(indent+20) << "supportedFeatures = " << setprecision(indent) << m_supportedFeatures << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_replacementFeatureSet.Compare(other.m_replacementFeatureSet)) != EqualTo)
    return result;
  if ((result = m_neededFeatures.Compare(other.m_neededFeatures)) != EqualTo)
    return result;
  if ((result = m_desiredFeatures.Compare(other.m_desiredFeatures)) != EqualTo)
    return result;
  if ((result = m_supportedFeatures.Compare(other.m_supportedFeatures)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_FeatureSet::GetDataLength() const
{
  PINDEX length = 0;
  length += m_replacementFeatureSet.GetObjectLength();
  if (HasOptionalField(e_neededFeatures))
    length += m_neededFeatures.GetObjectLength();
  if (HasOptionalField(e_desiredFeatures))
    length += m_desiredFeatures.GetObjectLength();
  if (HasOptionalField(e_supportedFeatures))
    length += m_supportedFeatures.GetObjectLength();
  return length;
}


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

  if (!m_replacementFeatureSet.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_neededFeatures) && !m_neededFeatures.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_desiredFeatures) && !m_desiredFeatures.Decode(strm))
    return FALSE;
  if (HasOptionalField(e_supportedFeatures) && !m_supportedFeatures.Decode(strm))
    return FALSE;

  return UnknownExtensionsDecode(strm);
}


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

  m_replacementFeatureSet.Encode(strm);
  if (HasOptionalField(e_neededFeatures))
    m_neededFeatures.Encode(strm);
  if (HasOptionalField(e_desiredFeatures))
    m_desiredFeatures.Encode(strm);
  if (HasOptionalField(e_supportedFeatures))
    m_supportedFeatures.Encode(strm);

  UnknownExtensionsEncode(strm);
}


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


//
// RTPSession
//

H225_RTPSession::H225_RTPSession(unsigned tag, PASN_Object::TagClass tagClass)
  : PASN_Sequence(tag, tagClass, 0, TRUE, 2)
{
  m_ssrc.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
  m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
}


#ifndef PASN_NOPRINTON
void H225_RTPSession::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n";
  strm << setw(indent+13) << "rtpAddress = " << setprecision(indent) << m_rtpAddress << '\n';
  strm << setw(indent+14) << "rtcpAddress = " << setprecision(indent) << m_rtcpAddress << '\n';
  strm << setw(indent+8) << "cname = " << setprecision(indent) << m_cname << '\n';
  strm << setw(indent+7) << "ssrc = " << setprecision(indent) << m_ssrc << '\n';
  strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
  strm << setw(indent+23) << "associatedSessionIds = " << setprecision(indent) << m_associatedSessionIds << '\n';
  if (HasOptionalField(e_multicast))
    strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
  if (HasOptionalField(e_bandwidth))
    strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
  strm << setw(indent-1) << setprecision(indent-2) << "}";
}
#endif


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

  Comparison result;

  if ((result = m_rtpAddress.Compare(other.m_rtpAddress)) != EqualTo)
    return result;
  if ((result = m_rtcpAddress.Compare(other.m_rtcpAddress)) != EqualTo)
    return result;
  if ((result = m_cname.Compare(other.m_cname)) != EqualTo)
    return result;
  if ((result = m_ssrc.Compare(other.m_ssrc)) != EqualTo)
    return result;
  if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
    return result;
  if ((result = m_associatedSessionIds.Compare(other.m_associatedSessionIds)) != EqualTo)
    return result;

  return PASN_Sequence::Compare(other);
}


PINDEX H225_RTPSession::GetDataLength() const
{
  PINDEX length = 0;
  length +=