src/h225_2.cxx

   1 //
   2 // h225_2.cxx
   3 //
   4 // Code automatically generated by asnparse.
   5 //
   6
   7 #include <ptlib.h>
   8 #include "h225.h"
   9
  10 #define new PNEW
  11
  12
  13 #if ! H323_DISABLE_H225
  14
  15 //
  16 // ArrayOf_EnumeratedParameter
  17 //
  18
  19 H225_ArrayOf_EnumeratedParameter::H225_ArrayOf_EnumeratedParameter(unsigned tag, PASN_Object::TagClass tagClass)
  20   : PASN_Array(tag, tagClass)
  21 {
  22 }
  23
  24
  25 PASN_Object * H225_ArrayOf_EnumeratedParameter::CreateObject() const
  26 {
  27   return new H225_EnumeratedParameter;
  28 }
  29
  30
  31 H225_EnumeratedParameter & H225_ArrayOf_EnumeratedParameter::operator[](PINDEX i) const
  32 {
  33   return (H225_EnumeratedParameter &)array[i];
  34 }
  35
  36
  37 PObject * H225_ArrayOf_EnumeratedParameter::Clone() const
  38 {
  39 #ifndef PASN_LEANANDMEAN
  40   PAssert(IsClass(H225_ArrayOf_EnumeratedParameter::Class()), PInvalidCast);
  41 #endif
  42   return new H225_ArrayOf_EnumeratedParameter(*this);
  43 }
  44
  45
  46 //
  47 // RTPSession_associatedSessionIds
  48 //
  49
  50 H225_RTPSession_associatedSessionIds::H225_RTPSession_associatedSessionIds(unsigned tag, PASN_Object::TagClass tagClass)
  51   : PASN_Array(tag, tagClass)
  52 {
  53 }
  54
  55
  56 PASN_Object * H225_RTPSession_associatedSessionIds::CreateObject() const
  57 {
  58   PASN_Integer * obj = new PASN_Integer;
  59   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 255);
  60   return obj;
  61 }
  62
  63
  64 PASN_Integer & H225_RTPSession_associatedSessionIds::operator[](PINDEX i) const
  65 {
  66   return (PASN_Integer &)array[i];
  67 }
  68
  69
  70 PObject * H225_RTPSession_associatedSessionIds::Clone() const
  71 {
  72 #ifndef PASN_LEANANDMEAN
  73   PAssert(IsClass(H225_RTPSession_associatedSessionIds::Class()), PInvalidCast);
  74 #endif
  75   return new H225_RTPSession_associatedSessionIds(*this);
  76 }
  77
  78
  79 //
  80 // ArrayOf_AdmissionConfirm
  81 //
  82
  83 H225_ArrayOf_AdmissionConfirm::H225_ArrayOf_AdmissionConfirm(unsigned tag, PASN_Object::TagClass tagClass)
  84   : PASN_Array(tag, tagClass)
  85 {
  86 }
  87
  88
  89 PASN_Object * H225_ArrayOf_AdmissionConfirm::CreateObject() const
  90 {
  91   return new H225_AdmissionConfirm;
  92 }
  93
  94
  95 H225_AdmissionConfirm & H225_ArrayOf_AdmissionConfirm::operator[](PINDEX i) const
  96 {
  97   return (H225_AdmissionConfirm &)array[i];
  98 }
  99
 100
 101 PObject * H225_ArrayOf_AdmissionConfirm::Clone() const
 102 {
 103 #ifndef PASN_LEANANDMEAN
 104   PAssert(IsClass(H225_ArrayOf_AdmissionConfirm::Class()), PInvalidCast);
 105 #endif
 106   return new H225_ArrayOf_AdmissionConfirm(*this);
 107 }
 108
 109
 110 //
 111 // ArrayOf_Endpoint
 112 //
 113
 114 H225_ArrayOf_Endpoint::H225_ArrayOf_Endpoint(unsigned tag, PASN_Object::TagClass tagClass)
 115   : PASN_Array(tag, tagClass)
 116 {
 117 }
 118
 119
 120 PASN_Object * H225_ArrayOf_Endpoint::CreateObject() const
 121 {
 122   return new H225_Endpoint;
 123 }
 124
 125
 126 H225_Endpoint & H225_ArrayOf_Endpoint::operator[](PINDEX i) const
 127 {
 128   return (H225_Endpoint &)array[i];
 129 }
 130
 131
 132 PObject * H225_ArrayOf_Endpoint::Clone() const
 133 {
 134 #ifndef PASN_LEANANDMEAN
 135   PAssert(IsClass(H225_ArrayOf_Endpoint::Class()), PInvalidCast);
 136 #endif
 137   return new H225_ArrayOf_Endpoint(*this);
 138 }
 139
 140
 141 //
 142 // ArrayOf_AuthenticationMechanism
 143 //
 144
 145 H225_ArrayOf_AuthenticationMechanism::H225_ArrayOf_AuthenticationMechanism(unsigned tag, PASN_Object::TagClass tagClass)
 146   : PASN_Array(tag, tagClass)
 147 {
 148 }
 149
 150
 151 PASN_Object * H225_ArrayOf_AuthenticationMechanism::CreateObject() const
 152 {
 153   return new H235_AuthenticationMechanism;
 154 }
 155
 156
 157 H235_AuthenticationMechanism & H225_ArrayOf_AuthenticationMechanism::operator[](PINDEX i) const
 158 {
 159   return (H235_AuthenticationMechanism &)array[i];
 160 }
 161
 162
 163 PObject * H225_ArrayOf_AuthenticationMechanism::Clone() const
 164 {
 165 #ifndef PASN_LEANANDMEAN
 166   PAssert(IsClass(H225_ArrayOf_AuthenticationMechanism::Class()), PInvalidCast);
 167 #endif
 168   return new H225_ArrayOf_AuthenticationMechanism(*this);
 169 }
 170
 171
 172 //
 173 // ArrayOf_PASN_ObjectId
 174 //
 175
 176 H225_ArrayOf_PASN_ObjectId::H225_ArrayOf_PASN_ObjectId(unsigned tag, PASN_Object::TagClass tagClass)
 177   : PASN_Array(tag, tagClass)
 178 {
 179 }
 180
 181
 182 PASN_Object * H225_ArrayOf_PASN_ObjectId::CreateObject() const
 183 {
 184   return new PASN_ObjectId;
 185 }
 186
 187
 188 PASN_ObjectId & H225_ArrayOf_PASN_ObjectId::operator[](PINDEX i) const
 189 {
 190   return (PASN_ObjectId &)array[i];
 191 }
 192
 193
 194 PObject * H225_ArrayOf_PASN_ObjectId::Clone() const
 195 {
 196 #ifndef PASN_LEANANDMEAN
 197   PAssert(IsClass(H225_ArrayOf_PASN_ObjectId::Class()), PInvalidCast);
 198 #endif
 199   return new H225_ArrayOf_PASN_ObjectId(*this);
 200 }
 201
 202
 203 //
 204 // ArrayOf_IntegrityMechanism
 205 //
 206
 207 H225_ArrayOf_IntegrityMechanism::H225_ArrayOf_IntegrityMechanism(unsigned tag, PASN_Object::TagClass tagClass)
 208   : PASN_Array(tag, tagClass)
 209 {
 210 }
 211
 212
 213 PASN_Object * H225_ArrayOf_IntegrityMechanism::CreateObject() const
 214 {
 215   return new H225_IntegrityMechanism;
 216 }
 217
 218
 219 H225_IntegrityMechanism & H225_ArrayOf_IntegrityMechanism::operator[](PINDEX i) const
 220 {
 221   return (H225_IntegrityMechanism &)array[i];
 222 }
 223
 224
 225 PObject * H225_ArrayOf_IntegrityMechanism::Clone() const
 226 {
 227 #ifndef PASN_LEANANDMEAN
 228   PAssert(IsClass(H225_ArrayOf_IntegrityMechanism::Class()), PInvalidCast);
 229 #endif
 230   return new H225_ArrayOf_IntegrityMechanism(*this);
 231 }
 232
 233
 234 //
 235 // ArrayOf_AddressPattern
 236 //
 237
 238 H225_ArrayOf_AddressPattern::H225_ArrayOf_AddressPattern(unsigned tag, PASN_Object::TagClass tagClass)
 239   : PASN_Array(tag, tagClass)
 240 {
 241 }
 242
 243
 244 PASN_Object * H225_ArrayOf_AddressPattern::CreateObject() const
 245 {
 246   return new H225_AddressPattern;
 247 }
 248
 249
 250 H225_AddressPattern & H225_ArrayOf_AddressPattern::operator[](PINDEX i) const
 251 {
 252   return (H225_AddressPattern &)array[i];
 253 }
 254
 255
 256 PObject * H225_ArrayOf_AddressPattern::Clone() const
 257 {
 258 #ifndef PASN_LEANANDMEAN
 259   PAssert(IsClass(H225_ArrayOf_AddressPattern::Class()), PInvalidCast);
 260 #endif
 261   return new H225_ArrayOf_AddressPattern(*this);
 262 }
 263
 264
 265 //
 266 // ArrayOf_H248PackagesDescriptor
 267 //
 268
 269 H225_ArrayOf_H248PackagesDescriptor::H225_ArrayOf_H248PackagesDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
 270   : PASN_Array(tag, tagClass)
 271 {
 272 }
 273
 274
 275 PASN_Object * H225_ArrayOf_H248PackagesDescriptor::CreateObject() const
 276 {
 277   return new H225_H248PackagesDescriptor;
 278 }
 279
 280
 281 H225_H248PackagesDescriptor & H225_ArrayOf_H248PackagesDescriptor::operator[](PINDEX i) const
 282 {
 283   return (H225_H248PackagesDescriptor &)array[i];
 284 }
 285
 286
 287 PObject * H225_ArrayOf_H248PackagesDescriptor::Clone() const
 288 {
 289 #ifndef PASN_LEANANDMEAN
 290   PAssert(IsClass(H225_ArrayOf_H248PackagesDescriptor::Class()), PInvalidCast);
 291 #endif
 292   return new H225_ArrayOf_H248PackagesDescriptor(*this);
 293 }
 294
 295
 296 //
 297 // RegistrationRequest_language
 298 //
 299
 300 H225_RegistrationRequest_language::H225_RegistrationRequest_language(unsigned tag, PASN_Object::TagClass tagClass)
 301   : PASN_Array(tag, tagClass)
 302 {
 303 }
 304
 305
 306 PASN_Object * H225_RegistrationRequest_language::CreateObject() const
 307 {
 308   PASN_IA5String * obj = new PASN_IA5String;
 309   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
 310   return obj;
 311 }
 312
 313
 314 PASN_IA5String & H225_RegistrationRequest_language::operator[](PINDEX i) const
 315 {
 316   return (PASN_IA5String &)array[i];
 317 }
 318
 319
 320 PObject * H225_RegistrationRequest_language::Clone() const
 321 {
 322 #ifndef PASN_LEANANDMEAN
 323   PAssert(IsClass(H225_RegistrationRequest_language::Class()), PInvalidCast);
 324 #endif
 325   return new H225_RegistrationRequest_language(*this);
 326 }
 327
 328
 329 //
 330 // ArrayOf_RasUsageSpecification
 331 //
 332
 333 H225_ArrayOf_RasUsageSpecification::H225_ArrayOf_RasUsageSpecification(unsigned tag, PASN_Object::TagClass tagClass)
 334   : PASN_Array(tag, tagClass)
 335 {
 336 }
 337
 338
 339 PASN_Object * H225_ArrayOf_RasUsageSpecification::CreateObject() const
 340 {
 341   return new H225_RasUsageSpecification;
 342 }
 343
 344
 345 H225_RasUsageSpecification & H225_ArrayOf_RasUsageSpecification::operator[](PINDEX i) const
 346 {
 347   return (H225_RasUsageSpecification &)array[i];
 348 }
 349
 350
 351 PObject * H225_ArrayOf_RasUsageSpecification::Clone() const
 352 {
 353 #ifndef PASN_LEANANDMEAN
 354   PAssert(IsClass(H225_ArrayOf_RasUsageSpecification::Class()), PInvalidCast);
 355 #endif
 356   return new H225_ArrayOf_RasUsageSpecification(*this);
 357 }
 358
 359
 360 //
 361 // RegistrationRejectReason_invalidTerminalAliases
 362 //
 363
 364 H225_RegistrationRejectReason_invalidTerminalAliases::H225_RegistrationRejectReason_invalidTerminalAliases(unsigned tag, PASN_Object::TagClass tagClass)
 365   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
 366 {
 367 }
 368
 369
 370 #ifndef PASN_NOPRINTON
 371 void H225_RegistrationRejectReason_invalidTerminalAliases::PrintOn(ostream & strm) const
 372 {
 373   int indent = strm.precision() + 2;
 374   strm << "{\n";
 375   if (HasOptionalField(e_terminalAlias))
 376     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
 377   if (HasOptionalField(e_terminalAliasPattern))
 378     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
 379   if (HasOptionalField(e_supportedPrefixes))
 380     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
 381   strm << setw(indent-1) << setprecision(indent-2) << "}";
 382 }
 383 #endif
 384
 385
 386 PObject::Comparison H225_RegistrationRejectReason_invalidTerminalAliases::Compare(const PObject & obj) const
 387 {
 388 #ifndef PASN_LEANANDMEAN
 389   PAssert(PIsDescendant(&obj, H225_RegistrationRejectReason_invalidTerminalAliases), PInvalidCast);
 390 #endif
 391   const H225_RegistrationRejectReason_invalidTerminalAliases & other = (const H225_RegistrationRejectReason_invalidTerminalAliases &)obj;
 392
 393   Comparison result;
 394
 395   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
 396     return result;
 397   if ((result = m_terminalAliasPattern.Compare(other.m_terminalAliasPattern)) != EqualTo)
 398     return result;
 399   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
 400     return result;
 401
 402   return PASN_Sequence::Compare(other);
 403 }
 404
 405
 406 PINDEX H225_RegistrationRejectReason_invalidTerminalAliases::GetDataLength() const
 407 {
 408   PINDEX length = 0;
 409   if (HasOptionalField(e_terminalAlias))
 410     length += m_terminalAlias.GetObjectLength();
 411   if (HasOptionalField(e_terminalAliasPattern))
 412     length += m_terminalAliasPattern.GetObjectLength();
 413   if (HasOptionalField(e_supportedPrefixes))
 414     length += m_supportedPrefixes.GetObjectLength();
 415   return length;
 416 }
 417
 418
 419 BOOL H225_RegistrationRejectReason_invalidTerminalAliases::Decode(PASN_Stream & strm)
 420 {
 421   if (!PreambleDecode(strm))
 422     return FALSE;
 423
 424   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
 425     return FALSE;
 426   if (HasOptionalField(e_terminalAliasPattern) && !m_terminalAliasPattern.Decode(strm))
 427     return FALSE;
 428   if (HasOptionalField(e_supportedPrefixes) && !m_supportedPrefixes.Decode(strm))
 429     return FALSE;
 430
 431   return UnknownExtensionsDecode(strm);
 432 }
 433
 434
 435 void H225_RegistrationRejectReason_invalidTerminalAliases::Encode(PASN_Stream & strm) const
 436 {
 437   PreambleEncode(strm);
 438
 439   if (HasOptionalField(e_terminalAlias))
 440     m_terminalAlias.Encode(strm);
 441   if (HasOptionalField(e_terminalAliasPattern))
 442     m_terminalAliasPattern.Encode(strm);
 443   if (HasOptionalField(e_supportedPrefixes))
 444     m_supportedPrefixes.Encode(strm);
 445
 446   UnknownExtensionsEncode(strm);
 447 }
 448
 449
 450 PObject * H225_RegistrationRejectReason_invalidTerminalAliases::Clone() const
 451 {
 452 #ifndef PASN_LEANANDMEAN
 453   PAssert(IsClass(H225_RegistrationRejectReason_invalidTerminalAliases::Class()), PInvalidCast);
 454 #endif
 455   return new H225_RegistrationRejectReason_invalidTerminalAliases(*this);
 456 }
 457
 458
 459 //
 460 // ArrayOf_QOSCapability
 461 //
 462
 463 H225_ArrayOf_QOSCapability::H225_ArrayOf_QOSCapability(unsigned tag, PASN_Object::TagClass tagClass)
 464   : PASN_Array(tag, tagClass)
 465 {
 466 }
 467
 468
 469 PASN_Object * H225_ArrayOf_QOSCapability::CreateObject() const
 470 {
 471   return new H245_QOSCapability;
 472 }
 473
 474
 475 H245_QOSCapability & H225_ArrayOf_QOSCapability::operator[](PINDEX i) const
 476 {
 477   return (H245_QOSCapability &)array[i];
 478 }
 479
 480
 481 PObject * H225_ArrayOf_QOSCapability::Clone() const
 482 {
 483 #ifndef PASN_LEANANDMEAN
 484   PAssert(IsClass(H225_ArrayOf_QOSCapability::Class()), PInvalidCast);
 485 #endif
 486   return new H225_ArrayOf_QOSCapability(*this);
 487 }
 488
 489
 490 //
 491 // AdmissionConfirm_language
 492 //
 493
 494 H225_AdmissionConfirm_language::H225_AdmissionConfirm_language(unsigned tag, PASN_Object::TagClass tagClass)
 495   : PASN_Array(tag, tagClass)
 496 {
 497 }
 498
 499
 500 PASN_Object * H225_AdmissionConfirm_language::CreateObject() const
 501 {
 502   PASN_IA5String * obj = new PASN_IA5String;
 503   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
 504   return obj;
 505 }
 506
 507
 508 PASN_IA5String & H225_AdmissionConfirm_language::operator[](PINDEX i) const
 509 {
 510   return (PASN_IA5String &)array[i];
 511 }
 512
 513
 514 PObject * H225_AdmissionConfirm_language::Clone() const
 515 {
 516 #ifndef PASN_LEANANDMEAN
 517   PAssert(IsClass(H225_AdmissionConfirm_language::Class()), PInvalidCast);
 518 #endif
 519   return new H225_AdmissionConfirm_language(*this);
 520 }
 521
 522
 523 //
 524 // ArrayOf_PartyNumber
 525 //
 526
 527 H225_ArrayOf_PartyNumber::H225_ArrayOf_PartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
 528   : PASN_Array(tag, tagClass)
 529 {
 530 }
 531
 532
 533 PASN_Object * H225_ArrayOf_PartyNumber::CreateObject() const
 534 {
 535   return new H225_PartyNumber;
 536 }
 537
 538
 539 H225_PartyNumber & H225_ArrayOf_PartyNumber::operator[](PINDEX i) const
 540 {
 541   return (H225_PartyNumber &)array[i];
 542 }
 543
 544
 545 PObject * H225_ArrayOf_PartyNumber::Clone() const
 546 {
 547 #ifndef PASN_LEANANDMEAN
 548   PAssert(IsClass(H225_ArrayOf_PartyNumber::Class()), PInvalidCast);
 549 #endif
 550   return new H225_ArrayOf_PartyNumber(*this);
 551 }
 552
 553
 554 //
 555 // ArrayOf_BandwidthDetails
 556 //
 557
 558 H225_ArrayOf_BandwidthDetails::H225_ArrayOf_BandwidthDetails(unsigned tag, PASN_Object::TagClass tagClass)
 559   : PASN_Array(tag, tagClass)
 560 {
 561 }
 562
 563
 564 PASN_Object * H225_ArrayOf_BandwidthDetails::CreateObject() const
 565 {
 566   return new H225_BandwidthDetails;
 567 }
 568
 569
 570 H225_BandwidthDetails & H225_ArrayOf_BandwidthDetails::operator[](PINDEX i) const
 571 {
 572   return (H225_BandwidthDetails &)array[i];
 573 }
 574
 575
 576 PObject * H225_ArrayOf_BandwidthDetails::Clone() const
 577 {
 578 #ifndef PASN_LEANANDMEAN
 579   PAssert(IsClass(H225_ArrayOf_BandwidthDetails::Class()), PInvalidCast);
 580 #endif
 581   return new H225_ArrayOf_BandwidthDetails(*this);
 582 }
 583
 584
 585 //
 586 // LocationRequest_language
 587 //
 588
 589 H225_LocationRequest_language::H225_LocationRequest_language(unsigned tag, PASN_Object::TagClass tagClass)
 590   : PASN_Array(tag, tagClass)
 591 {
 592 }
 593
 594
 595 PASN_Object * H225_LocationRequest_language::CreateObject() const
 596 {
 597   PASN_IA5String * obj = new PASN_IA5String;
 598   obj->SetConstraints(PASN_Object::FixedConstraint, 1, 32);
 599   return obj;
 600 }
 601
 602
 603 PASN_IA5String & H225_LocationRequest_language::operator[](PINDEX i) const
 604 {
 605   return (PASN_IA5String &)array[i];
 606 }
 607
 608
 609 PObject * H225_LocationRequest_language::Clone() const
 610 {
 611 #ifndef PASN_LEANANDMEAN
 612   PAssert(IsClass(H225_LocationRequest_language::Class()), PInvalidCast);
 613 #endif
 614   return new H225_LocationRequest_language(*this);
 615 }
 616
 617
 618 //
 619 // InfoRequestResponse_perCallInfo
 620 //
 621
 622 H225_InfoRequestResponse_perCallInfo::H225_InfoRequestResponse_perCallInfo(unsigned tag, PASN_Object::TagClass tagClass)
 623   : PASN_Array(tag, tagClass)
 624 {
 625 }
 626
 627
 628 PASN_Object * H225_InfoRequestResponse_perCallInfo::CreateObject() const
 629 {
 630   return new H225_InfoRequestResponse_perCallInfo_subtype;
 631 }
 632
 633
 634 H225_InfoRequestResponse_perCallInfo_subtype & H225_InfoRequestResponse_perCallInfo::operator[](PINDEX i) const
 635 {
 636   return (H225_InfoRequestResponse_perCallInfo_subtype &)array[i];
 637 }
 638
 639
 640 PObject * H225_InfoRequestResponse_perCallInfo::Clone() const
 641 {
 642 #ifndef PASN_LEANANDMEAN
 643   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo::Class()), PInvalidCast);
 644 #endif
 645   return new H225_InfoRequestResponse_perCallInfo(*this);
 646 }
 647
 648
 649 //
 650 // ServiceControlIndication_callSpecific
 651 //
 652
 653 H225_ServiceControlIndication_callSpecific::H225_ServiceControlIndication_callSpecific(unsigned tag, PASN_Object::TagClass tagClass)
 654   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
 655 {
 656 }
 657
 658
 659 #ifndef PASN_NOPRINTON
 660 void H225_ServiceControlIndication_callSpecific::PrintOn(ostream & strm) const
 661 {
 662   int indent = strm.precision() + 2;
 663   strm << "{\n";
 664   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
 665   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
 666   strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
 667   strm << setw(indent-1) << setprecision(indent-2) << "}";
 668 }
 669 #endif
 670
 671
 672 PObject::Comparison H225_ServiceControlIndication_callSpecific::Compare(const PObject & obj) const
 673 {
 674 #ifndef PASN_LEANANDMEAN
 675   PAssert(PIsDescendant(&obj, H225_ServiceControlIndication_callSpecific), PInvalidCast);
 676 #endif
 677   const H225_ServiceControlIndication_callSpecific & other = (const H225_ServiceControlIndication_callSpecific &)obj;
 678
 679   Comparison result;
 680
 681   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
 682     return result;
 683   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
 684     return result;
 685   if ((result = m_answeredCall.Compare(other.m_answeredCall)) != EqualTo)
 686     return result;
 687
 688   return PASN_Sequence::Compare(other);
 689 }
 690
 691
 692 PINDEX H225_ServiceControlIndication_callSpecific::GetDataLength() const
 693 {
 694   PINDEX length = 0;
 695   length += m_callIdentifier.GetObjectLength();
 696   length += m_conferenceID.GetObjectLength();
 697   length += m_answeredCall.GetObjectLength();
 698   return length;
 699 }
 700
 701
 702 BOOL H225_ServiceControlIndication_callSpecific::Decode(PASN_Stream & strm)
 703 {
 704   if (!PreambleDecode(strm))
 705     return FALSE;
 706
 707   if (!m_callIdentifier.Decode(strm))
 708     return FALSE;
 709   if (!m_conferenceID.Decode(strm))
 710     return FALSE;
 711   if (!m_answeredCall.Decode(strm))
 712     return FALSE;
 713
 714   return UnknownExtensionsDecode(strm);
 715 }
 716
 717
 718 void H225_ServiceControlIndication_callSpecific::Encode(PASN_Stream & strm) const
 719 {
 720   PreambleEncode(strm);
 721
 722   m_callIdentifier.Encode(strm);
 723   m_conferenceID.Encode(strm);
 724   m_answeredCall.Encode(strm);
 725
 726   UnknownExtensionsEncode(strm);
 727 }
 728
 729
 730 PObject * H225_ServiceControlIndication_callSpecific::Clone() const
 731 {
 732 #ifndef PASN_LEANANDMEAN
 733   PAssert(IsClass(H225_ServiceControlIndication_callSpecific::Class()), PInvalidCast);
 734 #endif
 735   return new H225_ServiceControlIndication_callSpecific(*this);
 736 }
 737
 738
 739
 740 #ifndef PASN_NOPRINTON
 741 const static PASN_Names Names_H225_ServiceControlResponse_result[]={
 742       {"started",0}
 743      ,{"failed",1}
 744      ,{"stopped",2}
 745      ,{"notAvailable",3}
 746      ,{"neededFeatureNotSupported",4}
 747 };
 748 #endif
 749 //
 750 // ServiceControlResponse_result
 751 //
 752
 753 H225_ServiceControlResponse_result::H225_ServiceControlResponse_result(unsigned tag, PASN_Object::TagClass tagClass)
 754   : PASN_Choice(tag, tagClass, 5, TRUE
 755 #ifndef PASN_NOPRINTON
 756     ,(const PASN_Names *)Names_H225_ServiceControlResponse_result,5
 757 #endif
 758 )
 759 {
 760 }
 761
 762
 763 BOOL H225_ServiceControlResponse_result::CreateObject()
 764 {
 765   choice = (tag <= e_neededFeatureNotSupported) ? new PASN_Null() : NULL;
 766   return choice != NULL;
 767 }
 768
 769
 770 PObject * H225_ServiceControlResponse_result::Clone() const
 771 {
 772 #ifndef PASN_LEANANDMEAN
 773   PAssert(IsClass(H225_ServiceControlResponse_result::Class()), PInvalidCast);
 774 #endif
 775   return new H225_ServiceControlResponse_result(*this);
 776 }
 777
 778
 779 //
 780 // TransportAddress_ipSourceRoute_route
 781 //
 782
 783 H225_TransportAddress_ipSourceRoute_route::H225_TransportAddress_ipSourceRoute_route(unsigned tag, PASN_Object::TagClass tagClass)
 784   : PASN_Array(tag, tagClass)
 785 {
 786 }
 787
 788
 789 PASN_Object * H225_TransportAddress_ipSourceRoute_route::CreateObject() const
 790 {
 791   PASN_OctetString * obj = new PASN_OctetString;
 792   obj->SetConstraints(PASN_Object::FixedConstraint, 4);
 793   return obj;
 794 }
 795
 796
 797 PASN_OctetString & H225_TransportAddress_ipSourceRoute_route::operator[](PINDEX i) const
 798 {
 799   return (PASN_OctetString &)array[i];
 800 }
 801
 802
 803 PObject * H225_TransportAddress_ipSourceRoute_route::Clone() const
 804 {
 805 #ifndef PASN_LEANANDMEAN
 806   PAssert(IsClass(H225_TransportAddress_ipSourceRoute_route::Class()), PInvalidCast);
 807 #endif
 808   return new H225_TransportAddress_ipSourceRoute_route(*this);
 809 }
 810
 811
 812
 813 #ifndef PASN_NOPRINTON
 814 const static PASN_Names Names_H225_TransportAddress_ipSourceRoute_routing[]={
 815       {"strict",0}
 816      ,{"loose",1}
 817 };
 818 #endif
 819 //
 820 // TransportAddress_ipSourceRoute_routing
 821 //
 822
 823 H225_TransportAddress_ipSourceRoute_routing::H225_TransportAddress_ipSourceRoute_routing(unsigned tag, PASN_Object::TagClass tagClass)
 824   : PASN_Choice(tag, tagClass, 2, TRUE
 825 #ifndef PASN_NOPRINTON
 826     ,(const PASN_Names *)Names_H225_TransportAddress_ipSourceRoute_routing,2
 827 #endif
 828 )
 829 {
 830 }
 831
 832
 833 BOOL H225_TransportAddress_ipSourceRoute_routing::CreateObject()
 834 {
 835   choice = (tag <= e_loose) ? new PASN_Null() : NULL;
 836   return choice != NULL;
 837 }
 838
 839
 840 PObject * H225_TransportAddress_ipSourceRoute_routing::Clone() const
 841 {
 842 #ifndef PASN_LEANANDMEAN
 843   PAssert(IsClass(H225_TransportAddress_ipSourceRoute_routing::Class()), PInvalidCast);
 844 #endif
 845   return new H225_TransportAddress_ipSourceRoute_routing(*this);
 846 }
 847
 848
 849 //
 850 // ArrayOf_RTPSession
 851 //
 852
 853 H225_ArrayOf_RTPSession::H225_ArrayOf_RTPSession(unsigned tag, PASN_Object::TagClass tagClass)
 854   : PASN_Array(tag, tagClass)
 855 {
 856 }
 857
 858
 859 PASN_Object * H225_ArrayOf_RTPSession::CreateObject() const
 860 {
 861   return new H225_RTPSession;
 862 }
 863
 864
 865 H225_RTPSession & H225_ArrayOf_RTPSession::operator[](PINDEX i) const
 866 {
 867   return (H225_RTPSession &)array[i];
 868 }
 869
 870
 871 PObject * H225_ArrayOf_RTPSession::Clone() const
 872 {
 873 #ifndef PASN_LEANANDMEAN
 874   PAssert(IsClass(H225_ArrayOf_RTPSession::Class()), PInvalidCast);
 875 #endif
 876   return new H225_ArrayOf_RTPSession(*this);
 877 }
 878
 879
 880 //
 881 // ArrayOf_TransportChannelInfo
 882 //
 883
 884 H225_ArrayOf_TransportChannelInfo::H225_ArrayOf_TransportChannelInfo(unsigned tag, PASN_Object::TagClass tagClass)
 885   : PASN_Array(tag, tagClass)
 886 {
 887 }
 888
 889
 890 PASN_Object * H225_ArrayOf_TransportChannelInfo::CreateObject() const
 891 {
 892   return new H225_TransportChannelInfo;
 893 }
 894
 895
 896 H225_TransportChannelInfo & H225_ArrayOf_TransportChannelInfo::operator[](PINDEX i) const
 897 {
 898   return (H225_TransportChannelInfo &)array[i];
 899 }
 900
 901
 902 PObject * H225_ArrayOf_TransportChannelInfo::Clone() const
 903 {
 904 #ifndef PASN_LEANANDMEAN
 905   PAssert(IsClass(H225_ArrayOf_TransportChannelInfo::Class()), PInvalidCast);
 906 #endif
 907   return new H225_ArrayOf_TransportChannelInfo(*this);
 908 }
 909
 910
 911 //
 912 // ArrayOf_ConferenceIdentifier
 913 //
 914
 915 H225_ArrayOf_ConferenceIdentifier::H225_ArrayOf_ConferenceIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
 916   : PASN_Array(tag, tagClass)
 917 {
 918 }
 919
 920
 921 PASN_Object * H225_ArrayOf_ConferenceIdentifier::CreateObject() const
 922 {
 923   return new H225_ConferenceIdentifier;
 924 }
 925
 926
 927 H225_ConferenceIdentifier & H225_ArrayOf_ConferenceIdentifier::operator[](PINDEX i) const
 928 {
 929   return (H225_ConferenceIdentifier &)array[i];
 930 }
 931
 932
 933 PObject * H225_ArrayOf_ConferenceIdentifier::Clone() const
 934 {
 935 #ifndef PASN_LEANANDMEAN
 936   PAssert(IsClass(H225_ArrayOf_ConferenceIdentifier::Class()), PInvalidCast);
 937 #endif
 938   return new H225_ArrayOf_ConferenceIdentifier(*this);
 939 }
 940
 941
 942 //
 943 // InfoRequestResponse_perCallInfo_subtype_pdu
 944 //
 945
 946 H225_InfoRequestResponse_perCallInfo_subtype_pdu::H225_InfoRequestResponse_perCallInfo_subtype_pdu(unsigned tag, PASN_Object::TagClass tagClass)
 947   : PASN_Array(tag, tagClass)
 948 {
 949 }
 950
 951
 952 PASN_Object * H225_InfoRequestResponse_perCallInfo_subtype_pdu::CreateObject() const
 953 {
 954   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype;
 955 }
 956
 957
 958 H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype & H225_InfoRequestResponse_perCallInfo_subtype_pdu::operator[](PINDEX i) const
 959 {
 960   return (H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype &)array[i];
 961 }
 962
 963
 964 PObject * H225_InfoRequestResponse_perCallInfo_subtype_pdu::Clone() const
 965 {
 966 #ifndef PASN_LEANANDMEAN
 967   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype_pdu::Class()), PInvalidCast);
 968 #endif
 969   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu(*this);
 970 }
 971
 972
 973 //
 974 // Status-UUIE
 975 //
 976
 977 H225_Status_UUIE::H225_Status_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
 978   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
 979 {
 980 }
 981
 982
 983 #ifndef PASN_NOPRINTON
 984 void H225_Status_UUIE::PrintOn(ostream & strm) const
 985 {
 986   int indent = strm.precision() + 2;
 987   strm << "{\n";
 988   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
 989   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
 990   if (HasOptionalField(e_tokens))
 991     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
 992   if (HasOptionalField(e_cryptoTokens))
 993     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
 994   strm << setw(indent-1) << setprecision(indent-2) << "}";
 995 }
 996 #endif
 997
 998
 999 PObject::Comparison H225_Status_UUIE::Compare(const PObject & obj) const
1000 {
1001 #ifndef PASN_LEANANDMEAN
1002   PAssert(PIsDescendant(&obj, H225_Status_UUIE), PInvalidCast);
1003 #endif
1004   const H225_Status_UUIE & other = (const H225_Status_UUIE &)obj;
1005
1006   Comparison result;
1007
1008   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
1009     return result;
1010   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
1011     return result;
1012   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
1013     return result;
1014   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
1015     return result;
1016
1017   return PASN_Sequence::Compare(other);
1018 }
1019
1020
1021 PINDEX H225_Status_UUIE::GetDataLength() const
1022 {
1023   PINDEX length = 0;
1024   length += m_protocolIdentifier.GetObjectLength();
1025   length += m_callIdentifier.GetObjectLength();
1026   if (HasOptionalField(e_tokens))
1027     length += m_tokens.GetObjectLength();
1028   if (HasOptionalField(e_cryptoTokens))
1029     length += m_cryptoTokens.GetObjectLength();
1030   return length;
1031 }
1032
1033
1034 BOOL H225_Status_UUIE::Decode(PASN_Stream & strm)
1035 {
1036   if (!PreambleDecode(strm))
1037     return FALSE;
1038
1039   if (!m_protocolIdentifier.Decode(strm))
1040     return FALSE;
1041   if (!m_callIdentifier.Decode(strm))
1042     return FALSE;
1043   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
1044     return FALSE;
1045   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
1046     return FALSE;
1047
1048   return UnknownExtensionsDecode(strm);
1049 }
1050
1051
1052 void H225_Status_UUIE::Encode(PASN_Stream & strm) const
1053 {
1054   PreambleEncode(strm);
1055
1056   m_protocolIdentifier.Encode(strm);
1057   m_callIdentifier.Encode(strm);
1058   if (HasOptionalField(e_tokens))
1059     m_tokens.Encode(strm);
1060   if (HasOptionalField(e_cryptoTokens))
1061     m_cryptoTokens.Encode(strm);
1062
1063   UnknownExtensionsEncode(strm);
1064 }
1065
1066
1067 PObject * H225_Status_UUIE::Clone() const
1068 {
1069 #ifndef PASN_LEANANDMEAN
1070   PAssert(IsClass(H225_Status_UUIE::Class()), PInvalidCast);
1071 #endif
1072   return new H225_Status_UUIE(*this);
1073 }
1074
1075
1076 //
1077 // StatusInquiry-UUIE
1078 //
1079
1080 H225_StatusInquiry_UUIE::H225_StatusInquiry_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
1081   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1082 {
1083 }
1084
1085
1086 #ifndef PASN_NOPRINTON
1087 void H225_StatusInquiry_UUIE::PrintOn(ostream & strm) const
1088 {
1089   int indent = strm.precision() + 2;
1090   strm << "{\n";
1091   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
1092   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
1093   if (HasOptionalField(e_tokens))
1094     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
1095   if (HasOptionalField(e_cryptoTokens))
1096     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
1097   strm << setw(indent-1) << setprecision(indent-2) << "}";
1098 }
1099 #endif
1100
1101
1102 PObject::Comparison H225_StatusInquiry_UUIE::Compare(const PObject & obj) const
1103 {
1104 #ifndef PASN_LEANANDMEAN
1105   PAssert(PIsDescendant(&obj, H225_StatusInquiry_UUIE), PInvalidCast);
1106 #endif
1107   const H225_StatusInquiry_UUIE & other = (const H225_StatusInquiry_UUIE &)obj;
1108
1109   Comparison result;
1110
1111   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
1112     return result;
1113   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
1114     return result;
1115   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
1116     return result;
1117   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
1118     return result;
1119
1120   return PASN_Sequence::Compare(other);
1121 }
1122
1123
1124 PINDEX H225_StatusInquiry_UUIE::GetDataLength() const
1125 {
1126   PINDEX length = 0;
1127   length += m_protocolIdentifier.GetObjectLength();
1128   length += m_callIdentifier.GetObjectLength();
1129   if (HasOptionalField(e_tokens))
1130     length += m_tokens.GetObjectLength();
1131   if (HasOptionalField(e_cryptoTokens))
1132     length += m_cryptoTokens.GetObjectLength();
1133   return length;
1134 }
1135
1136
1137 BOOL H225_StatusInquiry_UUIE::Decode(PASN_Stream & strm)
1138 {
1139   if (!PreambleDecode(strm))
1140     return FALSE;
1141
1142   if (!m_protocolIdentifier.Decode(strm))
1143     return FALSE;
1144   if (!m_callIdentifier.Decode(strm))
1145     return FALSE;
1146   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
1147     return FALSE;
1148   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
1149     return FALSE;
1150
1151   return UnknownExtensionsDecode(strm);
1152 }
1153
1154
1155 void H225_StatusInquiry_UUIE::Encode(PASN_Stream & strm) const
1156 {
1157   PreambleEncode(strm);
1158
1159   m_protocolIdentifier.Encode(strm);
1160   m_callIdentifier.Encode(strm);
1161   if (HasOptionalField(e_tokens))
1162     m_tokens.Encode(strm);
1163   if (HasOptionalField(e_cryptoTokens))
1164     m_cryptoTokens.Encode(strm);
1165
1166   UnknownExtensionsEncode(strm);
1167 }
1168
1169
1170 PObject * H225_StatusInquiry_UUIE::Clone() const
1171 {
1172 #ifndef PASN_LEANANDMEAN
1173   PAssert(IsClass(H225_StatusInquiry_UUIE::Class()), PInvalidCast);
1174 #endif
1175   return new H225_StatusInquiry_UUIE(*this);
1176 }
1177
1178
1179 //
1180 // SetupAcknowledge-UUIE
1181 //
1182
1183 H225_SetupAcknowledge_UUIE::H225_SetupAcknowledge_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
1184   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1185 {
1186 }
1187
1188
1189 #ifndef PASN_NOPRINTON
1190 void H225_SetupAcknowledge_UUIE::PrintOn(ostream & strm) const
1191 {
1192   int indent = strm.precision() + 2;
1193   strm << "{\n";
1194   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
1195   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
1196   if (HasOptionalField(e_tokens))
1197     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
1198   if (HasOptionalField(e_cryptoTokens))
1199     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
1200   strm << setw(indent-1) << setprecision(indent-2) << "}";
1201 }
1202 #endif
1203
1204
1205 PObject::Comparison H225_SetupAcknowledge_UUIE::Compare(const PObject & obj) const
1206 {
1207 #ifndef PASN_LEANANDMEAN
1208   PAssert(PIsDescendant(&obj, H225_SetupAcknowledge_UUIE), PInvalidCast);
1209 #endif
1210   const H225_SetupAcknowledge_UUIE & other = (const H225_SetupAcknowledge_UUIE &)obj;
1211
1212   Comparison result;
1213
1214   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
1215     return result;
1216   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
1217     return result;
1218   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
1219     return result;
1220   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
1221     return result;
1222
1223   return PASN_Sequence::Compare(other);
1224 }
1225
1226
1227 PINDEX H225_SetupAcknowledge_UUIE::GetDataLength() const
1228 {
1229   PINDEX length = 0;
1230   length += m_protocolIdentifier.GetObjectLength();
1231   length += m_callIdentifier.GetObjectLength();
1232   if (HasOptionalField(e_tokens))
1233     length += m_tokens.GetObjectLength();
1234   if (HasOptionalField(e_cryptoTokens))
1235     length += m_cryptoTokens.GetObjectLength();
1236   return length;
1237 }
1238
1239
1240 BOOL H225_SetupAcknowledge_UUIE::Decode(PASN_Stream & strm)
1241 {
1242   if (!PreambleDecode(strm))
1243     return FALSE;
1244
1245   if (!m_protocolIdentifier.Decode(strm))
1246     return FALSE;
1247   if (!m_callIdentifier.Decode(strm))
1248     return FALSE;
1249   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
1250     return FALSE;
1251   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
1252     return FALSE;
1253
1254   return UnknownExtensionsDecode(strm);
1255 }
1256
1257
1258 void H225_SetupAcknowledge_UUIE::Encode(PASN_Stream & strm) const
1259 {
1260   PreambleEncode(strm);
1261
1262   m_protocolIdentifier.Encode(strm);
1263   m_callIdentifier.Encode(strm);
1264   if (HasOptionalField(e_tokens))
1265     m_tokens.Encode(strm);
1266   if (HasOptionalField(e_cryptoTokens))
1267     m_cryptoTokens.Encode(strm);
1268
1269   UnknownExtensionsEncode(strm);
1270 }
1271
1272
1273 PObject * H225_SetupAcknowledge_UUIE::Clone() const
1274 {
1275 #ifndef PASN_LEANANDMEAN
1276   PAssert(IsClass(H225_SetupAcknowledge_UUIE::Class()), PInvalidCast);
1277 #endif
1278   return new H225_SetupAcknowledge_UUIE(*this);
1279 }
1280
1281
1282 //
1283 // Notify-UUIE
1284 //
1285
1286 H225_Notify_UUIE::H225_Notify_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
1287   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
1288 {
1289 }
1290
1291
1292 #ifndef PASN_NOPRINTON
1293 void H225_Notify_UUIE::PrintOn(ostream & strm) const
1294 {
1295   int indent = strm.precision() + 2;
1296   strm << "{\n";
1297   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
1298   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
1299   if (HasOptionalField(e_tokens))
1300     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
1301   if (HasOptionalField(e_cryptoTokens))
1302     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
1303   strm << setw(indent-1) << setprecision(indent-2) << "}";
1304 }
1305 #endif
1306
1307
1308 PObject::Comparison H225_Notify_UUIE::Compare(const PObject & obj) const
1309 {
1310 #ifndef PASN_LEANANDMEAN
1311   PAssert(PIsDescendant(&obj, H225_Notify_UUIE), PInvalidCast);
1312 #endif
1313   const H225_Notify_UUIE & other = (const H225_Notify_UUIE &)obj;
1314
1315   Comparison result;
1316
1317   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
1318     return result;
1319   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
1320     return result;
1321   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
1322     return result;
1323   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
1324     return result;
1325
1326   return PASN_Sequence::Compare(other);
1327 }
1328
1329
1330 PINDEX H225_Notify_UUIE::GetDataLength() const
1331 {
1332   PINDEX length = 0;
1333   length += m_protocolIdentifier.GetObjectLength();
1334   length += m_callIdentifier.GetObjectLength();
1335   if (HasOptionalField(e_tokens))
1336     length += m_tokens.GetObjectLength();
1337   if (HasOptionalField(e_cryptoTokens))
1338     length += m_cryptoTokens.GetObjectLength();
1339   return length;
1340 }
1341
1342
1343 BOOL H225_Notify_UUIE::Decode(PASN_Stream & strm)
1344 {
1345   if (!PreambleDecode(strm))
1346     return FALSE;
1347
1348   if (!m_protocolIdentifier.Decode(strm))
1349     return FALSE;
1350   if (!m_callIdentifier.Decode(strm))
1351     return FALSE;
1352   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
1353     return FALSE;
1354   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
1355     return FALSE;
1356
1357   return UnknownExtensionsDecode(strm);
1358 }
1359
1360
1361 void H225_Notify_UUIE::Encode(PASN_Stream & strm) const
1362 {
1363   PreambleEncode(strm);
1364
1365   m_protocolIdentifier.Encode(strm);
1366   m_callIdentifier.Encode(strm);
1367   if (HasOptionalField(e_tokens))
1368     m_tokens.Encode(strm);
1369   if (HasOptionalField(e_cryptoTokens))
1370     m_cryptoTokens.Encode(strm);
1371
1372   UnknownExtensionsEncode(strm);
1373 }
1374
1375
1376 PObject * H225_Notify_UUIE::Clone() const
1377 {
1378 #ifndef PASN_LEANANDMEAN
1379   PAssert(IsClass(H225_Notify_UUIE::Class()), PInvalidCast);
1380 #endif
1381   return new H225_Notify_UUIE(*this);
1382 }
1383
1384
1385 //
1386 // VendorIdentifier
1387 //
1388
1389 H225_VendorIdentifier::H225_VendorIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
1390   : PASN_Sequence(tag, tagClass, 2, TRUE, 1)
1391 {
1392   m_productId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
1393   m_versionId.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
1394 }
1395
1396
1397 #ifndef PASN_NOPRINTON
1398 void H225_VendorIdentifier::PrintOn(ostream & strm) const
1399 {
1400   int indent = strm.precision() + 2;
1401   strm << "{\n";
1402   strm << setw(indent+9) << "vendor = " << setprecision(indent) << m_vendor << '\n';
1403   if (HasOptionalField(e_productId))
1404     strm << setw(indent+12) << "productId = " << setprecision(indent) << m_productId << '\n';
1405   if (HasOptionalField(e_versionId))
1406     strm << setw(indent+12) << "versionId = " << setprecision(indent) << m_versionId << '\n';
1407   if (HasOptionalField(e_enterpriseNumber))
1408     strm << setw(indent+19) << "enterpriseNumber = " << setprecision(indent) << m_enterpriseNumber << '\n';
1409   strm << setw(indent-1) << setprecision(indent-2) << "}";
1410 }
1411 #endif
1412
1413
1414 PObject::Comparison H225_VendorIdentifier::Compare(const PObject & obj) const
1415 {
1416 #ifndef PASN_LEANANDMEAN
1417   PAssert(PIsDescendant(&obj, H225_VendorIdentifier), PInvalidCast);
1418 #endif
1419   const H225_VendorIdentifier & other = (const H225_VendorIdentifier &)obj;
1420
1421   Comparison result;
1422
1423   if ((result = m_vendor.Compare(other.m_vendor)) != EqualTo)
1424     return result;
1425   if ((result = m_productId.Compare(other.m_productId)) != EqualTo)
1426     return result;
1427   if ((result = m_versionId.Compare(other.m_versionId)) != EqualTo)
1428     return result;
1429
1430   return PASN_Sequence::Compare(other);
1431 }
1432
1433
1434 PINDEX H225_VendorIdentifier::GetDataLength() const
1435 {
1436   PINDEX length = 0;
1437   length += m_vendor.GetObjectLength();
1438   if (HasOptionalField(e_productId))
1439     length += m_productId.GetObjectLength();
1440   if (HasOptionalField(e_versionId))
1441     length += m_versionId.GetObjectLength();
1442   return length;
1443 }
1444
1445
1446 BOOL H225_VendorIdentifier::Decode(PASN_Stream & strm)
1447 {
1448   if (!PreambleDecode(strm))
1449     return FALSE;
1450
1451   if (!m_vendor.Decode(strm))
1452     return FALSE;
1453   if (HasOptionalField(e_productId) && !m_productId.Decode(strm))
1454     return FALSE;
1455   if (HasOptionalField(e_versionId) && !m_versionId.Decode(strm))
1456     return FALSE;
1457   if (!KnownExtensionDecode(strm, e_enterpriseNumber, m_enterpriseNumber))
1458     return FALSE;
1459
1460   return UnknownExtensionsDecode(strm);
1461 }
1462
1463
1464 void H225_VendorIdentifier::Encode(PASN_Stream & strm) const
1465 {
1466   PreambleEncode(strm);
1467
1468   m_vendor.Encode(strm);
1469   if (HasOptionalField(e_productId))
1470     m_productId.Encode(strm);
1471   if (HasOptionalField(e_versionId))
1472     m_versionId.Encode(strm);
1473   KnownExtensionEncode(strm, e_enterpriseNumber, m_enterpriseNumber);
1474
1475   UnknownExtensionsEncode(strm);
1476 }
1477
1478
1479 PObject * H225_VendorIdentifier::Clone() const
1480 {
1481 #ifndef PASN_LEANANDMEAN
1482   PAssert(IsClass(H225_VendorIdentifier::Class()), PInvalidCast);
1483 #endif
1484   return new H225_VendorIdentifier(*this);
1485 }
1486
1487
1488 //
1489 // TunnelledProtocol
1490 //
1491
1492 H225_TunnelledProtocol::H225_TunnelledProtocol(unsigned tag, PASN_Object::TagClass tagClass)
1493   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
1494 {
1495   m_subIdentifier.SetConstraints(PASN_Object::FixedConstraint, 1, 64);
1496 }
1497
1498
1499 #ifndef PASN_NOPRINTON
1500 void H225_TunnelledProtocol::PrintOn(ostream & strm) const
1501 {
1502   int indent = strm.precision() + 2;
1503   strm << "{\n";
1504   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
1505   if (HasOptionalField(e_subIdentifier))
1506     strm << setw(indent+16) << "subIdentifier = " << setprecision(indent) << m_subIdentifier << '\n';
1507   strm << setw(indent-1) << setprecision(indent-2) << "}";
1508 }
1509 #endif
1510
1511
1512 PObject::Comparison H225_TunnelledProtocol::Compare(const PObject & obj) const
1513 {
1514 #ifndef PASN_LEANANDMEAN
1515   PAssert(PIsDescendant(&obj, H225_TunnelledProtocol), PInvalidCast);
1516 #endif
1517   const H225_TunnelledProtocol & other = (const H225_TunnelledProtocol &)obj;
1518
1519   Comparison result;
1520
1521   if ((result = m_id.Compare(other.m_id)) != EqualTo)
1522     return result;
1523   if ((result = m_subIdentifier.Compare(other.m_subIdentifier)) != EqualTo)
1524     return result;
1525
1526   return PASN_Sequence::Compare(other);
1527 }
1528
1529
1530 PINDEX H225_TunnelledProtocol::GetDataLength() const
1531 {
1532   PINDEX length = 0;
1533   length += m_id.GetObjectLength();
1534   if (HasOptionalField(e_subIdentifier))
1535     length += m_subIdentifier.GetObjectLength();
1536   return length;
1537 }
1538
1539
1540 BOOL H225_TunnelledProtocol::Decode(PASN_Stream & strm)
1541 {
1542   if (!PreambleDecode(strm))
1543     return FALSE;
1544
1545   if (!m_id.Decode(strm))
1546     return FALSE;
1547   if (HasOptionalField(e_subIdentifier) && !m_subIdentifier.Decode(strm))
1548     return FALSE;
1549
1550   return UnknownExtensionsDecode(strm);
1551 }
1552
1553
1554 void H225_TunnelledProtocol::Encode(PASN_Stream & strm) const
1555 {
1556   PreambleEncode(strm);
1557
1558   m_id.Encode(strm);
1559   if (HasOptionalField(e_subIdentifier))
1560     m_subIdentifier.Encode(strm);
1561
1562   UnknownExtensionsEncode(strm);
1563 }
1564
1565
1566 PObject * H225_TunnelledProtocol::Clone() const
1567 {
1568 #ifndef PASN_LEANANDMEAN
1569   PAssert(IsClass(H225_TunnelledProtocol::Class()), PInvalidCast);
1570 #endif
1571   return new H225_TunnelledProtocol(*this);
1572 }
1573
1574
1575 //
1576 // NonStandardParameter
1577 //
1578
1579 H225_NonStandardParameter::H225_NonStandardParameter(unsigned tag, PASN_Object::TagClass tagClass)
1580   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
1581 {
1582 }
1583
1584
1585 #ifndef PASN_NOPRINTON
1586 void H225_NonStandardParameter::PrintOn(ostream & strm) const
1587 {
1588   int indent = strm.precision() + 2;
1589   strm << "{\n";
1590   strm << setw(indent+24) << "nonStandardIdentifier = " << setprecision(indent) << m_nonStandardIdentifier << '\n';
1591   strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
1592   strm << setw(indent-1) << setprecision(indent-2) << "}";
1593 }
1594 #endif
1595
1596
1597 PObject::Comparison H225_NonStandardParameter::Compare(const PObject & obj) const
1598 {
1599 #ifndef PASN_LEANANDMEAN
1600   PAssert(PIsDescendant(&obj, H225_NonStandardParameter), PInvalidCast);
1601 #endif
1602   const H225_NonStandardParameter & other = (const H225_NonStandardParameter &)obj;
1603
1604   Comparison result;
1605
1606   if ((result = m_nonStandardIdentifier.Compare(other.m_nonStandardIdentifier)) != EqualTo)
1607     return result;
1608   if ((result = m_data.Compare(other.m_data)) != EqualTo)
1609     return result;
1610
1611   return PASN_Sequence::Compare(other);
1612 }
1613
1614
1615 PINDEX H225_NonStandardParameter::GetDataLength() const
1616 {
1617   PINDEX length = 0;
1618   length += m_nonStandardIdentifier.GetObjectLength();
1619   length += m_data.GetObjectLength();
1620   return length;
1621 }
1622
1623
1624 BOOL H225_NonStandardParameter::Decode(PASN_Stream & strm)
1625 {
1626   if (!PreambleDecode(strm))
1627     return FALSE;
1628
1629   if (!m_nonStandardIdentifier.Decode(strm))
1630     return FALSE;
1631   if (!m_data.Decode(strm))
1632     return FALSE;
1633
1634   return UnknownExtensionsDecode(strm);
1635 }
1636
1637
1638 void H225_NonStandardParameter::Encode(PASN_Stream & strm) const
1639 {
1640   PreambleEncode(strm);
1641
1642   m_nonStandardIdentifier.Encode(strm);
1643   m_data.Encode(strm);
1644
1645   UnknownExtensionsEncode(strm);
1646 }
1647
1648
1649 PObject * H225_NonStandardParameter::Clone() const
1650 {
1651 #ifndef PASN_LEANANDMEAN
1652   PAssert(IsClass(H225_NonStandardParameter::Class()), PInvalidCast);
1653 #endif
1654   return new H225_NonStandardParameter(*this);
1655 }
1656
1657
1658 //
1659 // PublicPartyNumber
1660 //
1661
1662 H225_PublicPartyNumber::H225_PublicPartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
1663   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
1664 {
1665 }
1666
1667
1668 #ifndef PASN_NOPRINTON
1669 void H225_PublicPartyNumber::PrintOn(ostream & strm) const
1670 {
1671   int indent = strm.precision() + 2;
1672   strm << "{\n";
1673   strm << setw(indent+21) << "publicTypeOfNumber = " << setprecision(indent) << m_publicTypeOfNumber << '\n';
1674   strm << setw(indent+21) << "publicNumberDigits = " << setprecision(indent) << m_publicNumberDigits << '\n';
1675   strm << setw(indent-1) << setprecision(indent-2) << "}";
1676 }
1677 #endif
1678
1679
1680 PObject::Comparison H225_PublicPartyNumber::Compare(const PObject & obj) const
1681 {
1682 #ifndef PASN_LEANANDMEAN
1683   PAssert(PIsDescendant(&obj, H225_PublicPartyNumber), PInvalidCast);
1684 #endif
1685   const H225_PublicPartyNumber & other = (const H225_PublicPartyNumber &)obj;
1686
1687   Comparison result;
1688
1689   if ((result = m_publicTypeOfNumber.Compare(other.m_publicTypeOfNumber)) != EqualTo)
1690     return result;
1691   if ((result = m_publicNumberDigits.Compare(other.m_publicNumberDigits)) != EqualTo)
1692     return result;
1693
1694   return PASN_Sequence::Compare(other);
1695 }
1696
1697
1698 PINDEX H225_PublicPartyNumber::GetDataLength() const
1699 {
1700   PINDEX length = 0;
1701   length += m_publicTypeOfNumber.GetObjectLength();
1702   length += m_publicNumberDigits.GetObjectLength();
1703   return length;
1704 }
1705
1706
1707 BOOL H225_PublicPartyNumber::Decode(PASN_Stream & strm)
1708 {
1709   if (!PreambleDecode(strm))
1710     return FALSE;
1711
1712   if (!m_publicTypeOfNumber.Decode(strm))
1713     return FALSE;
1714   if (!m_publicNumberDigits.Decode(strm))
1715     return FALSE;
1716
1717   return UnknownExtensionsDecode(strm);
1718 }
1719
1720
1721 void H225_PublicPartyNumber::Encode(PASN_Stream & strm) const
1722 {
1723   PreambleEncode(strm);
1724
1725   m_publicTypeOfNumber.Encode(strm);
1726   m_publicNumberDigits.Encode(strm);
1727
1728   UnknownExtensionsEncode(strm);
1729 }
1730
1731
1732 PObject * H225_PublicPartyNumber::Clone() const
1733 {
1734 #ifndef PASN_LEANANDMEAN
1735   PAssert(IsClass(H225_PublicPartyNumber::Class()), PInvalidCast);
1736 #endif
1737   return new H225_PublicPartyNumber(*this);
1738 }
1739
1740
1741 //
1742 // PrivatePartyNumber
1743 //
1744
1745 H225_PrivatePartyNumber::H225_PrivatePartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
1746   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
1747 {
1748 }
1749
1750
1751 #ifndef PASN_NOPRINTON
1752 void H225_PrivatePartyNumber::PrintOn(ostream & strm) const
1753 {
1754   int indent = strm.precision() + 2;
1755   strm << "{\n";
1756   strm << setw(indent+22) << "privateTypeOfNumber = " << setprecision(indent) << m_privateTypeOfNumber << '\n';
1757   strm << setw(indent+22) << "privateNumberDigits = " << setprecision(indent) << m_privateNumberDigits << '\n';
1758   strm << setw(indent-1) << setprecision(indent-2) << "}";
1759 }
1760 #endif
1761
1762
1763 PObject::Comparison H225_PrivatePartyNumber::Compare(const PObject & obj) const
1764 {
1765 #ifndef PASN_LEANANDMEAN
1766   PAssert(PIsDescendant(&obj, H225_PrivatePartyNumber), PInvalidCast);
1767 #endif
1768   const H225_PrivatePartyNumber & other = (const H225_PrivatePartyNumber &)obj;
1769
1770   Comparison result;
1771
1772   if ((result = m_privateTypeOfNumber.Compare(other.m_privateTypeOfNumber)) != EqualTo)
1773     return result;
1774   if ((result = m_privateNumberDigits.Compare(other.m_privateNumberDigits)) != EqualTo)
1775     return result;
1776
1777   return PASN_Sequence::Compare(other);
1778 }
1779
1780
1781 PINDEX H225_PrivatePartyNumber::GetDataLength() const
1782 {
1783   PINDEX length = 0;
1784   length += m_privateTypeOfNumber.GetObjectLength();
1785   length += m_privateNumberDigits.GetObjectLength();
1786   return length;
1787 }
1788
1789
1790 BOOL H225_PrivatePartyNumber::Decode(PASN_Stream & strm)
1791 {
1792   if (!PreambleDecode(strm))
1793     return FALSE;
1794
1795   if (!m_privateTypeOfNumber.Decode(strm))
1796     return FALSE;
1797   if (!m_privateNumberDigits.Decode(strm))
1798     return FALSE;
1799
1800   return UnknownExtensionsDecode(strm);
1801 }
1802
1803
1804 void H225_PrivatePartyNumber::Encode(PASN_Stream & strm) const
1805 {
1806   PreambleEncode(strm);
1807
1808   m_privateTypeOfNumber.Encode(strm);
1809   m_privateNumberDigits.Encode(strm);
1810
1811   UnknownExtensionsEncode(strm);
1812 }
1813
1814
1815 PObject * H225_PrivatePartyNumber::Clone() const
1816 {
1817 #ifndef PASN_LEANANDMEAN
1818   PAssert(IsClass(H225_PrivatePartyNumber::Class()), PInvalidCast);
1819 #endif
1820   return new H225_PrivatePartyNumber(*this);
1821 }
1822
1823
1824 //
1825 // ANSI-41-UIM
1826 //
1827
1828 H225_ANSI_41_UIM::H225_ANSI_41_UIM(unsigned tag, PASN_Object::TagClass tagClass)
1829   : PASN_Sequence(tag, tagClass, 11, TRUE, 0)
1830 {
1831   m_imsi.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1832   m_min.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1833   m_mdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1834   m_msisdn.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1835   m_esn.SetConstraints(PASN_Object::FixedConstraint, 16);
1836   m_mscid.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1837   m_systemMyTypeCode.SetConstraints(PASN_Object::FixedConstraint, 1);
1838   m_systemAccessType.SetConstraints(PASN_Object::FixedConstraint, 1);
1839   m_qualificationInformationCode.SetConstraints(PASN_Object::FixedConstraint, 1);
1840   m_sesn.SetConstraints(PASN_Object::FixedConstraint, 16);
1841   m_soc.SetConstraints(PASN_Object::FixedConstraint, 3, 16);
1842 }
1843
1844
1845 #ifndef PASN_NOPRINTON
1846 void H225_ANSI_41_UIM::PrintOn(ostream & strm) const
1847 {
1848   int indent = strm.precision() + 2;
1849   strm << "{\n";
1850   if (HasOptionalField(e_imsi))
1851     strm << setw(indent+7) << "imsi = " << setprecision(indent) << m_imsi << '\n';
1852   if (HasOptionalField(e_min))
1853     strm << setw(indent+6) << "min = " << setprecision(indent) << m_min << '\n';
1854   if (HasOptionalField(e_mdn))
1855     strm << setw(indent+6) << "mdn = " << setprecision(indent) << m_mdn << '\n';
1856   if (HasOptionalField(e_msisdn))
1857     strm << setw(indent+9) << "msisdn = " << setprecision(indent) << m_msisdn << '\n';
1858   if (HasOptionalField(e_esn))
1859     strm << setw(indent+6) << "esn = " << setprecision(indent) << m_esn << '\n';
1860   if (HasOptionalField(e_mscid))
1861     strm << setw(indent+8) << "mscid = " << setprecision(indent) << m_mscid << '\n';
1862   strm << setw(indent+12) << "system_id = " << setprecision(indent) << m_system_id << '\n';
1863   if (HasOptionalField(e_systemMyTypeCode))
1864     strm << setw(indent+19) << "systemMyTypeCode = " << setprecision(indent) << m_systemMyTypeCode << '\n';
1865   if (HasOptionalField(e_systemAccessType))
1866     strm << setw(indent+19) << "systemAccessType = " << setprecision(indent) << m_systemAccessType << '\n';
1867   if (HasOptionalField(e_qualificationInformationCode))
1868     strm << setw(indent+31) << "qualificationInformationCode = " << setprecision(indent) << m_qualificationInformationCode << '\n';
1869   if (HasOptionalField(e_sesn))
1870     strm << setw(indent+7) << "sesn = " << setprecision(indent) << m_sesn << '\n';
1871   if (HasOptionalField(e_soc))
1872     strm << setw(indent+6) << "soc = " << setprecision(indent) << m_soc << '\n';
1873   strm << setw(indent-1) << setprecision(indent-2) << "}";
1874 }
1875 #endif
1876
1877
1878 PObject::Comparison H225_ANSI_41_UIM::Compare(const PObject & obj) const
1879 {
1880 #ifndef PASN_LEANANDMEAN
1881   PAssert(PIsDescendant(&obj, H225_ANSI_41_UIM), PInvalidCast);
1882 #endif
1883   const H225_ANSI_41_UIM & other = (const H225_ANSI_41_UIM &)obj;
1884
1885   Comparison result;
1886
1887   if ((result = m_imsi.Compare(other.m_imsi)) != EqualTo)
1888     return result;
1889   if ((result = m_min.Compare(other.m_min)) != EqualTo)
1890     return result;
1891   if ((result = m_mdn.Compare(other.m_mdn)) != EqualTo)
1892     return result;
1893   if ((result = m_msisdn.Compare(other.m_msisdn)) != EqualTo)
1894     return result;
1895   if ((result = m_esn.Compare(other.m_esn)) != EqualTo)
1896     return result;
1897   if ((result = m_mscid.Compare(other.m_mscid)) != EqualTo)
1898     return result;
1899   if ((result = m_system_id.Compare(other.m_system_id)) != EqualTo)
1900     return result;
1901   if ((result = m_systemMyTypeCode.Compare(other.m_systemMyTypeCode)) != EqualTo)
1902     return result;
1903   if ((result = m_systemAccessType.Compare(other.m_systemAccessType)) != EqualTo)
1904     return result;
1905   if ((result = m_qualificationInformationCode.Compare(other.m_qualificationInformationCode)) != EqualTo)
1906     return result;
1907   if ((result = m_sesn.Compare(other.m_sesn)) != EqualTo)
1908     return result;
1909   if ((result = m_soc.Compare(other.m_soc)) != EqualTo)
1910     return result;
1911
1912   return PASN_Sequence::Compare(other);
1913 }
1914
1915
1916 PINDEX H225_ANSI_41_UIM::GetDataLength() const
1917 {
1918   PINDEX length = 0;
1919   if (HasOptionalField(e_imsi))
1920     length += m_imsi.GetObjectLength();
1921   if (HasOptionalField(e_min))
1922     length += m_min.GetObjectLength();
1923   if (HasOptionalField(e_mdn))
1924     length += m_mdn.GetObjectLength();
1925   if (HasOptionalField(e_msisdn))
1926     length += m_msisdn.GetObjectLength();
1927   if (HasOptionalField(e_esn))
1928     length += m_esn.GetObjectLength();
1929   if (HasOptionalField(e_mscid))
1930     length += m_mscid.GetObjectLength();
1931   length += m_system_id.GetObjectLength();
1932   if (HasOptionalField(e_systemMyTypeCode))
1933     length += m_systemMyTypeCode.GetObjectLength();
1934   if (HasOptionalField(e_systemAccessType))
1935     length += m_systemAccessType.GetObjectLength();
1936   if (HasOptionalField(e_qualificationInformationCode))
1937     length += m_qualificationInformationCode.GetObjectLength();
1938   if (HasOptionalField(e_sesn))
1939     length += m_sesn.GetObjectLength();
1940   if (HasOptionalField(e_soc))
1941     length += m_soc.GetObjectLength();
1942   return length;
1943 }
1944
1945
1946 BOOL H225_ANSI_41_UIM::Decode(PASN_Stream & strm)
1947 {
1948   if (!PreambleDecode(strm))
1949     return FALSE;
1950
1951   if (HasOptionalField(e_imsi) && !m_imsi.Decode(strm))
1952     return FALSE;
1953   if (HasOptionalField(e_min) && !m_min.Decode(strm))
1954     return FALSE;
1955   if (HasOptionalField(e_mdn) && !m_mdn.Decode(strm))
1956     return FALSE;
1957   if (HasOptionalField(e_msisdn) && !m_msisdn.Decode(strm))
1958     return FALSE;
1959   if (HasOptionalField(e_esn) && !m_esn.Decode(strm))
1960     return FALSE;
1961   if (HasOptionalField(e_mscid) && !m_mscid.Decode(strm))
1962     return FALSE;
1963   if (!m_system_id.Decode(strm))
1964     return FALSE;
1965   if (HasOptionalField(e_systemMyTypeCode) && !m_systemMyTypeCode.Decode(strm))
1966     return FALSE;
1967   if (HasOptionalField(e_systemAccessType) && !m_systemAccessType.Decode(strm))
1968     return FALSE;
1969   if (HasOptionalField(e_qualificationInformationCode) && !m_qualificationInformationCode.Decode(strm))
1970     return FALSE;
1971   if (HasOptionalField(e_sesn) && !m_sesn.Decode(strm))
1972     return FALSE;
1973   if (HasOptionalField(e_soc) && !m_soc.Decode(strm))
1974     return FALSE;
1975
1976   return UnknownExtensionsDecode(strm);
1977 }
1978
1979
1980 void H225_ANSI_41_UIM::Encode(PASN_Stream & strm) const
1981 {
1982   PreambleEncode(strm);
1983
1984   if (HasOptionalField(e_imsi))
1985     m_imsi.Encode(strm);
1986   if (HasOptionalField(e_min))
1987     m_min.Encode(strm);
1988   if (HasOptionalField(e_mdn))
1989     m_mdn.Encode(strm);
1990   if (HasOptionalField(e_msisdn))
1991     m_msisdn.Encode(strm);
1992   if (HasOptionalField(e_esn))
1993     m_esn.Encode(strm);
1994   if (HasOptionalField(e_mscid))
1995     m_mscid.Encode(strm);
1996   m_system_id.Encode(strm);
1997   if (HasOptionalField(e_systemMyTypeCode))
1998     m_systemMyTypeCode.Encode(strm);
1999   if (HasOptionalField(e_systemAccessType))
2000     m_systemAccessType.Encode(strm);
2001   if (HasOptionalField(e_qualificationInformationCode))
2002     m_qualificationInformationCode.Encode(strm);
2003   if (HasOptionalField(e_sesn))
2004     m_sesn.Encode(strm);
2005   if (HasOptionalField(e_soc))
2006     m_soc.Encode(strm);
2007
2008   UnknownExtensionsEncode(strm);
2009 }
2010
2011
2012 PObject * H225_ANSI_41_UIM::Clone() const
2013 {
2014 #ifndef PASN_LEANANDMEAN
2015   PAssert(IsClass(H225_ANSI_41_UIM::Class()), PInvalidCast);
2016 #endif
2017   return new H225_ANSI_41_UIM(*this);
2018 }
2019
2020
2021 //
2022 // IsupPublicPartyNumber
2023 //
2024
2025 H225_IsupPublicPartyNumber::H225_IsupPublicPartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
2026   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2027 {
2028 }
2029
2030
2031 #ifndef PASN_NOPRINTON
2032 void H225_IsupPublicPartyNumber::PrintOn(ostream & strm) const
2033 {
2034   int indent = strm.precision() + 2;
2035   strm << "{\n";
2036   strm << setw(indent+18) << "natureOfAddress = " << setprecision(indent) << m_natureOfAddress << '\n';
2037   strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
2038   strm << setw(indent-1) << setprecision(indent-2) << "}";
2039 }
2040 #endif
2041
2042
2043 PObject::Comparison H225_IsupPublicPartyNumber::Compare(const PObject & obj) const
2044 {
2045 #ifndef PASN_LEANANDMEAN
2046   PAssert(PIsDescendant(&obj, H225_IsupPublicPartyNumber), PInvalidCast);
2047 #endif
2048   const H225_IsupPublicPartyNumber & other = (const H225_IsupPublicPartyNumber &)obj;
2049
2050   Comparison result;
2051
2052   if ((result = m_natureOfAddress.Compare(other.m_natureOfAddress)) != EqualTo)
2053     return result;
2054   if ((result = m_address.Compare(other.m_address)) != EqualTo)
2055     return result;
2056
2057   return PASN_Sequence::Compare(other);
2058 }
2059
2060
2061 PINDEX H225_IsupPublicPartyNumber::GetDataLength() const
2062 {
2063   PINDEX length = 0;
2064   length += m_natureOfAddress.GetObjectLength();
2065   length += m_address.GetObjectLength();
2066   return length;
2067 }
2068
2069
2070 BOOL H225_IsupPublicPartyNumber::Decode(PASN_Stream & strm)
2071 {
2072   if (!PreambleDecode(strm))
2073     return FALSE;
2074
2075   if (!m_natureOfAddress.Decode(strm))
2076     return FALSE;
2077   if (!m_address.Decode(strm))
2078     return FALSE;
2079
2080   return UnknownExtensionsDecode(strm);
2081 }
2082
2083
2084 void H225_IsupPublicPartyNumber::Encode(PASN_Stream & strm) const
2085 {
2086   PreambleEncode(strm);
2087
2088   m_natureOfAddress.Encode(strm);
2089   m_address.Encode(strm);
2090
2091   UnknownExtensionsEncode(strm);
2092 }
2093
2094
2095 PObject * H225_IsupPublicPartyNumber::Clone() const
2096 {
2097 #ifndef PASN_LEANANDMEAN
2098   PAssert(IsClass(H225_IsupPublicPartyNumber::Class()), PInvalidCast);
2099 #endif
2100   return new H225_IsupPublicPartyNumber(*this);
2101 }
2102
2103
2104 //
2105 // IsupPrivatePartyNumber
2106 //
2107
2108 H225_IsupPrivatePartyNumber::H225_IsupPrivatePartyNumber(unsigned tag, PASN_Object::TagClass tagClass)
2109   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2110 {
2111 }
2112
2113
2114 #ifndef PASN_NOPRINTON
2115 void H225_IsupPrivatePartyNumber::PrintOn(ostream & strm) const
2116 {
2117   int indent = strm.precision() + 2;
2118   strm << "{\n";
2119   strm << setw(indent+22) << "privateTypeOfNumber = " << setprecision(indent) << m_privateTypeOfNumber << '\n';
2120   strm << setw(indent+10) << "address = " << setprecision(indent) << m_address << '\n';
2121   strm << setw(indent-1) << setprecision(indent-2) << "}";
2122 }
2123 #endif
2124
2125
2126 PObject::Comparison H225_IsupPrivatePartyNumber::Compare(const PObject & obj) const
2127 {
2128 #ifndef PASN_LEANANDMEAN
2129   PAssert(PIsDescendant(&obj, H225_IsupPrivatePartyNumber), PInvalidCast);
2130 #endif
2131   const H225_IsupPrivatePartyNumber & other = (const H225_IsupPrivatePartyNumber &)obj;
2132
2133   Comparison result;
2134
2135   if ((result = m_privateTypeOfNumber.Compare(other.m_privateTypeOfNumber)) != EqualTo)
2136     return result;
2137   if ((result = m_address.Compare(other.m_address)) != EqualTo)
2138     return result;
2139
2140   return PASN_Sequence::Compare(other);
2141 }
2142
2143
2144 PINDEX H225_IsupPrivatePartyNumber::GetDataLength() const
2145 {
2146   PINDEX length = 0;
2147   length += m_privateTypeOfNumber.GetObjectLength();
2148   length += m_address.GetObjectLength();
2149   return length;
2150 }
2151
2152
2153 BOOL H225_IsupPrivatePartyNumber::Decode(PASN_Stream & strm)
2154 {
2155   if (!PreambleDecode(strm))
2156     return FALSE;
2157
2158   if (!m_privateTypeOfNumber.Decode(strm))
2159     return FALSE;
2160   if (!m_address.Decode(strm))
2161     return FALSE;
2162
2163   return UnknownExtensionsDecode(strm);
2164 }
2165
2166
2167 void H225_IsupPrivatePartyNumber::Encode(PASN_Stream & strm) const
2168 {
2169   PreambleEncode(strm);
2170
2171   m_privateTypeOfNumber.Encode(strm);
2172   m_address.Encode(strm);
2173
2174   UnknownExtensionsEncode(strm);
2175 }
2176
2177
2178 PObject * H225_IsupPrivatePartyNumber::Clone() const
2179 {
2180 #ifndef PASN_LEANANDMEAN
2181   PAssert(IsClass(H225_IsupPrivatePartyNumber::Class()), PInvalidCast);
2182 #endif
2183   return new H225_IsupPrivatePartyNumber(*this);
2184 }
2185
2186
2187 //
2188 // AlternateTransportAddresses
2189 //
2190
2191 H225_AlternateTransportAddresses::H225_AlternateTransportAddresses(unsigned tag, PASN_Object::TagClass tagClass)
2192   : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
2193 {
2194 }
2195
2196
2197 #ifndef PASN_NOPRINTON
2198 void H225_AlternateTransportAddresses::PrintOn(ostream & strm) const
2199 {
2200   int indent = strm.precision() + 2;
2201   strm << "{\n";
2202   if (HasOptionalField(e_annexE))
2203     strm << setw(indent+9) << "annexE = " << setprecision(indent) << m_annexE << '\n';
2204   if (HasOptionalField(e_sctp))
2205     strm << setw(indent+7) << "sctp = " << setprecision(indent) << m_sctp << '\n';
2206   strm << setw(indent-1) << setprecision(indent-2) << "}";
2207 }
2208 #endif
2209
2210
2211 PObject::Comparison H225_AlternateTransportAddresses::Compare(const PObject & obj) const
2212 {
2213 #ifndef PASN_LEANANDMEAN
2214   PAssert(PIsDescendant(&obj, H225_AlternateTransportAddresses), PInvalidCast);
2215 #endif
2216   const H225_AlternateTransportAddresses & other = (const H225_AlternateTransportAddresses &)obj;
2217
2218   Comparison result;
2219
2220   if ((result = m_annexE.Compare(other.m_annexE)) != EqualTo)
2221     return result;
2222
2223   return PASN_Sequence::Compare(other);
2224 }
2225
2226
2227 PINDEX H225_AlternateTransportAddresses::GetDataLength() const
2228 {
2229   PINDEX length = 0;
2230   if (HasOptionalField(e_annexE))
2231     length += m_annexE.GetObjectLength();
2232   return length;
2233 }
2234
2235
2236 BOOL H225_AlternateTransportAddresses::Decode(PASN_Stream & strm)
2237 {
2238   if (!PreambleDecode(strm))
2239     return FALSE;
2240
2241   if (HasOptionalField(e_annexE) && !m_annexE.Decode(strm))
2242     return FALSE;
2243   if (!KnownExtensionDecode(strm, e_sctp, m_sctp))
2244     return FALSE;
2245
2246   return UnknownExtensionsDecode(strm);
2247 }
2248
2249
2250 void H225_AlternateTransportAddresses::Encode(PASN_Stream & strm) const
2251 {
2252   PreambleEncode(strm);
2253
2254   if (HasOptionalField(e_annexE))
2255     m_annexE.Encode(strm);
2256   KnownExtensionEncode(strm, e_sctp, m_sctp);
2257
2258   UnknownExtensionsEncode(strm);
2259 }
2260
2261
2262 PObject * H225_AlternateTransportAddresses::Clone() const
2263 {
2264 #ifndef PASN_LEANANDMEAN
2265   PAssert(IsClass(H225_AlternateTransportAddresses::Class()), PInvalidCast);
2266 #endif
2267   return new H225_AlternateTransportAddresses(*this);
2268 }
2269
2270
2271 //
2272 // AlternateGK
2273 //
2274
2275 H225_AlternateGK::H225_AlternateGK(unsigned tag, PASN_Object::TagClass tagClass)
2276   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
2277 {
2278   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 127);
2279 }
2280
2281
2282 #ifndef PASN_NOPRINTON
2283 void H225_AlternateGK::PrintOn(ostream & strm) const
2284 {
2285   int indent = strm.precision() + 2;
2286   strm << "{\n";
2287   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
2288   if (HasOptionalField(e_gatekeeperIdentifier))
2289     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
2290   strm << setw(indent+17) << "needToRegister = " << setprecision(indent) << m_needToRegister << '\n';
2291   strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
2292   strm << setw(indent-1) << setprecision(indent-2) << "}";
2293 }
2294 #endif
2295
2296
2297 PObject::Comparison H225_AlternateGK::Compare(const PObject & obj) const
2298 {
2299 #ifndef PASN_LEANANDMEAN
2300   PAssert(PIsDescendant(&obj, H225_AlternateGK), PInvalidCast);
2301 #endif
2302   const H225_AlternateGK & other = (const H225_AlternateGK &)obj;
2303
2304   Comparison result;
2305
2306   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
2307     return result;
2308   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
2309     return result;
2310   if ((result = m_needToRegister.Compare(other.m_needToRegister)) != EqualTo)
2311     return result;
2312   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
2313     return result;
2314
2315   return PASN_Sequence::Compare(other);
2316 }
2317
2318
2319 PINDEX H225_AlternateGK::GetDataLength() const
2320 {
2321   PINDEX length = 0;
2322   length += m_rasAddress.GetObjectLength();
2323   if (HasOptionalField(e_gatekeeperIdentifier))
2324     length += m_gatekeeperIdentifier.GetObjectLength();
2325   length += m_needToRegister.GetObjectLength();
2326   length += m_priority.GetObjectLength();
2327   return length;
2328 }
2329
2330
2331 BOOL H225_AlternateGK::Decode(PASN_Stream & strm)
2332 {
2333   if (!PreambleDecode(strm))
2334     return FALSE;
2335
2336   if (!m_rasAddress.Decode(strm))
2337     return FALSE;
2338   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
2339     return FALSE;
2340   if (!m_needToRegister.Decode(strm))
2341     return FALSE;
2342   if (!m_priority.Decode(strm))
2343     return FALSE;
2344
2345   return UnknownExtensionsDecode(strm);
2346 }
2347
2348
2349 void H225_AlternateGK::Encode(PASN_Stream & strm) const
2350 {
2351   PreambleEncode(strm);
2352
2353   m_rasAddress.Encode(strm);
2354   if (HasOptionalField(e_gatekeeperIdentifier))
2355     m_gatekeeperIdentifier.Encode(strm);
2356   m_needToRegister.Encode(strm);
2357   m_priority.Encode(strm);
2358
2359   UnknownExtensionsEncode(strm);
2360 }
2361
2362
2363 PObject * H225_AlternateGK::Clone() const
2364 {
2365 #ifndef PASN_LEANANDMEAN
2366   PAssert(IsClass(H225_AlternateGK::Class()), PInvalidCast);
2367 #endif
2368   return new H225_AlternateGK(*this);
2369 }
2370
2371
2372 //
2373 // AltGKInfo
2374 //
2375
2376 H225_AltGKInfo::H225_AltGKInfo(unsigned tag, PASN_Object::TagClass tagClass)
2377   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2378 {
2379 }
2380
2381
2382 #ifndef PASN_NOPRINTON
2383 void H225_AltGKInfo::PrintOn(ostream & strm) const
2384 {
2385   int indent = strm.precision() + 2;
2386   strm << "{\n";
2387   strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
2388   strm << setw(indent+19) << "altGKisPermanent = " << setprecision(indent) << m_altGKisPermanent << '\n';
2389   strm << setw(indent-1) << setprecision(indent-2) << "}";
2390 }
2391 #endif
2392
2393
2394 PObject::Comparison H225_AltGKInfo::Compare(const PObject & obj) const
2395 {
2396 #ifndef PASN_LEANANDMEAN
2397   PAssert(PIsDescendant(&obj, H225_AltGKInfo), PInvalidCast);
2398 #endif
2399   const H225_AltGKInfo & other = (const H225_AltGKInfo &)obj;
2400
2401   Comparison result;
2402
2403   if ((result = m_alternateGatekeeper.Compare(other.m_alternateGatekeeper)) != EqualTo)
2404     return result;
2405   if ((result = m_altGKisPermanent.Compare(other.m_altGKisPermanent)) != EqualTo)
2406     return result;
2407
2408   return PASN_Sequence::Compare(other);
2409 }
2410
2411
2412 PINDEX H225_AltGKInfo::GetDataLength() const
2413 {
2414   PINDEX length = 0;
2415   length += m_alternateGatekeeper.GetObjectLength();
2416   length += m_altGKisPermanent.GetObjectLength();
2417   return length;
2418 }
2419
2420
2421 BOOL H225_AltGKInfo::Decode(PASN_Stream & strm)
2422 {
2423   if (!PreambleDecode(strm))
2424     return FALSE;
2425
2426   if (!m_alternateGatekeeper.Decode(strm))
2427     return FALSE;
2428   if (!m_altGKisPermanent.Decode(strm))
2429     return FALSE;
2430
2431   return UnknownExtensionsDecode(strm);
2432 }
2433
2434
2435 void H225_AltGKInfo::Encode(PASN_Stream & strm) const
2436 {
2437   PreambleEncode(strm);
2438
2439   m_alternateGatekeeper.Encode(strm);
2440   m_altGKisPermanent.Encode(strm);
2441
2442   UnknownExtensionsEncode(strm);
2443 }
2444
2445
2446 PObject * H225_AltGKInfo::Clone() const
2447 {
2448 #ifndef PASN_LEANANDMEAN
2449   PAssert(IsClass(H225_AltGKInfo::Class()), PInvalidCast);
2450 #endif
2451   return new H225_AltGKInfo(*this);
2452 }
2453
2454
2455 //
2456 // SecurityCapabilities
2457 //
2458
2459 H225_SecurityCapabilities::H225_SecurityCapabilities(unsigned tag, PASN_Object::TagClass tagClass)
2460   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
2461 {
2462 }
2463
2464
2465 #ifndef PASN_NOPRINTON
2466 void H225_SecurityCapabilities::PrintOn(ostream & strm) const
2467 {
2468   int indent = strm.precision() + 2;
2469   strm << "{\n";
2470   if (HasOptionalField(e_nonStandard))
2471     strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
2472   strm << setw(indent+13) << "encryption = " << setprecision(indent) << m_encryption << '\n';
2473   strm << setw(indent+16) << "authenticaton = " << setprecision(indent) << m_authenticaton << '\n';
2474   strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
2475   strm << setw(indent-1) << setprecision(indent-2) << "}";
2476 }
2477 #endif
2478
2479
2480 PObject::Comparison H225_SecurityCapabilities::Compare(const PObject & obj) const
2481 {
2482 #ifndef PASN_LEANANDMEAN
2483   PAssert(PIsDescendant(&obj, H225_SecurityCapabilities), PInvalidCast);
2484 #endif
2485   const H225_SecurityCapabilities & other = (const H225_SecurityCapabilities &)obj;
2486
2487   Comparison result;
2488
2489   if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
2490     return result;
2491   if ((result = m_encryption.Compare(other.m_encryption)) != EqualTo)
2492     return result;
2493   if ((result = m_authenticaton.Compare(other.m_authenticaton)) != EqualTo)
2494     return result;
2495   if ((result = m_integrity.Compare(other.m_integrity)) != EqualTo)
2496     return result;
2497
2498   return PASN_Sequence::Compare(other);
2499 }
2500
2501
2502 PINDEX H225_SecurityCapabilities::GetDataLength() const
2503 {
2504   PINDEX length = 0;
2505   if (HasOptionalField(e_nonStandard))
2506     length += m_nonStandard.GetObjectLength();
2507   length += m_encryption.GetObjectLength();
2508   length += m_authenticaton.GetObjectLength();
2509   length += m_integrity.GetObjectLength();
2510   return length;
2511 }
2512
2513
2514 BOOL H225_SecurityCapabilities::Decode(PASN_Stream & strm)
2515 {
2516   if (!PreambleDecode(strm))
2517     return FALSE;
2518
2519   if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
2520     return FALSE;
2521   if (!m_encryption.Decode(strm))
2522     return FALSE;
2523   if (!m_authenticaton.Decode(strm))
2524     return FALSE;
2525   if (!m_integrity.Decode(strm))
2526     return FALSE;
2527
2528   return UnknownExtensionsDecode(strm);
2529 }
2530
2531
2532 void H225_SecurityCapabilities::Encode(PASN_Stream & strm) const
2533 {
2534   PreambleEncode(strm);
2535
2536   if (HasOptionalField(e_nonStandard))
2537     m_nonStandard.Encode(strm);
2538   m_encryption.Encode(strm);
2539   m_authenticaton.Encode(strm);
2540   m_integrity.Encode(strm);
2541
2542   UnknownExtensionsEncode(strm);
2543 }
2544
2545
2546 PObject * H225_SecurityCapabilities::Clone() const
2547 {
2548 #ifndef PASN_LEANANDMEAN
2549   PAssert(IsClass(H225_SecurityCapabilities::Class()), PInvalidCast);
2550 #endif
2551   return new H225_SecurityCapabilities(*this);
2552 }
2553
2554
2555 //
2556 // QseriesOptions
2557 //
2558
2559 H225_QseriesOptions::H225_QseriesOptions(unsigned tag, PASN_Object::TagClass tagClass)
2560   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2561 {
2562 }
2563
2564
2565 #ifndef PASN_NOPRINTON
2566 void H225_QseriesOptions::PrintOn(ostream & strm) const
2567 {
2568   int indent = strm.precision() + 2;
2569   strm << "{\n";
2570   strm << setw(indent+11) << "q932Full = " << setprecision(indent) << m_q932Full << '\n';
2571   strm << setw(indent+11) << "q951Full = " << setprecision(indent) << m_q951Full << '\n';
2572   strm << setw(indent+11) << "q952Full = " << setprecision(indent) << m_q952Full << '\n';
2573   strm << setw(indent+11) << "q953Full = " << setprecision(indent) << m_q953Full << '\n';
2574   strm << setw(indent+11) << "q955Full = " << setprecision(indent) << m_q955Full << '\n';
2575   strm << setw(indent+11) << "q956Full = " << setprecision(indent) << m_q956Full << '\n';
2576   strm << setw(indent+11) << "q957Full = " << setprecision(indent) << m_q957Full << '\n';
2577   strm << setw(indent+11) << "q954Info = " << setprecision(indent) << m_q954Info << '\n';
2578   strm << setw(indent-1) << setprecision(indent-2) << "}";
2579 }
2580 #endif
2581
2582
2583 PObject::Comparison H225_QseriesOptions::Compare(const PObject & obj) const
2584 {
2585 #ifndef PASN_LEANANDMEAN
2586   PAssert(PIsDescendant(&obj, H225_QseriesOptions), PInvalidCast);
2587 #endif
2588   const H225_QseriesOptions & other = (const H225_QseriesOptions &)obj;
2589
2590   Comparison result;
2591
2592   if ((result = m_q932Full.Compare(other.m_q932Full)) != EqualTo)
2593     return result;
2594   if ((result = m_q951Full.Compare(other.m_q951Full)) != EqualTo)
2595     return result;
2596   if ((result = m_q952Full.Compare(other.m_q952Full)) != EqualTo)
2597     return result;
2598   if ((result = m_q953Full.Compare(other.m_q953Full)) != EqualTo)
2599     return result;
2600   if ((result = m_q955Full.Compare(other.m_q955Full)) != EqualTo)
2601     return result;
2602   if ((result = m_q956Full.Compare(other.m_q956Full)) != EqualTo)
2603     return result;
2604   if ((result = m_q957Full.Compare(other.m_q957Full)) != EqualTo)
2605     return result;
2606   if ((result = m_q954Info.Compare(other.m_q954Info)) != EqualTo)
2607     return result;
2608
2609   return PASN_Sequence::Compare(other);
2610 }
2611
2612
2613 PINDEX H225_QseriesOptions::GetDataLength() const
2614 {
2615   PINDEX length = 0;
2616   length += m_q932Full.GetObjectLength();
2617   length += m_q951Full.GetObjectLength();
2618   length += m_q952Full.GetObjectLength();
2619   length += m_q953Full.GetObjectLength();
2620   length += m_q955Full.GetObjectLength();
2621   length += m_q956Full.GetObjectLength();
2622   length += m_q957Full.GetObjectLength();
2623   length += m_q954Info.GetObjectLength();
2624   return length;
2625 }
2626
2627
2628 BOOL H225_QseriesOptions::Decode(PASN_Stream & strm)
2629 {
2630   if (!PreambleDecode(strm))
2631     return FALSE;
2632
2633   if (!m_q932Full.Decode(strm))
2634     return FALSE;
2635   if (!m_q951Full.Decode(strm))
2636     return FALSE;
2637   if (!m_q952Full.Decode(strm))
2638     return FALSE;
2639   if (!m_q953Full.Decode(strm))
2640     return FALSE;
2641   if (!m_q955Full.Decode(strm))
2642     return FALSE;
2643   if (!m_q956Full.Decode(strm))
2644     return FALSE;
2645   if (!m_q957Full.Decode(strm))
2646     return FALSE;
2647   if (!m_q954Info.Decode(strm))
2648     return FALSE;
2649
2650   return UnknownExtensionsDecode(strm);
2651 }
2652
2653
2654 void H225_QseriesOptions::Encode(PASN_Stream & strm) const
2655 {
2656   PreambleEncode(strm);
2657
2658   m_q932Full.Encode(strm);
2659   m_q951Full.Encode(strm);
2660   m_q952Full.Encode(strm);
2661   m_q953Full.Encode(strm);
2662   m_q955Full.Encode(strm);
2663   m_q956Full.Encode(strm);
2664   m_q957Full.Encode(strm);
2665   m_q954Info.Encode(strm);
2666
2667   UnknownExtensionsEncode(strm);
2668 }
2669
2670
2671 PObject * H225_QseriesOptions::Clone() const
2672 {
2673 #ifndef PASN_LEANANDMEAN
2674   PAssert(IsClass(H225_QseriesOptions::Class()), PInvalidCast);
2675 #endif
2676   return new H225_QseriesOptions(*this);
2677 }
2678
2679
2680 //
2681 // DataRate
2682 //
2683
2684 H225_DataRate::H225_DataRate(unsigned tag, PASN_Object::TagClass tagClass)
2685   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
2686 {
2687   m_channelMultiplier.SetConstraints(PASN_Object::FixedConstraint, 1, 256);
2688 }
2689
2690
2691 #ifndef PASN_NOPRINTON
2692 void H225_DataRate::PrintOn(ostream & strm) const
2693 {
2694   int indent = strm.precision() + 2;
2695   strm << "{\n";
2696   if (HasOptionalField(e_nonStandardData))
2697     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
2698   strm << setw(indent+14) << "channelRate = " << setprecision(indent) << m_channelRate << '\n';
2699   if (HasOptionalField(e_channelMultiplier))
2700     strm << setw(indent+20) << "channelMultiplier = " << setprecision(indent) << m_channelMultiplier << '\n';
2701   strm << setw(indent-1) << setprecision(indent-2) << "}";
2702 }
2703 #endif
2704
2705
2706 PObject::Comparison H225_DataRate::Compare(const PObject & obj) const
2707 {
2708 #ifndef PASN_LEANANDMEAN
2709   PAssert(PIsDescendant(&obj, H225_DataRate), PInvalidCast);
2710 #endif
2711   const H225_DataRate & other = (const H225_DataRate &)obj;
2712
2713   Comparison result;
2714
2715   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
2716     return result;
2717   if ((result = m_channelRate.Compare(other.m_channelRate)) != EqualTo)
2718     return result;
2719   if ((result = m_channelMultiplier.Compare(other.m_channelMultiplier)) != EqualTo)
2720     return result;
2721
2722   return PASN_Sequence::Compare(other);
2723 }
2724
2725
2726 PINDEX H225_DataRate::GetDataLength() const
2727 {
2728   PINDEX length = 0;
2729   if (HasOptionalField(e_nonStandardData))
2730     length += m_nonStandardData.GetObjectLength();
2731   length += m_channelRate.GetObjectLength();
2732   if (HasOptionalField(e_channelMultiplier))
2733     length += m_channelMultiplier.GetObjectLength();
2734   return length;
2735 }
2736
2737
2738 BOOL H225_DataRate::Decode(PASN_Stream & strm)
2739 {
2740   if (!PreambleDecode(strm))
2741     return FALSE;
2742
2743   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
2744     return FALSE;
2745   if (!m_channelRate.Decode(strm))
2746     return FALSE;
2747   if (HasOptionalField(e_channelMultiplier) && !m_channelMultiplier.Decode(strm))
2748     return FALSE;
2749
2750   return UnknownExtensionsDecode(strm);
2751 }
2752
2753
2754 void H225_DataRate::Encode(PASN_Stream & strm) const
2755 {
2756   PreambleEncode(strm);
2757
2758   if (HasOptionalField(e_nonStandardData))
2759     m_nonStandardData.Encode(strm);
2760   m_channelRate.Encode(strm);
2761   if (HasOptionalField(e_channelMultiplier))
2762     m_channelMultiplier.Encode(strm);
2763
2764   UnknownExtensionsEncode(strm);
2765 }
2766
2767
2768 PObject * H225_DataRate::Clone() const
2769 {
2770 #ifndef PASN_LEANANDMEAN
2771   PAssert(IsClass(H225_DataRate::Class()), PInvalidCast);
2772 #endif
2773   return new H225_DataRate(*this);
2774 }
2775
2776
2777 //
2778 // SupportedPrefix
2779 //
2780
2781 H225_SupportedPrefix::H225_SupportedPrefix(unsigned tag, PASN_Object::TagClass tagClass)
2782   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
2783 {
2784 }
2785
2786
2787 #ifndef PASN_NOPRINTON
2788 void H225_SupportedPrefix::PrintOn(ostream & strm) const
2789 {
2790   int indent = strm.precision() + 2;
2791   strm << "{\n";
2792   if (HasOptionalField(e_nonStandardData))
2793     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
2794   strm << setw(indent+9) << "prefix = " << setprecision(indent) << m_prefix << '\n';
2795   strm << setw(indent-1) << setprecision(indent-2) << "}";
2796 }
2797 #endif
2798
2799
2800 PObject::Comparison H225_SupportedPrefix::Compare(const PObject & obj) const
2801 {
2802 #ifndef PASN_LEANANDMEAN
2803   PAssert(PIsDescendant(&obj, H225_SupportedPrefix), PInvalidCast);
2804 #endif
2805   const H225_SupportedPrefix & other = (const H225_SupportedPrefix &)obj;
2806
2807   Comparison result;
2808
2809   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
2810     return result;
2811   if ((result = m_prefix.Compare(other.m_prefix)) != EqualTo)
2812     return result;
2813
2814   return PASN_Sequence::Compare(other);
2815 }
2816
2817
2818 PINDEX H225_SupportedPrefix::GetDataLength() const
2819 {
2820   PINDEX length = 0;
2821   if (HasOptionalField(e_nonStandardData))
2822     length += m_nonStandardData.GetObjectLength();
2823   length += m_prefix.GetObjectLength();
2824   return length;
2825 }
2826
2827
2828 BOOL H225_SupportedPrefix::Decode(PASN_Stream & strm)
2829 {
2830   if (!PreambleDecode(strm))
2831     return FALSE;
2832
2833   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
2834     return FALSE;
2835   if (!m_prefix.Decode(strm))
2836     return FALSE;
2837
2838   return UnknownExtensionsDecode(strm);
2839 }
2840
2841
2842 void H225_SupportedPrefix::Encode(PASN_Stream & strm) const
2843 {
2844   PreambleEncode(strm);
2845
2846   if (HasOptionalField(e_nonStandardData))
2847     m_nonStandardData.Encode(strm);
2848   m_prefix.Encode(strm);
2849
2850   UnknownExtensionsEncode(strm);
2851 }
2852
2853
2854 PObject * H225_SupportedPrefix::Clone() const
2855 {
2856 #ifndef PASN_LEANANDMEAN
2857   PAssert(IsClass(H225_SupportedPrefix::Class()), PInvalidCast);
2858 #endif
2859   return new H225_SupportedPrefix(*this);
2860 }
2861
2862
2863 //
2864 // CapacityReportingSpecification
2865 //
2866
2867 H225_CapacityReportingSpecification::H225_CapacityReportingSpecification(unsigned tag, PASN_Object::TagClass tagClass)
2868   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
2869 {
2870 }
2871
2872
2873 #ifndef PASN_NOPRINTON
2874 void H225_CapacityReportingSpecification::PrintOn(ostream & strm) const
2875 {
2876   int indent = strm.precision() + 2;
2877   strm << "{\n";
2878   strm << setw(indent+7) << "when = " << setprecision(indent) << m_when << '\n';
2879   strm << setw(indent-1) << setprecision(indent-2) << "}";
2880 }
2881 #endif
2882
2883
2884 PObject::Comparison H225_CapacityReportingSpecification::Compare(const PObject & obj) const
2885 {
2886 #ifndef PASN_LEANANDMEAN
2887   PAssert(PIsDescendant(&obj, H225_CapacityReportingSpecification), PInvalidCast);
2888 #endif
2889   const H225_CapacityReportingSpecification & other = (const H225_CapacityReportingSpecification &)obj;
2890
2891   Comparison result;
2892
2893   if ((result = m_when.Compare(other.m_when)) != EqualTo)
2894     return result;
2895
2896   return PASN_Sequence::Compare(other);
2897 }
2898
2899
2900 PINDEX H225_CapacityReportingSpecification::GetDataLength() const
2901 {
2902   PINDEX length = 0;
2903   length += m_when.GetObjectLength();
2904   return length;
2905 }
2906
2907
2908 BOOL H225_CapacityReportingSpecification::Decode(PASN_Stream & strm)
2909 {
2910   if (!PreambleDecode(strm))
2911     return FALSE;
2912
2913   if (!m_when.Decode(strm))
2914     return FALSE;
2915
2916   return UnknownExtensionsDecode(strm);
2917 }
2918
2919
2920 void H225_CapacityReportingSpecification::Encode(PASN_Stream & strm) const
2921 {
2922   PreambleEncode(strm);
2923
2924   m_when.Encode(strm);
2925
2926   UnknownExtensionsEncode(strm);
2927 }
2928
2929
2930 PObject * H225_CapacityReportingSpecification::Clone() const
2931 {
2932 #ifndef PASN_LEANANDMEAN
2933   PAssert(IsClass(H225_CapacityReportingSpecification::Class()), PInvalidCast);
2934 #endif
2935   return new H225_CapacityReportingSpecification(*this);
2936 }
2937
2938
2939 //
2940 // CallCapacityInfo
2941 //
2942
2943 H225_CallCapacityInfo::H225_CallCapacityInfo(unsigned tag, PASN_Object::TagClass tagClass)
2944   : PASN_Sequence(tag, tagClass, 11, TRUE, 1)
2945 {
2946 }
2947
2948
2949 #ifndef PASN_NOPRINTON
2950 void H225_CallCapacityInfo::PrintOn(ostream & strm) const
2951 {
2952   int indent = strm.precision() + 2;
2953   strm << "{\n";
2954   if (HasOptionalField(e_voiceGwCallsAvailable))
2955     strm << setw(indent+24) << "voiceGwCallsAvailable = " << setprecision(indent) << m_voiceGwCallsAvailable << '\n';
2956   if (HasOptionalField(e_h310GwCallsAvailable))
2957     strm << setw(indent+23) << "h310GwCallsAvailable = " << setprecision(indent) << m_h310GwCallsAvailable << '\n';
2958   if (HasOptionalField(e_h320GwCallsAvailable))
2959     strm << setw(indent+23) << "h320GwCallsAvailable = " << setprecision(indent) << m_h320GwCallsAvailable << '\n';
2960   if (HasOptionalField(e_h321GwCallsAvailable))
2961     strm << setw(indent+23) << "h321GwCallsAvailable = " << setprecision(indent) << m_h321GwCallsAvailable << '\n';
2962   if (HasOptionalField(e_h322GwCallsAvailable))
2963     strm << setw(indent+23) << "h322GwCallsAvailable = " << setprecision(indent) << m_h322GwCallsAvailable << '\n';
2964   if (HasOptionalField(e_h323GwCallsAvailable))
2965     strm << setw(indent+23) << "h323GwCallsAvailable = " << setprecision(indent) << m_h323GwCallsAvailable << '\n';
2966   if (HasOptionalField(e_h324GwCallsAvailable))
2967     strm << setw(indent+23) << "h324GwCallsAvailable = " << setprecision(indent) << m_h324GwCallsAvailable << '\n';
2968   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
2969     strm << setw(indent+27) << "t120OnlyGwCallsAvailable = " << setprecision(indent) << m_t120OnlyGwCallsAvailable << '\n';
2970   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
2971     strm << setw(indent+35) << "t38FaxAnnexbOnlyGwCallsAvailable = " << setprecision(indent) << m_t38FaxAnnexbOnlyGwCallsAvailable << '\n';
2972   if (HasOptionalField(e_terminalCallsAvailable))
2973     strm << setw(indent+25) << "terminalCallsAvailable = " << setprecision(indent) << m_terminalCallsAvailable << '\n';
2974   if (HasOptionalField(e_mcuCallsAvailable))
2975     strm << setw(indent+20) << "mcuCallsAvailable = " << setprecision(indent) << m_mcuCallsAvailable << '\n';
2976   if (HasOptionalField(e_sipGwCallsAvailable))
2977     strm << setw(indent+22) << "sipGwCallsAvailable = " << setprecision(indent) << m_sipGwCallsAvailable << '\n';
2978   strm << setw(indent-1) << setprecision(indent-2) << "}";
2979 }
2980 #endif
2981
2982
2983 PObject::Comparison H225_CallCapacityInfo::Compare(const PObject & obj) const
2984 {
2985 #ifndef PASN_LEANANDMEAN
2986   PAssert(PIsDescendant(&obj, H225_CallCapacityInfo), PInvalidCast);
2987 #endif
2988   const H225_CallCapacityInfo & other = (const H225_CallCapacityInfo &)obj;
2989
2990   Comparison result;
2991
2992   if ((result = m_voiceGwCallsAvailable.Compare(other.m_voiceGwCallsAvailable)) != EqualTo)
2993     return result;
2994   if ((result = m_h310GwCallsAvailable.Compare(other.m_h310GwCallsAvailable)) != EqualTo)
2995     return result;
2996   if ((result = m_h320GwCallsAvailable.Compare(other.m_h320GwCallsAvailable)) != EqualTo)
2997     return result;
2998   if ((result = m_h321GwCallsAvailable.Compare(other.m_h321GwCallsAvailable)) != EqualTo)
2999     return result;
3000   if ((result = m_h322GwCallsAvailable.Compare(other.m_h322GwCallsAvailable)) != EqualTo)
3001     return result;
3002   if ((result = m_h323GwCallsAvailable.Compare(other.m_h323GwCallsAvailable)) != EqualTo)
3003     return result;
3004   if ((result = m_h324GwCallsAvailable.Compare(other.m_h324GwCallsAvailable)) != EqualTo)
3005     return result;
3006   if ((result = m_t120OnlyGwCallsAvailable.Compare(other.m_t120OnlyGwCallsAvailable)) != EqualTo)
3007     return result;
3008   if ((result = m_t38FaxAnnexbOnlyGwCallsAvailable.Compare(other.m_t38FaxAnnexbOnlyGwCallsAvailable)) != EqualTo)
3009     return result;
3010   if ((result = m_terminalCallsAvailable.Compare(other.m_terminalCallsAvailable)) != EqualTo)
3011     return result;
3012   if ((result = m_mcuCallsAvailable.Compare(other.m_mcuCallsAvailable)) != EqualTo)
3013     return result;
3014
3015   return PASN_Sequence::Compare(other);
3016 }
3017
3018
3019 PINDEX H225_CallCapacityInfo::GetDataLength() const
3020 {
3021   PINDEX length = 0;
3022   if (HasOptionalField(e_voiceGwCallsAvailable))
3023     length += m_voiceGwCallsAvailable.GetObjectLength();
3024   if (HasOptionalField(e_h310GwCallsAvailable))
3025     length += m_h310GwCallsAvailable.GetObjectLength();
3026   if (HasOptionalField(e_h320GwCallsAvailable))
3027     length += m_h320GwCallsAvailable.GetObjectLength();
3028   if (HasOptionalField(e_h321GwCallsAvailable))
3029     length += m_h321GwCallsAvailable.GetObjectLength();
3030   if (HasOptionalField(e_h322GwCallsAvailable))
3031     length += m_h322GwCallsAvailable.GetObjectLength();
3032   if (HasOptionalField(e_h323GwCallsAvailable))
3033     length += m_h323GwCallsAvailable.GetObjectLength();
3034   if (HasOptionalField(e_h324GwCallsAvailable))
3035     length += m_h324GwCallsAvailable.GetObjectLength();
3036   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
3037     length += m_t120OnlyGwCallsAvailable.GetObjectLength();
3038   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
3039     length += m_t38FaxAnnexbOnlyGwCallsAvailable.GetObjectLength();
3040   if (HasOptionalField(e_terminalCallsAvailable))
3041     length += m_terminalCallsAvailable.GetObjectLength();
3042   if (HasOptionalField(e_mcuCallsAvailable))
3043     length += m_mcuCallsAvailable.GetObjectLength();
3044   return length;
3045 }
3046
3047
3048 BOOL H225_CallCapacityInfo::Decode(PASN_Stream & strm)
3049 {
3050   if (!PreambleDecode(strm))
3051     return FALSE;
3052
3053   if (HasOptionalField(e_voiceGwCallsAvailable) && !m_voiceGwCallsAvailable.Decode(strm))
3054     return FALSE;
3055   if (HasOptionalField(e_h310GwCallsAvailable) && !m_h310GwCallsAvailable.Decode(strm))
3056     return FALSE;
3057   if (HasOptionalField(e_h320GwCallsAvailable) && !m_h320GwCallsAvailable.Decode(strm))
3058     return FALSE;
3059   if (HasOptionalField(e_h321GwCallsAvailable) && !m_h321GwCallsAvailable.Decode(strm))
3060     return FALSE;
3061   if (HasOptionalField(e_h322GwCallsAvailable) && !m_h322GwCallsAvailable.Decode(strm))
3062     return FALSE;
3063   if (HasOptionalField(e_h323GwCallsAvailable) && !m_h323GwCallsAvailable.Decode(strm))
3064     return FALSE;
3065   if (HasOptionalField(e_h324GwCallsAvailable) && !m_h324GwCallsAvailable.Decode(strm))
3066     return FALSE;
3067   if (HasOptionalField(e_t120OnlyGwCallsAvailable) && !m_t120OnlyGwCallsAvailable.Decode(strm))
3068     return FALSE;
3069   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable) && !m_t38FaxAnnexbOnlyGwCallsAvailable.Decode(strm))
3070     return FALSE;
3071   if (HasOptionalField(e_terminalCallsAvailable) && !m_terminalCallsAvailable.Decode(strm))
3072     return FALSE;
3073   if (HasOptionalField(e_mcuCallsAvailable) && !m_mcuCallsAvailable.Decode(strm))
3074     return FALSE;
3075   if (!KnownExtensionDecode(strm, e_sipGwCallsAvailable, m_sipGwCallsAvailable))
3076     return FALSE;
3077
3078   return UnknownExtensionsDecode(strm);
3079 }
3080
3081
3082 void H225_CallCapacityInfo::Encode(PASN_Stream & strm) const
3083 {
3084   PreambleEncode(strm);
3085
3086   if (HasOptionalField(e_voiceGwCallsAvailable))
3087     m_voiceGwCallsAvailable.Encode(strm);
3088   if (HasOptionalField(e_h310GwCallsAvailable))
3089     m_h310GwCallsAvailable.Encode(strm);
3090   if (HasOptionalField(e_h320GwCallsAvailable))
3091     m_h320GwCallsAvailable.Encode(strm);
3092   if (HasOptionalField(e_h321GwCallsAvailable))
3093     m_h321GwCallsAvailable.Encode(strm);
3094   if (HasOptionalField(e_h322GwCallsAvailable))
3095     m_h322GwCallsAvailable.Encode(strm);
3096   if (HasOptionalField(e_h323GwCallsAvailable))
3097     m_h323GwCallsAvailable.Encode(strm);
3098   if (HasOptionalField(e_h324GwCallsAvailable))
3099     m_h324GwCallsAvailable.Encode(strm);
3100   if (HasOptionalField(e_t120OnlyGwCallsAvailable))
3101     m_t120OnlyGwCallsAvailable.Encode(strm);
3102   if (HasOptionalField(e_t38FaxAnnexbOnlyGwCallsAvailable))
3103     m_t38FaxAnnexbOnlyGwCallsAvailable.Encode(strm);
3104   if (HasOptionalField(e_terminalCallsAvailable))
3105     m_terminalCallsAvailable.Encode(strm);
3106   if (HasOptionalField(e_mcuCallsAvailable))
3107     m_mcuCallsAvailable.Encode(strm);
3108   KnownExtensionEncode(strm, e_sipGwCallsAvailable, m_sipGwCallsAvailable);
3109
3110   UnknownExtensionsEncode(strm);
3111 }
3112
3113
3114 PObject * H225_CallCapacityInfo::Clone() const
3115 {
3116 #ifndef PASN_LEANANDMEAN
3117   PAssert(IsClass(H225_CallCapacityInfo::Class()), PInvalidCast);
3118 #endif
3119   return new H225_CallCapacityInfo(*this);
3120 }
3121
3122
3123 //
3124 // CallsAvailable
3125 //
3126
3127 H225_CallsAvailable::H225_CallsAvailable(unsigned tag, PASN_Object::TagClass tagClass)
3128   : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
3129 {
3130   m_calls.SetConstraints(PASN_Object::FixedConstraint, 0, 4294967295U);
3131   m_group.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
3132 }
3133
3134
3135 #ifndef PASN_NOPRINTON
3136 void H225_CallsAvailable::PrintOn(ostream & strm) const
3137 {
3138   int indent = strm.precision() + 2;
3139   strm << "{\n";
3140   strm << setw(indent+8) << "calls = " << setprecision(indent) << m_calls << '\n';
3141   if (HasOptionalField(e_group))
3142     strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
3143   if (HasOptionalField(e_carrier))
3144     strm << setw(indent+10) << "carrier = " << setprecision(indent) << m_carrier << '\n';
3145   strm << setw(indent-1) << setprecision(indent-2) << "}";
3146 }
3147 #endif
3148
3149
3150 PObject::Comparison H225_CallsAvailable::Compare(const PObject & obj) const
3151 {
3152 #ifndef PASN_LEANANDMEAN
3153   PAssert(PIsDescendant(&obj, H225_CallsAvailable), PInvalidCast);
3154 #endif
3155   const H225_CallsAvailable & other = (const H225_CallsAvailable &)obj;
3156
3157   Comparison result;
3158
3159   if ((result = m_calls.Compare(other.m_calls)) != EqualTo)
3160     return result;
3161   if ((result = m_group.Compare(other.m_group)) != EqualTo)
3162     return result;
3163
3164   return PASN_Sequence::Compare(other);
3165 }
3166
3167
3168 PINDEX H225_CallsAvailable::GetDataLength() const
3169 {
3170   PINDEX length = 0;
3171   length += m_calls.GetObjectLength();
3172   if (HasOptionalField(e_group))
3173     length += m_group.GetObjectLength();
3174   return length;
3175 }
3176
3177
3178 BOOL H225_CallsAvailable::Decode(PASN_Stream & strm)
3179 {
3180   if (!PreambleDecode(strm))
3181     return FALSE;
3182
3183   if (!m_calls.Decode(strm))
3184     return FALSE;
3185   if (HasOptionalField(e_group) && !m_group.Decode(strm))
3186     return FALSE;
3187   if (!KnownExtensionDecode(strm, e_carrier, m_carrier))
3188     return FALSE;
3189
3190   return UnknownExtensionsDecode(strm);
3191 }
3192
3193
3194 void H225_CallsAvailable::Encode(PASN_Stream & strm) const
3195 {
3196   PreambleEncode(strm);
3197
3198   m_calls.Encode(strm);
3199   if (HasOptionalField(e_group))
3200     m_group.Encode(strm);
3201   KnownExtensionEncode(strm, e_carrier, m_carrier);
3202
3203   UnknownExtensionsEncode(strm);
3204 }
3205
3206
3207 PObject * H225_CallsAvailable::Clone() const
3208 {
3209 #ifndef PASN_LEANANDMEAN
3210   PAssert(IsClass(H225_CallsAvailable::Class()), PInvalidCast);
3211 #endif
3212   return new H225_CallsAvailable(*this);
3213 }
3214
3215
3216 //
3217 // CicInfo
3218 //
3219
3220 H225_CicInfo::H225_CicInfo(unsigned tag, PASN_Object::TagClass tagClass)
3221   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
3222 {
3223   m_pointCode.SetConstraints(PASN_Object::FixedConstraint, 2, 5);
3224 }
3225
3226
3227 #ifndef PASN_NOPRINTON
3228 void H225_CicInfo::PrintOn(ostream & strm) const
3229 {
3230   int indent = strm.precision() + 2;
3231   strm << "{\n";
3232   strm << setw(indent+6) << "cic = " << setprecision(indent) << m_cic << '\n';
3233   strm << setw(indent+12) << "pointCode = " << setprecision(indent) << m_pointCode << '\n';
3234   strm << setw(indent-1) << setprecision(indent-2) << "}";
3235 }
3236 #endif
3237
3238
3239 PObject::Comparison H225_CicInfo::Compare(const PObject & obj) const
3240 {
3241 #ifndef PASN_LEANANDMEAN
3242   PAssert(PIsDescendant(&obj, H225_CicInfo), PInvalidCast);
3243 #endif
3244   const H225_CicInfo & other = (const H225_CicInfo &)obj;
3245
3246   Comparison result;
3247
3248   if ((result = m_cic.Compare(other.m_cic)) != EqualTo)
3249     return result;
3250   if ((result = m_pointCode.Compare(other.m_pointCode)) != EqualTo)
3251     return result;
3252
3253   return PASN_Sequence::Compare(other);
3254 }
3255
3256
3257 PINDEX H225_CicInfo::GetDataLength() const
3258 {
3259   PINDEX length = 0;
3260   length += m_cic.GetObjectLength();
3261   length += m_pointCode.GetObjectLength();
3262   return length;
3263 }
3264
3265
3266 BOOL H225_CicInfo::Decode(PASN_Stream & strm)
3267 {
3268   if (!PreambleDecode(strm))
3269     return FALSE;
3270
3271   if (!m_cic.Decode(strm))
3272     return FALSE;
3273   if (!m_pointCode.Decode(strm))
3274     return FALSE;
3275
3276   return UnknownExtensionsDecode(strm);
3277 }
3278
3279
3280 void H225_CicInfo::Encode(PASN_Stream & strm) const
3281 {
3282   PreambleEncode(strm);
3283
3284   m_cic.Encode(strm);
3285   m_pointCode.Encode(strm);
3286
3287   UnknownExtensionsEncode(strm);
3288 }
3289
3290
3291 PObject * H225_CicInfo::Clone() const
3292 {
3293 #ifndef PASN_LEANANDMEAN
3294   PAssert(IsClass(H225_CicInfo::Class()), PInvalidCast);
3295 #endif
3296   return new H225_CicInfo(*this);
3297 }
3298
3299
3300 //
3301 // GroupID
3302 //
3303
3304 H225_GroupID::H225_GroupID(unsigned tag, PASN_Object::TagClass tagClass)
3305   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
3306 {
3307   m_group.SetConstraints(PASN_Object::FixedConstraint, 1, 128);
3308 }
3309
3310
3311 #ifndef PASN_NOPRINTON
3312 void H225_GroupID::PrintOn(ostream & strm) const
3313 {
3314   int indent = strm.precision() + 2;
3315   strm << "{\n";
3316   if (HasOptionalField(e_member))
3317     strm << setw(indent+9) << "member = " << setprecision(indent) << m_member << '\n';
3318   strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
3319   strm << setw(indent-1) << setprecision(indent-2) << "}";
3320 }
3321 #endif
3322
3323
3324 PObject::Comparison H225_GroupID::Compare(const PObject & obj) const
3325 {
3326 #ifndef PASN_LEANANDMEAN
3327   PAssert(PIsDescendant(&obj, H225_GroupID), PInvalidCast);
3328 #endif
3329   const H225_GroupID & other = (const H225_GroupID &)obj;
3330
3331   Comparison result;
3332
3333   if ((result = m_member.Compare(other.m_member)) != EqualTo)
3334     return result;
3335   if ((result = m_group.Compare(other.m_group)) != EqualTo)
3336     return result;
3337
3338   return PASN_Sequence::Compare(other);
3339 }
3340
3341
3342 PINDEX H225_GroupID::GetDataLength() const
3343 {
3344   PINDEX length = 0;
3345   if (HasOptionalField(e_member))
3346     length += m_member.GetObjectLength();
3347   length += m_group.GetObjectLength();
3348   return length;
3349 }
3350
3351
3352 BOOL H225_GroupID::Decode(PASN_Stream & strm)
3353 {
3354   if (!PreambleDecode(strm))
3355     return FALSE;
3356
3357   if (HasOptionalField(e_member) && !m_member.Decode(strm))
3358     return FALSE;
3359   if (!m_group.Decode(strm))
3360     return FALSE;
3361
3362   return UnknownExtensionsDecode(strm);
3363 }
3364
3365
3366 void H225_GroupID::Encode(PASN_Stream & strm) const
3367 {
3368   PreambleEncode(strm);
3369
3370   if (HasOptionalField(e_member))
3371     m_member.Encode(strm);
3372   m_group.Encode(strm);
3373
3374   UnknownExtensionsEncode(strm);
3375 }
3376
3377
3378 PObject * H225_GroupID::Clone() const
3379 {
3380 #ifndef PASN_LEANANDMEAN
3381   PAssert(IsClass(H225_GroupID::Class()), PInvalidCast);
3382 #endif
3383   return new H225_GroupID(*this);
3384 }
3385
3386
3387 //
3388 // ServiceControlSession
3389 //
3390
3391 H225_ServiceControlSession::H225_ServiceControlSession(unsigned tag, PASN_Object::TagClass tagClass)
3392   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
3393 {
3394   m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 0, 255);
3395 }
3396
3397
3398 #ifndef PASN_NOPRINTON
3399 void H225_ServiceControlSession::PrintOn(ostream & strm) const
3400 {
3401   int indent = strm.precision() + 2;
3402   strm << "{\n";
3403   strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
3404   if (HasOptionalField(e_contents))
3405     strm << setw(indent+11) << "contents = " << setprecision(indent) << m_contents << '\n';
3406   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
3407   strm << setw(indent-1) << setprecision(indent-2) << "}";
3408 }
3409 #endif
3410
3411
3412 PObject::Comparison H225_ServiceControlSession::Compare(const PObject & obj) const
3413 {
3414 #ifndef PASN_LEANANDMEAN
3415   PAssert(PIsDescendant(&obj, H225_ServiceControlSession), PInvalidCast);
3416 #endif
3417   const H225_ServiceControlSession & other = (const H225_ServiceControlSession &)obj;
3418
3419   Comparison result;
3420
3421   if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
3422     return result;
3423   if ((result = m_contents.Compare(other.m_contents)) != EqualTo)
3424     return result;
3425   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
3426     return result;
3427
3428   return PASN_Sequence::Compare(other);
3429 }
3430
3431
3432 PINDEX H225_ServiceControlSession::GetDataLength() const
3433 {
3434   PINDEX length = 0;
3435   length += m_sessionId.GetObjectLength();
3436   if (HasOptionalField(e_contents))
3437     length += m_contents.GetObjectLength();
3438   length += m_reason.GetObjectLength();
3439   return length;
3440 }
3441
3442
3443 BOOL H225_ServiceControlSession::Decode(PASN_Stream & strm)
3444 {
3445   if (!PreambleDecode(strm))
3446     return FALSE;
3447
3448   if (!m_sessionId.Decode(strm))
3449     return FALSE;
3450   if (HasOptionalField(e_contents) && !m_contents.Decode(strm))
3451     return FALSE;
3452   if (!m_reason.Decode(strm))
3453     return FALSE;
3454
3455   return UnknownExtensionsDecode(strm);
3456 }
3457
3458
3459 void H225_ServiceControlSession::Encode(PASN_Stream & strm) const
3460 {
3461   PreambleEncode(strm);
3462
3463   m_sessionId.Encode(strm);
3464   if (HasOptionalField(e_contents))
3465     m_contents.Encode(strm);
3466   m_reason.Encode(strm);
3467
3468   UnknownExtensionsEncode(strm);
3469 }
3470
3471
3472 PObject * H225_ServiceControlSession::Clone() const
3473 {
3474 #ifndef PASN_LEANANDMEAN
3475   PAssert(IsClass(H225_ServiceControlSession::Class()), PInvalidCast);
3476 #endif
3477   return new H225_ServiceControlSession(*this);
3478 }
3479
3480
3481 //
3482 // RasUsageInfoTypes
3483 //
3484
3485 H225_RasUsageInfoTypes::H225_RasUsageInfoTypes(unsigned tag, PASN_Object::TagClass tagClass)
3486   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
3487 {
3488 }
3489
3490
3491 #ifndef PASN_NOPRINTON
3492 void H225_RasUsageInfoTypes::PrintOn(ostream & strm) const
3493 {
3494   int indent = strm.precision() + 2;
3495   strm << "{\n";
3496   strm << setw(indent+24) << "nonStandardUsageTypes = " << setprecision(indent) << m_nonStandardUsageTypes << '\n';
3497   if (HasOptionalField(e_startTime))
3498     strm << setw(indent+12) << "startTime = " << setprecision(indent) << m_startTime << '\n';
3499   if (HasOptionalField(e_endTime))
3500     strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
3501   if (HasOptionalField(e_terminationCause))
3502     strm << setw(indent+19) << "terminationCause = " << setprecision(indent) << m_terminationCause << '\n';
3503   strm << setw(indent-1) << setprecision(indent-2) << "}";
3504 }
3505 #endif
3506
3507
3508 PObject::Comparison H225_RasUsageInfoTypes::Compare(const PObject & obj) const
3509 {
3510 #ifndef PASN_LEANANDMEAN
3511   PAssert(PIsDescendant(&obj, H225_RasUsageInfoTypes), PInvalidCast);
3512 #endif
3513   const H225_RasUsageInfoTypes & other = (const H225_RasUsageInfoTypes &)obj;
3514
3515   Comparison result;
3516
3517   if ((result = m_nonStandardUsageTypes.Compare(other.m_nonStandardUsageTypes)) != EqualTo)
3518     return result;
3519   if ((result = m_startTime.Compare(other.m_startTime)) != EqualTo)
3520     return result;
3521   if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
3522     return result;
3523   if ((result = m_terminationCause.Compare(other.m_terminationCause)) != EqualTo)
3524     return result;
3525
3526   return PASN_Sequence::Compare(other);
3527 }
3528
3529
3530 PINDEX H225_RasUsageInfoTypes::GetDataLength() const
3531 {
3532   PINDEX length = 0;
3533   length += m_nonStandardUsageTypes.GetObjectLength();
3534   if (HasOptionalField(e_startTime))
3535     length += m_startTime.GetObjectLength();
3536   if (HasOptionalField(e_endTime))
3537     length += m_endTime.GetObjectLength();
3538   if (HasOptionalField(e_terminationCause))
3539     length += m_terminationCause.GetObjectLength();
3540   return length;
3541 }
3542
3543
3544 BOOL H225_RasUsageInfoTypes::Decode(PASN_Stream & strm)
3545 {
3546   if (!PreambleDecode(strm))
3547     return FALSE;
3548
3549   if (!m_nonStandardUsageTypes.Decode(strm))
3550     return FALSE;
3551   if (HasOptionalField(e_startTime) && !m_startTime.Decode(strm))
3552     return FALSE;
3553   if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
3554     return FALSE;
3555   if (HasOptionalField(e_terminationCause) && !m_terminationCause.Decode(strm))
3556     return FALSE;
3557
3558   return UnknownExtensionsDecode(strm);
3559 }
3560
3561
3562 void H225_RasUsageInfoTypes::Encode(PASN_Stream & strm) const
3563 {
3564   PreambleEncode(strm);
3565
3566   m_nonStandardUsageTypes.Encode(strm);
3567   if (HasOptionalField(e_startTime))
3568     m_startTime.Encode(strm);
3569   if (HasOptionalField(e_endTime))
3570     m_endTime.Encode(strm);
3571   if (HasOptionalField(e_terminationCause))
3572     m_terminationCause.Encode(strm);
3573
3574   UnknownExtensionsEncode(strm);
3575 }
3576
3577
3578 PObject * H225_RasUsageInfoTypes::Clone() const
3579 {
3580 #ifndef PASN_LEANANDMEAN
3581   PAssert(IsClass(H225_RasUsageInfoTypes::Class()), PInvalidCast);
3582 #endif
3583   return new H225_RasUsageInfoTypes(*this);
3584 }
3585
3586
3587 //
3588 // RasUsageSpecification
3589 //
3590
3591 H225_RasUsageSpecification::H225_RasUsageSpecification(unsigned tag, PASN_Object::TagClass tagClass)
3592   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
3593 {
3594 }
3595
3596
3597 #ifndef PASN_NOPRINTON
3598 void H225_RasUsageSpecification::PrintOn(ostream & strm) const
3599 {
3600   int indent = strm.precision() + 2;
3601   strm << "{\n";
3602   strm << setw(indent+7) << "when = " << setprecision(indent) << m_when << '\n';
3603   if (HasOptionalField(e_callStartingPoint))
3604     strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
3605   strm << setw(indent+11) << "required = " << setprecision(indent) << m_required << '\n';
3606   strm << setw(indent-1) << setprecision(indent-2) << "}";
3607 }
3608 #endif
3609
3610
3611 PObject::Comparison H225_RasUsageSpecification::Compare(const PObject & obj) const
3612 {
3613 #ifndef PASN_LEANANDMEAN
3614   PAssert(PIsDescendant(&obj, H225_RasUsageSpecification), PInvalidCast);
3615 #endif
3616   const H225_RasUsageSpecification & other = (const H225_RasUsageSpecification &)obj;
3617
3618   Comparison result;
3619
3620   if ((result = m_when.Compare(other.m_when)) != EqualTo)
3621     return result;
3622   if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
3623     return result;
3624   if ((result = m_required.Compare(other.m_required)) != EqualTo)
3625     return result;
3626
3627   return PASN_Sequence::Compare(other);
3628 }
3629
3630
3631 PINDEX H225_RasUsageSpecification::GetDataLength() const
3632 {
3633   PINDEX length = 0;
3634   length += m_when.GetObjectLength();
3635   if (HasOptionalField(e_callStartingPoint))
3636     length += m_callStartingPoint.GetObjectLength();
3637   length += m_required.GetObjectLength();
3638   return length;
3639 }
3640
3641
3642 BOOL H225_RasUsageSpecification::Decode(PASN_Stream & strm)
3643 {
3644   if (!PreambleDecode(strm))
3645     return FALSE;
3646
3647   if (!m_when.Decode(strm))
3648     return FALSE;
3649   if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
3650     return FALSE;
3651   if (!m_required.Decode(strm))
3652     return FALSE;
3653
3654   return UnknownExtensionsDecode(strm);
3655 }
3656
3657
3658 void H225_RasUsageSpecification::Encode(PASN_Stream & strm) const
3659 {
3660   PreambleEncode(strm);
3661
3662   m_when.Encode(strm);
3663   if (HasOptionalField(e_callStartingPoint))
3664     m_callStartingPoint.Encode(strm);
3665   m_required.Encode(strm);
3666
3667   UnknownExtensionsEncode(strm);
3668 }
3669
3670
3671 PObject * H225_RasUsageSpecification::Clone() const
3672 {
3673 #ifndef PASN_LEANANDMEAN
3674   PAssert(IsClass(H225_RasUsageSpecification::Class()), PInvalidCast);
3675 #endif
3676   return new H225_RasUsageSpecification(*this);
3677 }
3678
3679
3680 //
3681 // RasUsageInformation
3682 //
3683
3684 H225_RasUsageInformation::H225_RasUsageInformation(unsigned tag, PASN_Object::TagClass tagClass)
3685   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
3686 {
3687 }
3688
3689
3690 #ifndef PASN_NOPRINTON
3691 void H225_RasUsageInformation::PrintOn(ostream & strm) const
3692 {
3693   int indent = strm.precision() + 2;
3694   strm << "{\n";
3695   strm << setw(indent+25) << "nonStandardUsageFields = " << setprecision(indent) << m_nonStandardUsageFields << '\n';
3696   if (HasOptionalField(e_alertingTime))
3697     strm << setw(indent+15) << "alertingTime = " << setprecision(indent) << m_alertingTime << '\n';
3698   if (HasOptionalField(e_connectTime))
3699     strm << setw(indent+14) << "connectTime = " << setprecision(indent) << m_connectTime << '\n';
3700   if (HasOptionalField(e_endTime))
3701     strm << setw(indent+10) << "endTime = " << setprecision(indent) << m_endTime << '\n';
3702   strm << setw(indent-1) << setprecision(indent-2) << "}";
3703 }
3704 #endif
3705
3706
3707 PObject::Comparison H225_RasUsageInformation::Compare(const PObject & obj) const
3708 {
3709 #ifndef PASN_LEANANDMEAN
3710   PAssert(PIsDescendant(&obj, H225_RasUsageInformation), PInvalidCast);
3711 #endif
3712   const H225_RasUsageInformation & other = (const H225_RasUsageInformation &)obj;
3713
3714   Comparison result;
3715
3716   if ((result = m_nonStandardUsageFields.Compare(other.m_nonStandardUsageFields)) != EqualTo)
3717     return result;
3718   if ((result = m_alertingTime.Compare(other.m_alertingTime)) != EqualTo)
3719     return result;
3720   if ((result = m_connectTime.Compare(other.m_connectTime)) != EqualTo)
3721     return result;
3722   if ((result = m_endTime.Compare(other.m_endTime)) != EqualTo)
3723     return result;
3724
3725   return PASN_Sequence::Compare(other);
3726 }
3727
3728
3729 PINDEX H225_RasUsageInformation::GetDataLength() const
3730 {
3731   PINDEX length = 0;
3732   length += m_nonStandardUsageFields.GetObjectLength();
3733   if (HasOptionalField(e_alertingTime))
3734     length += m_alertingTime.GetObjectLength();
3735   if (HasOptionalField(e_connectTime))
3736     length += m_connectTime.GetObjectLength();
3737   if (HasOptionalField(e_endTime))
3738     length += m_endTime.GetObjectLength();
3739   return length;
3740 }
3741
3742
3743 BOOL H225_RasUsageInformation::Decode(PASN_Stream & strm)
3744 {
3745   if (!PreambleDecode(strm))
3746     return FALSE;
3747
3748   if (!m_nonStandardUsageFields.Decode(strm))
3749     return FALSE;
3750   if (HasOptionalField(e_alertingTime) && !m_alertingTime.Decode(strm))
3751     return FALSE;
3752   if (HasOptionalField(e_connectTime) && !m_connectTime.Decode(strm))
3753     return FALSE;
3754   if (HasOptionalField(e_endTime) && !m_endTime.Decode(strm))
3755     return FALSE;
3756
3757   return UnknownExtensionsDecode(strm);
3758 }
3759
3760
3761 void H225_RasUsageInformation::Encode(PASN_Stream & strm) const
3762 {
3763   PreambleEncode(strm);
3764
3765   m_nonStandardUsageFields.Encode(strm);
3766   if (HasOptionalField(e_alertingTime))
3767     m_alertingTime.Encode(strm);
3768   if (HasOptionalField(e_connectTime))
3769     m_connectTime.Encode(strm);
3770   if (HasOptionalField(e_endTime))
3771     m_endTime.Encode(strm);
3772
3773   UnknownExtensionsEncode(strm);
3774 }
3775
3776
3777 PObject * H225_RasUsageInformation::Clone() const
3778 {
3779 #ifndef PASN_LEANANDMEAN
3780   PAssert(IsClass(H225_RasUsageInformation::Class()), PInvalidCast);
3781 #endif
3782   return new H225_RasUsageInformation(*this);
3783 }
3784
3785
3786 //
3787 // BandwidthDetails
3788 //
3789
3790 H225_BandwidthDetails::H225_BandwidthDetails(unsigned tag, PASN_Object::TagClass tagClass)
3791   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
3792 {
3793 }
3794
3795
3796 #ifndef PASN_NOPRINTON
3797 void H225_BandwidthDetails::PrintOn(ostream & strm) const
3798 {
3799   int indent = strm.precision() + 2;
3800   strm << "{\n";
3801   strm << setw(indent+9) << "sender = " << setprecision(indent) << m_sender << '\n';
3802   strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
3803   strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
3804   strm << setw(indent+16) << "rtcpAddresses = " << setprecision(indent) << m_rtcpAddresses << '\n';
3805   strm << setw(indent-1) << setprecision(indent-2) << "}";
3806 }
3807 #endif
3808
3809
3810 PObject::Comparison H225_BandwidthDetails::Compare(const PObject & obj) const
3811 {
3812 #ifndef PASN_LEANANDMEAN
3813   PAssert(PIsDescendant(&obj, H225_BandwidthDetails), PInvalidCast);
3814 #endif
3815   const H225_BandwidthDetails & other = (const H225_BandwidthDetails &)obj;
3816
3817   Comparison result;
3818
3819   if ((result = m_sender.Compare(other.m_sender)) != EqualTo)
3820     return result;
3821   if ((result = m_multicast.Compare(other.m_multicast)) != EqualTo)
3822     return result;
3823   if ((result = m_bandwidth.Compare(other.m_bandwidth)) != EqualTo)
3824     return result;
3825   if ((result = m_rtcpAddresses.Compare(other.m_rtcpAddresses)) != EqualTo)
3826     return result;
3827
3828   return PASN_Sequence::Compare(other);
3829 }
3830
3831
3832 PINDEX H225_BandwidthDetails::GetDataLength() const
3833 {
3834   PINDEX length = 0;
3835   length += m_sender.GetObjectLength();
3836   length += m_multicast.GetObjectLength();
3837   length += m_bandwidth.GetObjectLength();
3838   length += m_rtcpAddresses.GetObjectLength();
3839   return length;
3840 }
3841
3842
3843 BOOL H225_BandwidthDetails::Decode(PASN_Stream & strm)
3844 {
3845   if (!PreambleDecode(strm))
3846     return FALSE;
3847
3848   if (!m_sender.Decode(strm))
3849     return FALSE;
3850   if (!m_multicast.Decode(strm))
3851     return FALSE;
3852   if (!m_bandwidth.Decode(strm))
3853     return FALSE;
3854   if (!m_rtcpAddresses.Decode(strm))
3855     return FALSE;
3856
3857   return UnknownExtensionsDecode(strm);
3858 }
3859
3860
3861 void H225_BandwidthDetails::Encode(PASN_Stream & strm) const
3862 {
3863   PreambleEncode(strm);
3864
3865   m_sender.Encode(strm);
3866   m_multicast.Encode(strm);
3867   m_bandwidth.Encode(strm);
3868   m_rtcpAddresses.Encode(strm);
3869
3870   UnknownExtensionsEncode(strm);
3871 }
3872
3873
3874 PObject * H225_BandwidthDetails::Clone() const
3875 {
3876 #ifndef PASN_LEANANDMEAN
3877   PAssert(IsClass(H225_BandwidthDetails::Class()), PInvalidCast);
3878 #endif
3879   return new H225_BandwidthDetails(*this);
3880 }
3881
3882
3883 //
3884 // CallCreditServiceControl
3885 //
3886
3887 H225_CallCreditServiceControl::H225_CallCreditServiceControl(unsigned tag, PASN_Object::TagClass tagClass)
3888   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
3889 {
3890   m_amountString.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
3891   m_callDurationLimit.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
3892 }
3893
3894
3895 #ifndef PASN_NOPRINTON
3896 void H225_CallCreditServiceControl::PrintOn(ostream & strm) const
3897 {
3898   int indent = strm.precision() + 2;
3899   strm << "{\n";
3900   if (HasOptionalField(e_amountString))
3901     strm << setw(indent+15) << "amountString = " << setprecision(indent) << m_amountString << '\n';
3902   if (HasOptionalField(e_billingMode))
3903     strm << setw(indent+14) << "billingMode = " << setprecision(indent) << m_billingMode << '\n';
3904   if (HasOptionalField(e_callDurationLimit))
3905     strm << setw(indent+20) << "callDurationLimit = " << setprecision(indent) << m_callDurationLimit << '\n';
3906   if (HasOptionalField(e_enforceCallDurationLimit))
3907     strm << setw(indent+27) << "enforceCallDurationLimit = " << setprecision(indent) << m_enforceCallDurationLimit << '\n';
3908   if (HasOptionalField(e_callStartingPoint))
3909     strm << setw(indent+20) << "callStartingPoint = " << setprecision(indent) << m_callStartingPoint << '\n';
3910   strm << setw(indent-1) << setprecision(indent-2) << "}";
3911 }
3912 #endif
3913
3914
3915 PObject::Comparison H225_CallCreditServiceControl::Compare(const PObject & obj) const
3916 {
3917 #ifndef PASN_LEANANDMEAN
3918   PAssert(PIsDescendant(&obj, H225_CallCreditServiceControl), PInvalidCast);
3919 #endif
3920   const H225_CallCreditServiceControl & other = (const H225_CallCreditServiceControl &)obj;
3921
3922   Comparison result;
3923
3924   if ((result = m_amountString.Compare(other.m_amountString)) != EqualTo)
3925     return result;
3926   if ((result = m_billingMode.Compare(other.m_billingMode)) != EqualTo)
3927     return result;
3928   if ((result = m_callDurationLimit.Compare(other.m_callDurationLimit)) != EqualTo)
3929     return result;
3930   if ((result = m_enforceCallDurationLimit.Compare(other.m_enforceCallDurationLimit)) != EqualTo)
3931     return result;
3932   if ((result = m_callStartingPoint.Compare(other.m_callStartingPoint)) != EqualTo)
3933     return result;
3934
3935   return PASN_Sequence::Compare(other);
3936 }
3937
3938
3939 PINDEX H225_CallCreditServiceControl::GetDataLength() const
3940 {
3941   PINDEX length = 0;
3942   if (HasOptionalField(e_amountString))
3943     length += m_amountString.GetObjectLength();
3944   if (HasOptionalField(e_billingMode))
3945     length += m_billingMode.GetObjectLength();
3946   if (HasOptionalField(e_callDurationLimit))
3947     length += m_callDurationLimit.GetObjectLength();
3948   if (HasOptionalField(e_enforceCallDurationLimit))
3949     length += m_enforceCallDurationLimit.GetObjectLength();
3950   if (HasOptionalField(e_callStartingPoint))
3951     length += m_callStartingPoint.GetObjectLength();
3952   return length;
3953 }
3954
3955
3956 BOOL H225_CallCreditServiceControl::Decode(PASN_Stream & strm)
3957 {
3958   if (!PreambleDecode(strm))
3959     return FALSE;
3960
3961   if (HasOptionalField(e_amountString) && !m_amountString.Decode(strm))
3962     return FALSE;
3963   if (HasOptionalField(e_billingMode) && !m_billingMode.Decode(strm))
3964     return FALSE;
3965   if (HasOptionalField(e_callDurationLimit) && !m_callDurationLimit.Decode(strm))
3966     return FALSE;
3967   if (HasOptionalField(e_enforceCallDurationLimit) && !m_enforceCallDurationLimit.Decode(strm))
3968     return FALSE;
3969   if (HasOptionalField(e_callStartingPoint) && !m_callStartingPoint.Decode(strm))
3970     return FALSE;
3971
3972   return UnknownExtensionsDecode(strm);
3973 }
3974
3975
3976 void H225_CallCreditServiceControl::Encode(PASN_Stream & strm) const
3977 {
3978   PreambleEncode(strm);
3979
3980   if (HasOptionalField(e_amountString))
3981     m_amountString.Encode(strm);
3982   if (HasOptionalField(e_billingMode))
3983     m_billingMode.Encode(strm);
3984   if (HasOptionalField(e_callDurationLimit))
3985     m_callDurationLimit.Encode(strm);
3986   if (HasOptionalField(e_enforceCallDurationLimit))
3987     m_enforceCallDurationLimit.Encode(strm);
3988   if (HasOptionalField(e_callStartingPoint))
3989     m_callStartingPoint.Encode(strm);
3990
3991   UnknownExtensionsEncode(strm);
3992 }
3993
3994
3995 PObject * H225_CallCreditServiceControl::Clone() const
3996 {
3997 #ifndef PASN_LEANANDMEAN
3998   PAssert(IsClass(H225_CallCreditServiceControl::Class()), PInvalidCast);
3999 #endif
4000   return new H225_CallCreditServiceControl(*this);
4001 }
4002
4003
4004 //
4005 // GenericData
4006 //
4007
4008 H225_GenericData::H225_GenericData(unsigned tag, PASN_Object::TagClass tagClass)
4009   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
4010 {
4011   m_parameters.SetConstraints(PASN_Object::FixedConstraint, 1, 512);
4012 }
4013
4014
4015 #ifndef PASN_NOPRINTON
4016 void H225_GenericData::PrintOn(ostream & strm) const
4017 {
4018   int indent = strm.precision() + 2;
4019   strm << "{\n";
4020   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
4021   if (HasOptionalField(e_parameters))
4022     strm << setw(indent+13) << "parameters = " << setprecision(indent) << m_parameters << '\n';
4023   strm << setw(indent-1) << setprecision(indent-2) << "}";
4024 }
4025 #endif
4026
4027
4028 PObject::Comparison H225_GenericData::Compare(const PObject & obj) const
4029 {
4030 #ifndef PASN_LEANANDMEAN
4031   PAssert(PIsDescendant(&obj, H225_GenericData), PInvalidCast);
4032 #endif
4033   const H225_GenericData & other = (const H225_GenericData &)obj;
4034
4035   Comparison result;
4036
4037   if ((result = m_id.Compare(other.m_id)) != EqualTo)
4038     return result;
4039   if ((result = m_parameters.Compare(other.m_parameters)) != EqualTo)
4040     return result;
4041
4042   return PASN_Sequence::Compare(other);
4043 }
4044
4045
4046 PINDEX H225_GenericData::GetDataLength() const
4047 {
4048   PINDEX length = 0;
4049   length += m_id.GetObjectLength();
4050   if (HasOptionalField(e_parameters))
4051     length += m_parameters.GetObjectLength();
4052   return length;
4053 }
4054
4055
4056 BOOL H225_GenericData::Decode(PASN_Stream & strm)
4057 {
4058   if (!PreambleDecode(strm))
4059     return FALSE;
4060
4061   if (!m_id.Decode(strm))
4062     return FALSE;
4063   if (HasOptionalField(e_parameters) && !m_parameters.Decode(strm))
4064     return FALSE;
4065
4066   return UnknownExtensionsDecode(strm);
4067 }
4068
4069
4070 void H225_GenericData::Encode(PASN_Stream & strm) const
4071 {
4072   PreambleEncode(strm);
4073
4074   m_id.Encode(strm);
4075   if (HasOptionalField(e_parameters))
4076     m_parameters.Encode(strm);
4077
4078   UnknownExtensionsEncode(strm);
4079 }
4080
4081
4082 PObject * H225_GenericData::Clone() const
4083 {
4084 #ifndef PASN_LEANANDMEAN
4085   PAssert(IsClass(H225_GenericData::Class()), PInvalidCast);
4086 #endif
4087   return new H225_GenericData(*this);
4088 }
4089
4090
4091 //
4092 // EnumeratedParameter
4093 //
4094
4095 H225_EnumeratedParameter::H225_EnumeratedParameter(unsigned tag, PASN_Object::TagClass tagClass)
4096   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
4097 {
4098 }
4099
4100
4101 #ifndef PASN_NOPRINTON
4102 void H225_EnumeratedParameter::PrintOn(ostream & strm) const
4103 {
4104   int indent = strm.precision() + 2;
4105   strm << "{\n";
4106   strm << setw(indent+5) << "id = " << setprecision(indent) << m_id << '\n';
4107   if (HasOptionalField(e_content))
4108     strm << setw(indent+10) << "content = " << setprecision(indent) << m_content << '\n';
4109   strm << setw(indent-1) << setprecision(indent-2) << "}";
4110 }
4111 #endif
4112
4113
4114 PObject::Comparison H225_EnumeratedParameter::Compare(const PObject & obj) const
4115 {
4116 #ifndef PASN_LEANANDMEAN
4117   PAssert(PIsDescendant(&obj, H225_EnumeratedParameter), PInvalidCast);
4118 #endif
4119   const H225_EnumeratedParameter & other = (const H225_EnumeratedParameter &)obj;
4120
4121   Comparison result;
4122
4123   if ((result = m_id.Compare(other.m_id)) != EqualTo)
4124     return result;
4125   if ((result = m_content.Compare(other.m_content)) != EqualTo)
4126     return result;
4127
4128   return PASN_Sequence::Compare(other);
4129 }
4130
4131
4132 PINDEX H225_EnumeratedParameter::GetDataLength() const
4133 {
4134   PINDEX length = 0;
4135   length += m_id.GetObjectLength();
4136   if (HasOptionalField(e_content))
4137     length += m_content.GetObjectLength();
4138   return length;
4139 }
4140
4141
4142 BOOL H225_EnumeratedParameter::Decode(PASN_Stream & strm)
4143 {
4144   if (!PreambleDecode(strm))
4145     return FALSE;
4146
4147   if (!m_id.Decode(strm))
4148     return FALSE;
4149   if (HasOptionalField(e_content) && !m_content.Decode(strm))
4150     return FALSE;
4151
4152   return UnknownExtensionsDecode(strm);
4153 }
4154
4155
4156 void H225_EnumeratedParameter::Encode(PASN_Stream & strm) const
4157 {
4158   PreambleEncode(strm);
4159
4160   m_id.Encode(strm);
4161   if (HasOptionalField(e_content))
4162     m_content.Encode(strm);
4163
4164   UnknownExtensionsEncode(strm);
4165 }
4166
4167
4168 PObject * H225_EnumeratedParameter::Clone() const
4169 {
4170 #ifndef PASN_LEANANDMEAN
4171   PAssert(IsClass(H225_EnumeratedParameter::Class()), PInvalidCast);
4172 #endif
4173   return new H225_EnumeratedParameter(*this);
4174 }
4175
4176
4177 //
4178 // FeatureSet
4179 //
4180
4181 H225_FeatureSet::H225_FeatureSet(unsigned tag, PASN_Object::TagClass tagClass)
4182   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
4183 {
4184 }
4185
4186
4187 #ifndef PASN_NOPRINTON
4188 void H225_FeatureSet::PrintOn(ostream & strm) const
4189 {
4190   int indent = strm.precision() + 2;
4191   strm << "{\n";
4192   strm << setw(indent+24) << "replacementFeatureSet = " << setprecision(indent) << m_replacementFeatureSet << '\n';
4193   if (HasOptionalField(e_neededFeatures))
4194     strm << setw(indent+17) << "neededFeatures = " << setprecision(indent) << m_neededFeatures << '\n';
4195   if (HasOptionalField(e_desiredFeatures))
4196     strm << setw(indent+18) << "desiredFeatures = " << setprecision(indent) << m_desiredFeatures << '\n';
4197   if (HasOptionalField(e_supportedFeatures))
4198     strm << setw(indent+20) << "supportedFeatures = " << setprecision(indent) << m_supportedFeatures << '\n';
4199   strm << setw(indent-1) << setprecision(indent-2) << "}";
4200 }
4201 #endif
4202
4203
4204 PObject::Comparison H225_FeatureSet::Compare(const PObject & obj) const
4205 {
4206 #ifndef PASN_LEANANDMEAN
4207   PAssert(PIsDescendant(&obj, H225_FeatureSet), PInvalidCast);
4208 #endif
4209   const H225_FeatureSet & other = (const H225_FeatureSet &)obj;
4210
4211   Comparison result;
4212
4213   if ((result = m_replacementFeatureSet.Compare(other.m_replacementFeatureSet)) != EqualTo)
4214     return result;
4215   if ((result = m_neededFeatures.Compare(other.m_neededFeatures)) != EqualTo)
4216     return result;
4217   if ((result = m_desiredFeatures.Compare(other.m_desiredFeatures)) != EqualTo)
4218     return result;
4219   if ((result = m_supportedFeatures.Compare(other.m_supportedFeatures)) != EqualTo)
4220     return result;
4221
4222   return PASN_Sequence::Compare(other);
4223 }
4224
4225
4226 PINDEX H225_FeatureSet::GetDataLength() const
4227 {
4228   PINDEX length = 0;
4229   length += m_replacementFeatureSet.GetObjectLength();
4230   if (HasOptionalField(e_neededFeatures))
4231     length += m_neededFeatures.GetObjectLength();
4232   if (HasOptionalField(e_desiredFeatures))
4233     length += m_desiredFeatures.GetObjectLength();
4234   if (HasOptionalField(e_supportedFeatures))
4235     length += m_supportedFeatures.GetObjectLength();
4236   return length;
4237 }
4238
4239
4240 BOOL H225_FeatureSet::Decode(PASN_Stream & strm)
4241 {
4242   if (!PreambleDecode(strm))
4243     return FALSE;
4244
4245   if (!m_replacementFeatureSet.Decode(strm))
4246     return FALSE;
4247   if (HasOptionalField(e_neededFeatures) && !m_neededFeatures.Decode(strm))
4248     return FALSE;
4249   if (HasOptionalField(e_desiredFeatures) && !m_desiredFeatures.Decode(strm))
4250     return FALSE;
4251   if (HasOptionalField(e_supportedFeatures) && !m_supportedFeatures.Decode(strm))
4252     return FALSE;
4253
4254   return UnknownExtensionsDecode(strm);
4255 }
4256
4257
4258 void H225_FeatureSet::Encode(PASN_Stream & strm) const
4259 {
4260   PreambleEncode(strm);
4261
4262   m_replacementFeatureSet.Encode(strm);
4263   if (HasOptionalField(e_neededFeatures))
4264     m_neededFeatures.Encode(strm);
4265   if (HasOptionalField(e_desiredFeatures))
4266     m_desiredFeatures.Encode(strm);
4267   if (HasOptionalField(e_supportedFeatures))
4268     m_supportedFeatures.Encode(strm);
4269
4270   UnknownExtensionsEncode(strm);
4271 }
4272
4273
4274 PObject * H225_FeatureSet::Clone() const
4275 {
4276 #ifndef PASN_LEANANDMEAN
4277   PAssert(IsClass(H225_FeatureSet::Class()), PInvalidCast);
4278 #endif
4279   return new H225_FeatureSet(*this);
4280 }
4281
4282
4283 //
4284 // RTPSession
4285 //
4286
4287 H225_RTPSession::H225_RTPSession(unsigned tag, PASN_Object::TagClass tagClass)
4288   : PASN_Sequence(tag, tagClass, 0, TRUE, 2)
4289 {
4290   m_ssrc.SetConstraints(PASN_Object::FixedConstraint, 1, 4294967295U);
4291   m_sessionId.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
4292 }
4293
4294
4295 #ifndef PASN_NOPRINTON
4296 void H225_RTPSession::PrintOn(ostream & strm) const
4297 {
4298   int indent = strm.precision() + 2;
4299   strm << "{\n";
4300   strm << setw(indent+13) << "rtpAddress = " << setprecision(indent) << m_rtpAddress << '\n';
4301   strm << setw(indent+14) << "rtcpAddress = " << setprecision(indent) << m_rtcpAddress << '\n';
4302   strm << setw(indent+8) << "cname = " << setprecision(indent) << m_cname << '\n';
4303   strm << setw(indent+7) << "ssrc = " << setprecision(indent) << m_ssrc << '\n';
4304   strm << setw(indent+12) << "sessionId = " << setprecision(indent) << m_sessionId << '\n';
4305   strm << setw(indent+23) << "associatedSessionIds = " << setprecision(indent) << m_associatedSessionIds << '\n';
4306   if (HasOptionalField(e_multicast))
4307     strm << setw(indent+12) << "multicast = " << setprecision(indent) << m_multicast << '\n';
4308   if (HasOptionalField(e_bandwidth))
4309     strm << setw(indent+12) << "bandwidth = " << setprecision(indent) << m_bandwidth << '\n';
4310   strm << setw(indent-1) << setprecision(indent-2) << "}";
4311 }
4312 #endif
4313
4314
4315 PObject::Comparison H225_RTPSession::Compare(const PObject & obj) const
4316 {
4317 #ifndef PASN_LEANANDMEAN
4318   PAssert(PIsDescendant(&obj, H225_RTPSession), PInvalidCast);
4319 #endif
4320   const H225_RTPSession & other = (const H225_RTPSession &)obj;
4321
4322   Comparison result;
4323
4324   if ((result = m_rtpAddress.Compare(other.m_rtpAddress)) != EqualTo)
4325     return result;
4326   if ((result = m_rtcpAddress.Compare(other.m_rtcpAddress)) != EqualTo)
4327     return result;
4328   if ((result = m_cname.Compare(other.m_cname)) != EqualTo)
4329     return result;
4330   if ((result = m_ssrc.Compare(other.m_ssrc)) != EqualTo)
4331     return result;
4332   if ((result = m_sessionId.Compare(other.m_sessionId)) != EqualTo)
4333     return result;
4334   if ((result = m_associatedSessionIds.Compare(other.m_associatedSessionIds)) != EqualTo)
4335     return result;
4336
4337   return PASN_Sequence::Compare(other);
4338 }
4339
4340
4341 PINDEX H225_RTPSession::GetDataLength() const
4342 {
4343   PINDEX length = 0;
4344   length += m_rtpAddress.GetObjectLength();
4345   length += m_rtcpAddress.GetObjectLength();
4346   length += m_cname.GetObjectLength();
4347   length += m_ssrc.GetObjectLength();
4348   length += m_sessionId.GetObjectLength();
4349   length += m_associatedSessionIds.GetObjectLength();
4350   return length;
4351 }
4352
4353
4354 BOOL H225_RTPSession::Decode(PASN_Stream & strm)
4355 {
4356   if (!PreambleDecode(strm))
4357     return FALSE;
4358
4359   if (!m_rtpAddress.Decode(strm))
4360     return FALSE;
4361   if (!m_rtcpAddress.Decode(strm))
4362     return FALSE;
4363   if (!m_cname.Decode(strm))
4364     return FALSE;
4365   if (!m_ssrc.Decode(strm))
4366     return FALSE;
4367   if (!m_sessionId.Decode(strm))
4368     return FALSE;
4369   if (!m_associatedSessionIds.Decode(strm))
4370     return FALSE;
4371   if (!KnownExtensionDecode(strm, e_multicast, m_multicast))
4372     return FALSE;
4373   if (!KnownExtensionDecode(strm, e_bandwidth, m_bandwidth))
4374     return FALSE;
4375
4376   return UnknownExtensionsDecode(strm);
4377 }
4378
4379
4380 void H225_RTPSession::Encode(PASN_Stream & strm) const
4381 {
4382   PreambleEncode(strm);
4383
4384   m_rtpAddress.Encode(strm);
4385   m_rtcpAddress.Encode(strm);
4386   m_cname.Encode(strm);
4387   m_ssrc.Encode(strm);
4388   m_sessionId.Encode(strm);
4389   m_associatedSessionIds.Encode(strm);
4390   KnownExtensionEncode(strm, e_multicast, m_multicast);
4391   KnownExtensionEncode(strm, e_bandwidth, m_bandwidth);
4392
4393   UnknownExtensionsEncode(strm);
4394 }
4395
4396
4397 PObject * H225_RTPSession::Clone() const
4398 {
4399 #ifndef PASN_LEANANDMEAN
4400   PAssert(IsClass(H225_RTPSession::Class()), PInvalidCast);
4401 #endif
4402   return new H225_RTPSession(*this);
4403 }
4404
4405
4406 //
4407 // GatekeeperConfirm
4408 //
4409
4410 H225_GatekeeperConfirm::H225_GatekeeperConfirm(unsigned tag, PASN_Object::TagClass tagClass)
4411   : PASN_Sequence(tag, tagClass, 2, TRUE, 11)
4412 {
4413 }
4414
4415
4416 #ifndef PASN_NOPRINTON
4417 void H225_GatekeeperConfirm::PrintOn(ostream & strm) const
4418 {
4419   int indent = strm.precision() + 2;
4420   strm << "{\n";
4421   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
4422   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
4423   if (HasOptionalField(e_nonStandardData))
4424     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
4425   if (HasOptionalField(e_gatekeeperIdentifier))
4426     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
4427   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
4428   if (HasOptionalField(e_alternateGatekeeper))
4429     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
4430   if (HasOptionalField(e_authenticationMode))
4431     strm << setw(indent+21) << "authenticationMode = " << setprecision(indent) << m_authenticationMode << '\n';
4432   if (HasOptionalField(e_tokens))
4433     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
4434   if (HasOptionalField(e_cryptoTokens))
4435     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
4436   if (HasOptionalField(e_algorithmOID))
4437     strm << setw(indent+15) << "algorithmOID = " << setprecision(indent) << m_algorithmOID << '\n';
4438   if (HasOptionalField(e_integrity))
4439     strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
4440   if (HasOptionalField(e_integrityCheckValue))
4441     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
4442   if (HasOptionalField(e_featureSet))
4443     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
4444   if (HasOptionalField(e_genericData))
4445     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
4446   if (HasOptionalField(e_assignedGatekeeper))
4447     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
4448   if (HasOptionalField(e_rehomingModel))
4449     strm << setw(indent+16) << "rehomingModel = " << setprecision(indent) << m_rehomingModel << '\n';
4450   strm << setw(indent-1) << setprecision(indent-2) << "}";
4451 }
4452 #endif
4453
4454
4455 PObject::Comparison H225_GatekeeperConfirm::Compare(const PObject & obj) const
4456 {
4457 #ifndef PASN_LEANANDMEAN
4458   PAssert(PIsDescendant(&obj, H225_GatekeeperConfirm), PInvalidCast);
4459 #endif
4460   const H225_GatekeeperConfirm & other = (const H225_GatekeeperConfirm &)obj;
4461
4462   Comparison result;
4463
4464   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
4465     return result;
4466   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
4467     return result;
4468   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
4469     return result;
4470   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
4471     return result;
4472   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
4473     return result;
4474
4475   return PASN_Sequence::Compare(other);
4476 }
4477
4478
4479 PINDEX H225_GatekeeperConfirm::GetDataLength() const
4480 {
4481   PINDEX length = 0;
4482   length += m_requestSeqNum.GetObjectLength();
4483   length += m_protocolIdentifier.GetObjectLength();
4484   if (HasOptionalField(e_nonStandardData))
4485     length += m_nonStandardData.GetObjectLength();
4486   if (HasOptionalField(e_gatekeeperIdentifier))
4487     length += m_gatekeeperIdentifier.GetObjectLength();
4488   length += m_rasAddress.GetObjectLength();
4489   return length;
4490 }
4491
4492
4493 BOOL H225_GatekeeperConfirm::Decode(PASN_Stream & strm)
4494 {
4495   if (!PreambleDecode(strm))
4496     return FALSE;
4497
4498   if (!m_requestSeqNum.Decode(strm))
4499     return FALSE;
4500   if (!m_protocolIdentifier.Decode(strm))
4501     return FALSE;
4502   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
4503     return FALSE;
4504   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
4505     return FALSE;
4506   if (!m_rasAddress.Decode(strm))
4507     return FALSE;
4508   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
4509     return FALSE;
4510   if (!KnownExtensionDecode(strm, e_authenticationMode, m_authenticationMode))
4511     return FALSE;
4512   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
4513     return FALSE;
4514   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
4515     return FALSE;
4516   if (!KnownExtensionDecode(strm, e_algorithmOID, m_algorithmOID))
4517     return FALSE;
4518   if (!KnownExtensionDecode(strm, e_integrity, m_integrity))
4519     return FALSE;
4520   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
4521     return FALSE;
4522   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
4523     return FALSE;
4524   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
4525     return FALSE;
4526   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
4527     return FALSE;
4528   if (!KnownExtensionDecode(strm, e_rehomingModel, m_rehomingModel))
4529     return FALSE;
4530
4531   return UnknownExtensionsDecode(strm);
4532 }
4533
4534
4535 void H225_GatekeeperConfirm::Encode(PASN_Stream & strm) const
4536 {
4537   PreambleEncode(strm);
4538
4539   m_requestSeqNum.Encode(strm);
4540   m_protocolIdentifier.Encode(strm);
4541   if (HasOptionalField(e_nonStandardData))
4542     m_nonStandardData.Encode(strm);
4543   if (HasOptionalField(e_gatekeeperIdentifier))
4544     m_gatekeeperIdentifier.Encode(strm);
4545   m_rasAddress.Encode(strm);
4546   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
4547   KnownExtensionEncode(strm, e_authenticationMode, m_authenticationMode);
4548   KnownExtensionEncode(strm, e_tokens, m_tokens);
4549   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
4550   KnownExtensionEncode(strm, e_algorithmOID, m_algorithmOID);
4551   KnownExtensionEncode(strm, e_integrity, m_integrity);
4552   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
4553   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
4554   KnownExtensionEncode(strm, e_genericData, m_genericData);
4555   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
4556   KnownExtensionEncode(strm, e_rehomingModel, m_rehomingModel);
4557
4558   UnknownExtensionsEncode(strm);
4559 }
4560
4561
4562 PObject * H225_GatekeeperConfirm::Clone() const
4563 {
4564 #ifndef PASN_LEANANDMEAN
4565   PAssert(IsClass(H225_GatekeeperConfirm::Class()), PInvalidCast);
4566 #endif
4567   return new H225_GatekeeperConfirm(*this);
4568 }
4569
4570
4571 //
4572 // GatekeeperReject
4573 //
4574
4575 H225_GatekeeperReject::H225_GatekeeperReject(unsigned tag, PASN_Object::TagClass tagClass)
4576   : PASN_Sequence(tag, tagClass, 2, TRUE, 6)
4577 {
4578 }
4579
4580
4581 #ifndef PASN_NOPRINTON
4582 void H225_GatekeeperReject::PrintOn(ostream & strm) const
4583 {
4584   int indent = strm.precision() + 2;
4585   strm << "{\n";
4586   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
4587   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
4588   if (HasOptionalField(e_nonStandardData))
4589     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
4590   if (HasOptionalField(e_gatekeeperIdentifier))
4591     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
4592   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
4593   if (HasOptionalField(e_altGKInfo))
4594     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
4595   if (HasOptionalField(e_tokens))
4596     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
4597   if (HasOptionalField(e_cryptoTokens))
4598     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
4599   if (HasOptionalField(e_integrityCheckValue))
4600     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
4601   if (HasOptionalField(e_featureSet))
4602     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
4603   if (HasOptionalField(e_genericData))
4604     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
4605   strm << setw(indent-1) << setprecision(indent-2) << "}";
4606 }
4607 #endif
4608
4609
4610 PObject::Comparison H225_GatekeeperReject::Compare(const PObject & obj) const
4611 {
4612 #ifndef PASN_LEANANDMEAN
4613   PAssert(PIsDescendant(&obj, H225_GatekeeperReject), PInvalidCast);
4614 #endif
4615   const H225_GatekeeperReject & other = (const H225_GatekeeperReject &)obj;
4616
4617   Comparison result;
4618
4619   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
4620     return result;
4621   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
4622     return result;
4623   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
4624     return result;
4625   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
4626     return result;
4627   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
4628     return result;
4629
4630   return PASN_Sequence::Compare(other);
4631 }
4632
4633
4634 PINDEX H225_GatekeeperReject::GetDataLength() const
4635 {
4636   PINDEX length = 0;
4637   length += m_requestSeqNum.GetObjectLength();
4638   length += m_protocolIdentifier.GetObjectLength();
4639   if (HasOptionalField(e_nonStandardData))
4640     length += m_nonStandardData.GetObjectLength();
4641   if (HasOptionalField(e_gatekeeperIdentifier))
4642     length += m_gatekeeperIdentifier.GetObjectLength();
4643   length += m_rejectReason.GetObjectLength();
4644   return length;
4645 }
4646
4647
4648 BOOL H225_GatekeeperReject::Decode(PASN_Stream & strm)
4649 {
4650   if (!PreambleDecode(strm))
4651     return FALSE;
4652
4653   if (!m_requestSeqNum.Decode(strm))
4654     return FALSE;
4655   if (!m_protocolIdentifier.Decode(strm))
4656     return FALSE;
4657   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
4658     return FALSE;
4659   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
4660     return FALSE;
4661   if (!m_rejectReason.Decode(strm))
4662     return FALSE;
4663   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
4664     return FALSE;
4665   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
4666     return FALSE;
4667   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
4668     return FALSE;
4669   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
4670     return FALSE;
4671   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
4672     return FALSE;
4673   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
4674     return FALSE;
4675
4676   return UnknownExtensionsDecode(strm);
4677 }
4678
4679
4680 void H225_GatekeeperReject::Encode(PASN_Stream & strm) const
4681 {
4682   PreambleEncode(strm);
4683
4684   m_requestSeqNum.Encode(strm);
4685   m_protocolIdentifier.Encode(strm);
4686   if (HasOptionalField(e_nonStandardData))
4687     m_nonStandardData.Encode(strm);
4688   if (HasOptionalField(e_gatekeeperIdentifier))
4689     m_gatekeeperIdentifier.Encode(strm);
4690   m_rejectReason.Encode(strm);
4691   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
4692   KnownExtensionEncode(strm, e_tokens, m_tokens);
4693   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
4694   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
4695   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
4696   KnownExtensionEncode(strm, e_genericData, m_genericData);
4697
4698   UnknownExtensionsEncode(strm);
4699 }
4700
4701
4702 PObject * H225_GatekeeperReject::Clone() const
4703 {
4704 #ifndef PASN_LEANANDMEAN
4705   PAssert(IsClass(H225_GatekeeperReject::Class()), PInvalidCast);
4706 #endif
4707   return new H225_GatekeeperReject(*this);
4708 }
4709
4710
4711 //
4712 // RegistrationReject
4713 //
4714
4715 H225_RegistrationReject::H225_RegistrationReject(unsigned tag, PASN_Object::TagClass tagClass)
4716   : PASN_Sequence(tag, tagClass, 2, TRUE, 7)
4717 {
4718 }
4719
4720
4721 #ifndef PASN_NOPRINTON
4722 void H225_RegistrationReject::PrintOn(ostream & strm) const
4723 {
4724   int indent = strm.precision() + 2;
4725   strm << "{\n";
4726   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
4727   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
4728   if (HasOptionalField(e_nonStandardData))
4729     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
4730   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
4731   if (HasOptionalField(e_gatekeeperIdentifier))
4732     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
4733   if (HasOptionalField(e_altGKInfo))
4734     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
4735   if (HasOptionalField(e_tokens))
4736     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
4737   if (HasOptionalField(e_cryptoTokens))
4738     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
4739   if (HasOptionalField(e_integrityCheckValue))
4740     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
4741   if (HasOptionalField(e_featureSet))
4742     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
4743   if (HasOptionalField(e_genericData))
4744     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
4745   if (HasOptionalField(e_assignedGatekeeper))
4746     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
4747   strm << setw(indent-1) << setprecision(indent-2) << "}";
4748 }
4749 #endif
4750
4751
4752 PObject::Comparison H225_RegistrationReject::Compare(const PObject & obj) const
4753 {
4754 #ifndef PASN_LEANANDMEAN
4755   PAssert(PIsDescendant(&obj, H225_RegistrationReject), PInvalidCast);
4756 #endif
4757   const H225_RegistrationReject & other = (const H225_RegistrationReject &)obj;
4758
4759   Comparison result;
4760
4761   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
4762     return result;
4763   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
4764     return result;
4765   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
4766     return result;
4767   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
4768     return result;
4769   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
4770     return result;
4771
4772   return PASN_Sequence::Compare(other);
4773 }
4774
4775
4776 PINDEX H225_RegistrationReject::GetDataLength() const
4777 {
4778   PINDEX length = 0;
4779   length += m_requestSeqNum.GetObjectLength();
4780   length += m_protocolIdentifier.GetObjectLength();
4781   if (HasOptionalField(e_nonStandardData))
4782     length += m_nonStandardData.GetObjectLength();
4783   length += m_rejectReason.GetObjectLength();
4784   if (HasOptionalField(e_gatekeeperIdentifier))
4785     length += m_gatekeeperIdentifier.GetObjectLength();
4786   return length;
4787 }
4788
4789
4790 BOOL H225_RegistrationReject::Decode(PASN_Stream & strm)
4791 {
4792   if (!PreambleDecode(strm))
4793     return FALSE;
4794
4795   if (!m_requestSeqNum.Decode(strm))
4796     return FALSE;
4797   if (!m_protocolIdentifier.Decode(strm))
4798     return FALSE;
4799   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
4800     return FALSE;
4801   if (!m_rejectReason.Decode(strm))
4802     return FALSE;
4803   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
4804     return FALSE;
4805   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
4806     return FALSE;
4807   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
4808     return FALSE;
4809   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
4810     return FALSE;
4811   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
4812     return FALSE;
4813   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
4814     return FALSE;
4815   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
4816     return FALSE;
4817   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
4818     return FALSE;
4819
4820   return UnknownExtensionsDecode(strm);
4821 }
4822
4823
4824 void H225_RegistrationReject::Encode(PASN_Stream & strm) const
4825 {
4826   PreambleEncode(strm);
4827
4828   m_requestSeqNum.Encode(strm);
4829   m_protocolIdentifier.Encode(strm);
4830   if (HasOptionalField(e_nonStandardData))
4831     m_nonStandardData.Encode(strm);
4832   m_rejectReason.Encode(strm);
4833   if (HasOptionalField(e_gatekeeperIdentifier))
4834     m_gatekeeperIdentifier.Encode(strm);
4835   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
4836   KnownExtensionEncode(strm, e_tokens, m_tokens);
4837   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
4838   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
4839   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
4840   KnownExtensionEncode(strm, e_genericData, m_genericData);
4841   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
4842
4843   UnknownExtensionsEncode(strm);
4844 }
4845
4846
4847 PObject * H225_RegistrationReject::Clone() const
4848 {
4849 #ifndef PASN_LEANANDMEAN
4850   PAssert(IsClass(H225_RegistrationReject::Class()), PInvalidCast);
4851 #endif
4852   return new H225_RegistrationReject(*this);
4853 }
4854
4855
4856 //
4857 // UnregistrationRequest
4858 //
4859
4860 H225_UnregistrationRequest::H225_UnregistrationRequest(unsigned tag, PASN_Object::TagClass tagClass)
4861   : PASN_Sequence(tag, tagClass, 3, TRUE, 11)
4862 {
4863 }
4864
4865
4866 #ifndef PASN_NOPRINTON
4867 void H225_UnregistrationRequest::PrintOn(ostream & strm) const
4868 {
4869   int indent = strm.precision() + 2;
4870   strm << "{\n";
4871   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
4872   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
4873   if (HasOptionalField(e_endpointAlias))
4874     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
4875   if (HasOptionalField(e_nonStandardData))
4876     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
4877   if (HasOptionalField(e_endpointIdentifier))
4878     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
4879   if (HasOptionalField(e_alternateEndpoints))
4880     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
4881   if (HasOptionalField(e_gatekeeperIdentifier))
4882     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
4883   if (HasOptionalField(e_tokens))
4884     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
4885   if (HasOptionalField(e_cryptoTokens))
4886     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
4887   if (HasOptionalField(e_integrityCheckValue))
4888     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
4889   if (HasOptionalField(e_reason))
4890     strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
4891   if (HasOptionalField(e_endpointAliasPattern))
4892     strm << setw(indent+23) << "endpointAliasPattern = " << setprecision(indent) << m_endpointAliasPattern << '\n';
4893   if (HasOptionalField(e_supportedPrefixes))
4894     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
4895   if (HasOptionalField(e_alternateGatekeeper))
4896     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
4897   if (HasOptionalField(e_genericData))
4898     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
4899   if (HasOptionalField(e_assignedGatekeeper))
4900     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
4901   strm << setw(indent-1) << setprecision(indent-2) << "}";
4902 }
4903 #endif
4904
4905
4906 PObject::Comparison H225_UnregistrationRequest::Compare(const PObject & obj) const
4907 {
4908 #ifndef PASN_LEANANDMEAN
4909   PAssert(PIsDescendant(&obj, H225_UnregistrationRequest), PInvalidCast);
4910 #endif
4911   const H225_UnregistrationRequest & other = (const H225_UnregistrationRequest &)obj;
4912
4913   Comparison result;
4914
4915   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
4916     return result;
4917   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
4918     return result;
4919   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
4920     return result;
4921   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
4922     return result;
4923   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
4924     return result;
4925
4926   return PASN_Sequence::Compare(other);
4927 }
4928
4929
4930 PINDEX H225_UnregistrationRequest::GetDataLength() const
4931 {
4932   PINDEX length = 0;
4933   length += m_requestSeqNum.GetObjectLength();
4934   length += m_callSignalAddress.GetObjectLength();
4935   if (HasOptionalField(e_endpointAlias))
4936     length += m_endpointAlias.GetObjectLength();
4937   if (HasOptionalField(e_nonStandardData))
4938     length += m_nonStandardData.GetObjectLength();
4939   if (HasOptionalField(e_endpointIdentifier))
4940     length += m_endpointIdentifier.GetObjectLength();
4941   return length;
4942 }
4943
4944
4945 BOOL H225_UnregistrationRequest::Decode(PASN_Stream & strm)
4946 {
4947   if (!PreambleDecode(strm))
4948     return FALSE;
4949
4950   if (!m_requestSeqNum.Decode(strm))
4951     return FALSE;
4952   if (!m_callSignalAddress.Decode(strm))
4953     return FALSE;
4954   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
4955     return FALSE;
4956   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
4957     return FALSE;
4958   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
4959     return FALSE;
4960   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
4961     return FALSE;
4962   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
4963     return FALSE;
4964   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
4965     return FALSE;
4966   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
4967     return FALSE;
4968   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
4969     return FALSE;
4970   if (!KnownExtensionDecode(strm, e_reason, m_reason))
4971     return FALSE;
4972   if (!KnownExtensionDecode(strm, e_endpointAliasPattern, m_endpointAliasPattern))
4973     return FALSE;
4974   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
4975     return FALSE;
4976   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
4977     return FALSE;
4978   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
4979     return FALSE;
4980   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
4981     return FALSE;
4982
4983   return UnknownExtensionsDecode(strm);
4984 }
4985
4986
4987 void H225_UnregistrationRequest::Encode(PASN_Stream & strm) const
4988 {
4989   PreambleEncode(strm);
4990
4991   m_requestSeqNum.Encode(strm);
4992   m_callSignalAddress.Encode(strm);
4993   if (HasOptionalField(e_endpointAlias))
4994     m_endpointAlias.Encode(strm);
4995   if (HasOptionalField(e_nonStandardData))
4996     m_nonStandardData.Encode(strm);
4997   if (HasOptionalField(e_endpointIdentifier))
4998     m_endpointIdentifier.Encode(strm);
4999   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
5000   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
5001   KnownExtensionEncode(strm, e_tokens, m_tokens);
5002   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5003   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5004   KnownExtensionEncode(strm, e_reason, m_reason);
5005   KnownExtensionEncode(strm, e_endpointAliasPattern, m_endpointAliasPattern);
5006   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
5007   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
5008   KnownExtensionEncode(strm, e_genericData, m_genericData);
5009   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
5010
5011   UnknownExtensionsEncode(strm);
5012 }
5013
5014
5015 PObject * H225_UnregistrationRequest::Clone() const
5016 {
5017 #ifndef PASN_LEANANDMEAN
5018   PAssert(IsClass(H225_UnregistrationRequest::Class()), PInvalidCast);
5019 #endif
5020   return new H225_UnregistrationRequest(*this);
5021 }
5022
5023
5024 //
5025 // UnregistrationConfirm
5026 //
5027
5028 H225_UnregistrationConfirm::H225_UnregistrationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
5029   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
5030 {
5031 }
5032
5033
5034 #ifndef PASN_NOPRINTON
5035 void H225_UnregistrationConfirm::PrintOn(ostream & strm) const
5036 {
5037   int indent = strm.precision() + 2;
5038   strm << "{\n";
5039   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5040   if (HasOptionalField(e_nonStandardData))
5041     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5042   if (HasOptionalField(e_tokens))
5043     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5044   if (HasOptionalField(e_cryptoTokens))
5045     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5046   if (HasOptionalField(e_integrityCheckValue))
5047     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5048   if (HasOptionalField(e_genericData))
5049     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5050   if (HasOptionalField(e_assignedGatekeeper))
5051     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
5052   strm << setw(indent-1) << setprecision(indent-2) << "}";
5053 }
5054 #endif
5055
5056
5057 PObject::Comparison H225_UnregistrationConfirm::Compare(const PObject & obj) const
5058 {
5059 #ifndef PASN_LEANANDMEAN
5060   PAssert(PIsDescendant(&obj, H225_UnregistrationConfirm), PInvalidCast);
5061 #endif
5062   const H225_UnregistrationConfirm & other = (const H225_UnregistrationConfirm &)obj;
5063
5064   Comparison result;
5065
5066   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5067     return result;
5068   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5069     return result;
5070
5071   return PASN_Sequence::Compare(other);
5072 }
5073
5074
5075 PINDEX H225_UnregistrationConfirm::GetDataLength() const
5076 {
5077   PINDEX length = 0;
5078   length += m_requestSeqNum.GetObjectLength();
5079   if (HasOptionalField(e_nonStandardData))
5080     length += m_nonStandardData.GetObjectLength();
5081   return length;
5082 }
5083
5084
5085 BOOL H225_UnregistrationConfirm::Decode(PASN_Stream & strm)
5086 {
5087   if (!PreambleDecode(strm))
5088     return FALSE;
5089
5090   if (!m_requestSeqNum.Decode(strm))
5091     return FALSE;
5092   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5093     return FALSE;
5094   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5095     return FALSE;
5096   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5097     return FALSE;
5098   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5099     return FALSE;
5100   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5101     return FALSE;
5102   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
5103     return FALSE;
5104
5105   return UnknownExtensionsDecode(strm);
5106 }
5107
5108
5109 void H225_UnregistrationConfirm::Encode(PASN_Stream & strm) const
5110 {
5111   PreambleEncode(strm);
5112
5113   m_requestSeqNum.Encode(strm);
5114   if (HasOptionalField(e_nonStandardData))
5115     m_nonStandardData.Encode(strm);
5116   KnownExtensionEncode(strm, e_tokens, m_tokens);
5117   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5118   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5119   KnownExtensionEncode(strm, e_genericData, m_genericData);
5120   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
5121
5122   UnknownExtensionsEncode(strm);
5123 }
5124
5125
5126 PObject * H225_UnregistrationConfirm::Clone() const
5127 {
5128 #ifndef PASN_LEANANDMEAN
5129   PAssert(IsClass(H225_UnregistrationConfirm::Class()), PInvalidCast);
5130 #endif
5131   return new H225_UnregistrationConfirm(*this);
5132 }
5133
5134
5135 //
5136 // UnregistrationReject
5137 //
5138
5139 H225_UnregistrationReject::H225_UnregistrationReject(unsigned tag, PASN_Object::TagClass tagClass)
5140   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
5141 {
5142 }
5143
5144
5145 #ifndef PASN_NOPRINTON
5146 void H225_UnregistrationReject::PrintOn(ostream & strm) const
5147 {
5148   int indent = strm.precision() + 2;
5149   strm << "{\n";
5150   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5151   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
5152   if (HasOptionalField(e_nonStandardData))
5153     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5154   if (HasOptionalField(e_altGKInfo))
5155     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
5156   if (HasOptionalField(e_tokens))
5157     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5158   if (HasOptionalField(e_cryptoTokens))
5159     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5160   if (HasOptionalField(e_integrityCheckValue))
5161     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5162   if (HasOptionalField(e_genericData))
5163     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5164   strm << setw(indent-1) << setprecision(indent-2) << "}";
5165 }
5166 #endif
5167
5168
5169 PObject::Comparison H225_UnregistrationReject::Compare(const PObject & obj) const
5170 {
5171 #ifndef PASN_LEANANDMEAN
5172   PAssert(PIsDescendant(&obj, H225_UnregistrationReject), PInvalidCast);
5173 #endif
5174   const H225_UnregistrationReject & other = (const H225_UnregistrationReject &)obj;
5175
5176   Comparison result;
5177
5178   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5179     return result;
5180   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
5181     return result;
5182   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5183     return result;
5184
5185   return PASN_Sequence::Compare(other);
5186 }
5187
5188
5189 PINDEX H225_UnregistrationReject::GetDataLength() const
5190 {
5191   PINDEX length = 0;
5192   length += m_requestSeqNum.GetObjectLength();
5193   length += m_rejectReason.GetObjectLength();
5194   if (HasOptionalField(e_nonStandardData))
5195     length += m_nonStandardData.GetObjectLength();
5196   return length;
5197 }
5198
5199
5200 BOOL H225_UnregistrationReject::Decode(PASN_Stream & strm)
5201 {
5202   if (!PreambleDecode(strm))
5203     return FALSE;
5204
5205   if (!m_requestSeqNum.Decode(strm))
5206     return FALSE;
5207   if (!m_rejectReason.Decode(strm))
5208     return FALSE;
5209   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5210     return FALSE;
5211   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
5212     return FALSE;
5213   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5214     return FALSE;
5215   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5216     return FALSE;
5217   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5218     return FALSE;
5219   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5220     return FALSE;
5221
5222   return UnknownExtensionsDecode(strm);
5223 }
5224
5225
5226 void H225_UnregistrationReject::Encode(PASN_Stream & strm) const
5227 {
5228   PreambleEncode(strm);
5229
5230   m_requestSeqNum.Encode(strm);
5231   m_rejectReason.Encode(strm);
5232   if (HasOptionalField(e_nonStandardData))
5233     m_nonStandardData.Encode(strm);
5234   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
5235   KnownExtensionEncode(strm, e_tokens, m_tokens);
5236   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5237   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5238   KnownExtensionEncode(strm, e_genericData, m_genericData);
5239
5240   UnknownExtensionsEncode(strm);
5241 }
5242
5243
5244 PObject * H225_UnregistrationReject::Clone() const
5245 {
5246 #ifndef PASN_LEANANDMEAN
5247   PAssert(IsClass(H225_UnregistrationReject::Class()), PInvalidCast);
5248 #endif
5249   return new H225_UnregistrationReject(*this);
5250 }
5251
5252
5253 //
5254 // AdmissionReject
5255 //
5256
5257 H225_AdmissionReject::H225_AdmissionReject(unsigned tag, PASN_Object::TagClass tagClass)
5258   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
5259 {
5260 }
5261
5262
5263 #ifndef PASN_NOPRINTON
5264 void H225_AdmissionReject::PrintOn(ostream & strm) const
5265 {
5266   int indent = strm.precision() + 2;
5267   strm << "{\n";
5268   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5269   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
5270   if (HasOptionalField(e_nonStandardData))
5271     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5272   if (HasOptionalField(e_altGKInfo))
5273     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
5274   if (HasOptionalField(e_tokens))
5275     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5276   if (HasOptionalField(e_cryptoTokens))
5277     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5278   if (HasOptionalField(e_callSignalAddress))
5279     strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
5280   if (HasOptionalField(e_integrityCheckValue))
5281     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5282   if (HasOptionalField(e_serviceControl))
5283     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
5284   if (HasOptionalField(e_featureSet))
5285     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
5286   if (HasOptionalField(e_genericData))
5287     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5288   if (HasOptionalField(e_assignedGatekeeper))
5289     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
5290   strm << setw(indent-1) << setprecision(indent-2) << "}";
5291 }
5292 #endif
5293
5294
5295 PObject::Comparison H225_AdmissionReject::Compare(const PObject & obj) const
5296 {
5297 #ifndef PASN_LEANANDMEAN
5298   PAssert(PIsDescendant(&obj, H225_AdmissionReject), PInvalidCast);
5299 #endif
5300   const H225_AdmissionReject & other = (const H225_AdmissionReject &)obj;
5301
5302   Comparison result;
5303
5304   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5305     return result;
5306   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
5307     return result;
5308   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5309     return result;
5310
5311   return PASN_Sequence::Compare(other);
5312 }
5313
5314
5315 PINDEX H225_AdmissionReject::GetDataLength() const
5316 {
5317   PINDEX length = 0;
5318   length += m_requestSeqNum.GetObjectLength();
5319   length += m_rejectReason.GetObjectLength();
5320   if (HasOptionalField(e_nonStandardData))
5321     length += m_nonStandardData.GetObjectLength();
5322   return length;
5323 }
5324
5325
5326 BOOL H225_AdmissionReject::Decode(PASN_Stream & strm)
5327 {
5328   if (!PreambleDecode(strm))
5329     return FALSE;
5330
5331   if (!m_requestSeqNum.Decode(strm))
5332     return FALSE;
5333   if (!m_rejectReason.Decode(strm))
5334     return FALSE;
5335   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5336     return FALSE;
5337   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
5338     return FALSE;
5339   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5340     return FALSE;
5341   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5342     return FALSE;
5343   if (!KnownExtensionDecode(strm, e_callSignalAddress, m_callSignalAddress))
5344     return FALSE;
5345   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5346     return FALSE;
5347   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
5348     return FALSE;
5349   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
5350     return FALSE;
5351   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5352     return FALSE;
5353   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
5354     return FALSE;
5355
5356   return UnknownExtensionsDecode(strm);
5357 }
5358
5359
5360 void H225_AdmissionReject::Encode(PASN_Stream & strm) const
5361 {
5362   PreambleEncode(strm);
5363
5364   m_requestSeqNum.Encode(strm);
5365   m_rejectReason.Encode(strm);
5366   if (HasOptionalField(e_nonStandardData))
5367     m_nonStandardData.Encode(strm);
5368   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
5369   KnownExtensionEncode(strm, e_tokens, m_tokens);
5370   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5371   KnownExtensionEncode(strm, e_callSignalAddress, m_callSignalAddress);
5372   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5373   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
5374   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
5375   KnownExtensionEncode(strm, e_genericData, m_genericData);
5376   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
5377
5378   UnknownExtensionsEncode(strm);
5379 }
5380
5381
5382 PObject * H225_AdmissionReject::Clone() const
5383 {
5384 #ifndef PASN_LEANANDMEAN
5385   PAssert(IsClass(H225_AdmissionReject::Class()), PInvalidCast);
5386 #endif
5387   return new H225_AdmissionReject(*this);
5388 }
5389
5390
5391 //
5392 // BandwidthReject
5393 //
5394
5395 H225_BandwidthReject::H225_BandwidthReject(unsigned tag, PASN_Object::TagClass tagClass)
5396   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
5397 {
5398 }
5399
5400
5401 #ifndef PASN_NOPRINTON
5402 void H225_BandwidthReject::PrintOn(ostream & strm) const
5403 {
5404   int indent = strm.precision() + 2;
5405   strm << "{\n";
5406   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5407   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
5408   strm << setw(indent+19) << "allowedBandWidth = " << setprecision(indent) << m_allowedBandWidth << '\n';
5409   if (HasOptionalField(e_nonStandardData))
5410     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5411   if (HasOptionalField(e_altGKInfo))
5412     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
5413   if (HasOptionalField(e_tokens))
5414     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5415   if (HasOptionalField(e_cryptoTokens))
5416     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5417   if (HasOptionalField(e_integrityCheckValue))
5418     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5419   if (HasOptionalField(e_genericData))
5420     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5421   strm << setw(indent-1) << setprecision(indent-2) << "}";
5422 }
5423 #endif
5424
5425
5426 PObject::Comparison H225_BandwidthReject::Compare(const PObject & obj) const
5427 {
5428 #ifndef PASN_LEANANDMEAN
5429   PAssert(PIsDescendant(&obj, H225_BandwidthReject), PInvalidCast);
5430 #endif
5431   const H225_BandwidthReject & other = (const H225_BandwidthReject &)obj;
5432
5433   Comparison result;
5434
5435   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5436     return result;
5437   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
5438     return result;
5439   if ((result = m_allowedBandWidth.Compare(other.m_allowedBandWidth)) != EqualTo)
5440     return result;
5441   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5442     return result;
5443
5444   return PASN_Sequence::Compare(other);
5445 }
5446
5447
5448 PINDEX H225_BandwidthReject::GetDataLength() const
5449 {
5450   PINDEX length = 0;
5451   length += m_requestSeqNum.GetObjectLength();
5452   length += m_rejectReason.GetObjectLength();
5453   length += m_allowedBandWidth.GetObjectLength();
5454   if (HasOptionalField(e_nonStandardData))
5455     length += m_nonStandardData.GetObjectLength();
5456   return length;
5457 }
5458
5459
5460 BOOL H225_BandwidthReject::Decode(PASN_Stream & strm)
5461 {
5462   if (!PreambleDecode(strm))
5463     return FALSE;
5464
5465   if (!m_requestSeqNum.Decode(strm))
5466     return FALSE;
5467   if (!m_rejectReason.Decode(strm))
5468     return FALSE;
5469   if (!m_allowedBandWidth.Decode(strm))
5470     return FALSE;
5471   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5472     return FALSE;
5473   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
5474     return FALSE;
5475   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5476     return FALSE;
5477   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5478     return FALSE;
5479   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5480     return FALSE;
5481   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5482     return FALSE;
5483
5484   return UnknownExtensionsDecode(strm);
5485 }
5486
5487
5488 void H225_BandwidthReject::Encode(PASN_Stream & strm) const
5489 {
5490   PreambleEncode(strm);
5491
5492   m_requestSeqNum.Encode(strm);
5493   m_rejectReason.Encode(strm);
5494   m_allowedBandWidth.Encode(strm);
5495   if (HasOptionalField(e_nonStandardData))
5496     m_nonStandardData.Encode(strm);
5497   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
5498   KnownExtensionEncode(strm, e_tokens, m_tokens);
5499   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5500   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5501   KnownExtensionEncode(strm, e_genericData, m_genericData);
5502
5503   UnknownExtensionsEncode(strm);
5504 }
5505
5506
5507 PObject * H225_BandwidthReject::Clone() const
5508 {
5509 #ifndef PASN_LEANANDMEAN
5510   PAssert(IsClass(H225_BandwidthReject::Class()), PInvalidCast);
5511 #endif
5512   return new H225_BandwidthReject(*this);
5513 }
5514
5515
5516 //
5517 // LocationReject
5518 //
5519
5520 H225_LocationReject::H225_LocationReject(unsigned tag, PASN_Object::TagClass tagClass)
5521   : PASN_Sequence(tag, tagClass, 1, TRUE, 7)
5522 {
5523 }
5524
5525
5526 #ifndef PASN_NOPRINTON
5527 void H225_LocationReject::PrintOn(ostream & strm) const
5528 {
5529   int indent = strm.precision() + 2;
5530   strm << "{\n";
5531   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5532   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
5533   if (HasOptionalField(e_nonStandardData))
5534     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5535   if (HasOptionalField(e_altGKInfo))
5536     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
5537   if (HasOptionalField(e_tokens))
5538     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5539   if (HasOptionalField(e_cryptoTokens))
5540     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5541   if (HasOptionalField(e_integrityCheckValue))
5542     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5543   if (HasOptionalField(e_featureSet))
5544     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
5545   if (HasOptionalField(e_genericData))
5546     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5547   if (HasOptionalField(e_serviceControl))
5548     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
5549   strm << setw(indent-1) << setprecision(indent-2) << "}";
5550 }
5551 #endif
5552
5553
5554 PObject::Comparison H225_LocationReject::Compare(const PObject & obj) const
5555 {
5556 #ifndef PASN_LEANANDMEAN
5557   PAssert(PIsDescendant(&obj, H225_LocationReject), PInvalidCast);
5558 #endif
5559   const H225_LocationReject & other = (const H225_LocationReject &)obj;
5560
5561   Comparison result;
5562
5563   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5564     return result;
5565   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
5566     return result;
5567   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5568     return result;
5569
5570   return PASN_Sequence::Compare(other);
5571 }
5572
5573
5574 PINDEX H225_LocationReject::GetDataLength() const
5575 {
5576   PINDEX length = 0;
5577   length += m_requestSeqNum.GetObjectLength();
5578   length += m_rejectReason.GetObjectLength();
5579   if (HasOptionalField(e_nonStandardData))
5580     length += m_nonStandardData.GetObjectLength();
5581   return length;
5582 }
5583
5584
5585 BOOL H225_LocationReject::Decode(PASN_Stream & strm)
5586 {
5587   if (!PreambleDecode(strm))
5588     return FALSE;
5589
5590   if (!m_requestSeqNum.Decode(strm))
5591     return FALSE;
5592   if (!m_rejectReason.Decode(strm))
5593     return FALSE;
5594   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5595     return FALSE;
5596   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
5597     return FALSE;
5598   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5599     return FALSE;
5600   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5601     return FALSE;
5602   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5603     return FALSE;
5604   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
5605     return FALSE;
5606   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5607     return FALSE;
5608   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
5609     return FALSE;
5610
5611   return UnknownExtensionsDecode(strm);
5612 }
5613
5614
5615 void H225_LocationReject::Encode(PASN_Stream & strm) const
5616 {
5617   PreambleEncode(strm);
5618
5619   m_requestSeqNum.Encode(strm);
5620   m_rejectReason.Encode(strm);
5621   if (HasOptionalField(e_nonStandardData))
5622     m_nonStandardData.Encode(strm);
5623   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
5624   KnownExtensionEncode(strm, e_tokens, m_tokens);
5625   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5626   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5627   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
5628   KnownExtensionEncode(strm, e_genericData, m_genericData);
5629   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
5630
5631   UnknownExtensionsEncode(strm);
5632 }
5633
5634
5635 PObject * H225_LocationReject::Clone() const
5636 {
5637 #ifndef PASN_LEANANDMEAN
5638   PAssert(IsClass(H225_LocationReject::Class()), PInvalidCast);
5639 #endif
5640   return new H225_LocationReject(*this);
5641 }
5642
5643
5644 //
5645 // DisengageReject
5646 //
5647
5648 H225_DisengageReject::H225_DisengageReject(unsigned tag, PASN_Object::TagClass tagClass)
5649   : PASN_Sequence(tag, tagClass, 1, TRUE, 5)
5650 {
5651 }
5652
5653
5654 #ifndef PASN_NOPRINTON
5655 void H225_DisengageReject::PrintOn(ostream & strm) const
5656 {
5657   int indent = strm.precision() + 2;
5658   strm << "{\n";
5659   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5660   strm << setw(indent+15) << "rejectReason = " << setprecision(indent) << m_rejectReason << '\n';
5661   if (HasOptionalField(e_nonStandardData))
5662     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5663   if (HasOptionalField(e_altGKInfo))
5664     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
5665   if (HasOptionalField(e_tokens))
5666     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5667   if (HasOptionalField(e_cryptoTokens))
5668     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5669   if (HasOptionalField(e_integrityCheckValue))
5670     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5671   if (HasOptionalField(e_genericData))
5672     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5673   strm << setw(indent-1) << setprecision(indent-2) << "}";
5674 }
5675 #endif
5676
5677
5678 PObject::Comparison H225_DisengageReject::Compare(const PObject & obj) const
5679 {
5680 #ifndef PASN_LEANANDMEAN
5681   PAssert(PIsDescendant(&obj, H225_DisengageReject), PInvalidCast);
5682 #endif
5683   const H225_DisengageReject & other = (const H225_DisengageReject &)obj;
5684
5685   Comparison result;
5686
5687   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5688     return result;
5689   if ((result = m_rejectReason.Compare(other.m_rejectReason)) != EqualTo)
5690     return result;
5691   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5692     return result;
5693
5694   return PASN_Sequence::Compare(other);
5695 }
5696
5697
5698 PINDEX H225_DisengageReject::GetDataLength() const
5699 {
5700   PINDEX length = 0;
5701   length += m_requestSeqNum.GetObjectLength();
5702   length += m_rejectReason.GetObjectLength();
5703   if (HasOptionalField(e_nonStandardData))
5704     length += m_nonStandardData.GetObjectLength();
5705   return length;
5706 }
5707
5708
5709 BOOL H225_DisengageReject::Decode(PASN_Stream & strm)
5710 {
5711   if (!PreambleDecode(strm))
5712     return FALSE;
5713
5714   if (!m_requestSeqNum.Decode(strm))
5715     return FALSE;
5716   if (!m_rejectReason.Decode(strm))
5717     return FALSE;
5718   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5719     return FALSE;
5720   if (!KnownExtensionDecode(strm, e_altGKInfo, m_altGKInfo))
5721     return FALSE;
5722   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5723     return FALSE;
5724   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5725     return FALSE;
5726   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5727     return FALSE;
5728   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5729     return FALSE;
5730
5731   return UnknownExtensionsDecode(strm);
5732 }
5733
5734
5735 void H225_DisengageReject::Encode(PASN_Stream & strm) const
5736 {
5737   PreambleEncode(strm);
5738
5739   m_requestSeqNum.Encode(strm);
5740   m_rejectReason.Encode(strm);
5741   if (HasOptionalField(e_nonStandardData))
5742     m_nonStandardData.Encode(strm);
5743   KnownExtensionEncode(strm, e_altGKInfo, m_altGKInfo);
5744   KnownExtensionEncode(strm, e_tokens, m_tokens);
5745   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5746   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5747   KnownExtensionEncode(strm, e_genericData, m_genericData);
5748
5749   UnknownExtensionsEncode(strm);
5750 }
5751
5752
5753 PObject * H225_DisengageReject::Clone() const
5754 {
5755 #ifndef PASN_LEANANDMEAN
5756   PAssert(IsClass(H225_DisengageReject::Class()), PInvalidCast);
5757 #endif
5758   return new H225_DisengageReject(*this);
5759 }
5760
5761
5762 //
5763 // InfoRequest
5764 //
5765
5766 H225_InfoRequest::H225_InfoRequest(unsigned tag, PASN_Object::TagClass tagClass)
5767   : PASN_Sequence(tag, tagClass, 2, TRUE, 12)
5768 {
5769   IncludeOptionalField(e_callIdentifier);
5770   m_nextSegmentRequested.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
5771 }
5772
5773
5774 #ifndef PASN_NOPRINTON
5775 void H225_InfoRequest::PrintOn(ostream & strm) const
5776 {
5777   int indent = strm.precision() + 2;
5778   strm << "{\n";
5779   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5780   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
5781   if (HasOptionalField(e_nonStandardData))
5782     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5783   if (HasOptionalField(e_replyAddress))
5784     strm << setw(indent+15) << "replyAddress = " << setprecision(indent) << m_replyAddress << '\n';
5785   if (HasOptionalField(e_callIdentifier))
5786     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
5787   if (HasOptionalField(e_tokens))
5788     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5789   if (HasOptionalField(e_cryptoTokens))
5790     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5791   if (HasOptionalField(e_integrityCheckValue))
5792     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5793   if (HasOptionalField(e_uuiesRequested))
5794     strm << setw(indent+17) << "uuiesRequested = " << setprecision(indent) << m_uuiesRequested << '\n';
5795   if (HasOptionalField(e_callLinkage))
5796     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
5797   if (HasOptionalField(e_usageInfoRequested))
5798     strm << setw(indent+21) << "usageInfoRequested = " << setprecision(indent) << m_usageInfoRequested << '\n';
5799   if (HasOptionalField(e_segmentedResponseSupported))
5800     strm << setw(indent+29) << "segmentedResponseSupported = " << setprecision(indent) << m_segmentedResponseSupported << '\n';
5801   if (HasOptionalField(e_nextSegmentRequested))
5802     strm << setw(indent+23) << "nextSegmentRequested = " << setprecision(indent) << m_nextSegmentRequested << '\n';
5803   if (HasOptionalField(e_capacityInfoRequested))
5804     strm << setw(indent+24) << "capacityInfoRequested = " << setprecision(indent) << m_capacityInfoRequested << '\n';
5805   if (HasOptionalField(e_genericData))
5806     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
5807   if (HasOptionalField(e_assignedGatekeeper))
5808     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
5809   strm << setw(indent-1) << setprecision(indent-2) << "}";
5810 }
5811 #endif
5812
5813
5814 PObject::Comparison H225_InfoRequest::Compare(const PObject & obj) const
5815 {
5816 #ifndef PASN_LEANANDMEAN
5817   PAssert(PIsDescendant(&obj, H225_InfoRequest), PInvalidCast);
5818 #endif
5819   const H225_InfoRequest & other = (const H225_InfoRequest &)obj;
5820
5821   Comparison result;
5822
5823   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5824     return result;
5825   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
5826     return result;
5827   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5828     return result;
5829   if ((result = m_replyAddress.Compare(other.m_replyAddress)) != EqualTo)
5830     return result;
5831
5832   return PASN_Sequence::Compare(other);
5833 }
5834
5835
5836 PINDEX H225_InfoRequest::GetDataLength() const
5837 {
5838   PINDEX length = 0;
5839   length += m_requestSeqNum.GetObjectLength();
5840   length += m_callReferenceValue.GetObjectLength();
5841   if (HasOptionalField(e_nonStandardData))
5842     length += m_nonStandardData.GetObjectLength();
5843   if (HasOptionalField(e_replyAddress))
5844     length += m_replyAddress.GetObjectLength();
5845   return length;
5846 }
5847
5848
5849 BOOL H225_InfoRequest::Decode(PASN_Stream & strm)
5850 {
5851   if (!PreambleDecode(strm))
5852     return FALSE;
5853
5854   if (!m_requestSeqNum.Decode(strm))
5855     return FALSE;
5856   if (!m_callReferenceValue.Decode(strm))
5857     return FALSE;
5858   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
5859     return FALSE;
5860   if (HasOptionalField(e_replyAddress) && !m_replyAddress.Decode(strm))
5861     return FALSE;
5862   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
5863     return FALSE;
5864   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
5865     return FALSE;
5866   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
5867     return FALSE;
5868   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
5869     return FALSE;
5870   if (!KnownExtensionDecode(strm, e_uuiesRequested, m_uuiesRequested))
5871     return FALSE;
5872   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
5873     return FALSE;
5874   if (!KnownExtensionDecode(strm, e_usageInfoRequested, m_usageInfoRequested))
5875     return FALSE;
5876   if (!KnownExtensionDecode(strm, e_segmentedResponseSupported, m_segmentedResponseSupported))
5877     return FALSE;
5878   if (!KnownExtensionDecode(strm, e_nextSegmentRequested, m_nextSegmentRequested))
5879     return FALSE;
5880   if (!KnownExtensionDecode(strm, e_capacityInfoRequested, m_capacityInfoRequested))
5881     return FALSE;
5882   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
5883     return FALSE;
5884   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
5885     return FALSE;
5886
5887   return UnknownExtensionsDecode(strm);
5888 }
5889
5890
5891 void H225_InfoRequest::Encode(PASN_Stream & strm) const
5892 {
5893   PreambleEncode(strm);
5894
5895   m_requestSeqNum.Encode(strm);
5896   m_callReferenceValue.Encode(strm);
5897   if (HasOptionalField(e_nonStandardData))
5898     m_nonStandardData.Encode(strm);
5899   if (HasOptionalField(e_replyAddress))
5900     m_replyAddress.Encode(strm);
5901   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
5902   KnownExtensionEncode(strm, e_tokens, m_tokens);
5903   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
5904   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
5905   KnownExtensionEncode(strm, e_uuiesRequested, m_uuiesRequested);
5906   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
5907   KnownExtensionEncode(strm, e_usageInfoRequested, m_usageInfoRequested);
5908   KnownExtensionEncode(strm, e_segmentedResponseSupported, m_segmentedResponseSupported);
5909   KnownExtensionEncode(strm, e_nextSegmentRequested, m_nextSegmentRequested);
5910   KnownExtensionEncode(strm, e_capacityInfoRequested, m_capacityInfoRequested);
5911   KnownExtensionEncode(strm, e_genericData, m_genericData);
5912   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
5913
5914   UnknownExtensionsEncode(strm);
5915 }
5916
5917
5918 PObject * H225_InfoRequest::Clone() const
5919 {
5920 #ifndef PASN_LEANANDMEAN
5921   PAssert(IsClass(H225_InfoRequest::Class()), PInvalidCast);
5922 #endif
5923   return new H225_InfoRequest(*this);
5924 }
5925
5926
5927 //
5928 // InfoRequestAck
5929 //
5930
5931 H225_InfoRequestAck::H225_InfoRequestAck(unsigned tag, PASN_Object::TagClass tagClass)
5932   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
5933 {
5934 }
5935
5936
5937 #ifndef PASN_NOPRINTON
5938 void H225_InfoRequestAck::PrintOn(ostream & strm) const
5939 {
5940   int indent = strm.precision() + 2;
5941   strm << "{\n";
5942   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
5943   if (HasOptionalField(e_nonStandardData))
5944     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
5945   if (HasOptionalField(e_tokens))
5946     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
5947   if (HasOptionalField(e_cryptoTokens))
5948     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
5949   if (HasOptionalField(e_integrityCheckValue))
5950     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
5951   strm << setw(indent-1) << setprecision(indent-2) << "}";
5952 }
5953 #endif
5954
5955
5956 PObject::Comparison H225_InfoRequestAck::Compare(const PObject & obj) const
5957 {
5958 #ifndef PASN_LEANANDMEAN
5959   PAssert(PIsDescendant(&obj, H225_InfoRequestAck), PInvalidCast);
5960 #endif
5961   const H225_InfoRequestAck & other = (const H225_InfoRequestAck &)obj;
5962
5963   Comparison result;
5964
5965   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
5966     return result;
5967   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
5968     return result;
5969   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
5970     return result;
5971   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
5972     return result;
5973   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
5974     return result;
5975
5976   return PASN_Sequence::Compare(other);
5977 }
5978
5979
5980 PINDEX H225_InfoRequestAck::GetDataLength() const
5981 {
5982   PINDEX length = 0;
5983   length += m_requestSeqNum.GetObjectLength();
5984   if (HasOptionalField(e_nonStandardData))
5985     length += m_nonStandardData.GetObjectLength();
5986   if (HasOptionalField(e_tokens))
5987     length += m_tokens.GetObjectLength();
5988   if (HasOptionalField(e_cryptoTokens))
5989     length += m_cryptoTokens.GetObjectLength();
5990   if (HasOptionalField(e_integrityCheckValue))
5991     length += m_integrityCheckValue.GetObjectLength();
5992   return length;
5993 }
5994
5995
5996 BOOL H225_InfoRequestAck::Decode(PASN_Stream & strm)
5997 {
5998   if (!PreambleDecode(strm))
5999     return FALSE;
6000
6001   if (!m_requestSeqNum.Decode(strm))
6002     return FALSE;
6003   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6004     return FALSE;
6005   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6006     return FALSE;
6007   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6008     return FALSE;
6009   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6010     return FALSE;
6011
6012   return UnknownExtensionsDecode(strm);
6013 }
6014
6015
6016 void H225_InfoRequestAck::Encode(PASN_Stream & strm) const
6017 {
6018   PreambleEncode(strm);
6019
6020   m_requestSeqNum.Encode(strm);
6021   if (HasOptionalField(e_nonStandardData))
6022     m_nonStandardData.Encode(strm);
6023   if (HasOptionalField(e_tokens))
6024     m_tokens.Encode(strm);
6025   if (HasOptionalField(e_cryptoTokens))
6026     m_cryptoTokens.Encode(strm);
6027   if (HasOptionalField(e_integrityCheckValue))
6028     m_integrityCheckValue.Encode(strm);
6029
6030   UnknownExtensionsEncode(strm);
6031 }
6032
6033
6034 PObject * H225_InfoRequestAck::Clone() const
6035 {
6036 #ifndef PASN_LEANANDMEAN
6037   PAssert(IsClass(H225_InfoRequestAck::Class()), PInvalidCast);
6038 #endif
6039   return new H225_InfoRequestAck(*this);
6040 }
6041
6042
6043 //
6044 // InfoRequestNak
6045 //
6046
6047 H225_InfoRequestNak::H225_InfoRequestNak(unsigned tag, PASN_Object::TagClass tagClass)
6048   : PASN_Sequence(tag, tagClass, 5, TRUE, 0)
6049 {
6050 }
6051
6052
6053 #ifndef PASN_NOPRINTON
6054 void H225_InfoRequestNak::PrintOn(ostream & strm) const
6055 {
6056   int indent = strm.precision() + 2;
6057   strm << "{\n";
6058   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6059   if (HasOptionalField(e_nonStandardData))
6060     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6061   strm << setw(indent+12) << "nakReason = " << setprecision(indent) << m_nakReason << '\n';
6062   if (HasOptionalField(e_altGKInfo))
6063     strm << setw(indent+12) << "altGKInfo = " << setprecision(indent) << m_altGKInfo << '\n';
6064   if (HasOptionalField(e_tokens))
6065     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6066   if (HasOptionalField(e_cryptoTokens))
6067     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6068   if (HasOptionalField(e_integrityCheckValue))
6069     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6070   strm << setw(indent-1) << setprecision(indent-2) << "}";
6071 }
6072 #endif
6073
6074
6075 PObject::Comparison H225_InfoRequestNak::Compare(const PObject & obj) const
6076 {
6077 #ifndef PASN_LEANANDMEAN
6078   PAssert(PIsDescendant(&obj, H225_InfoRequestNak), PInvalidCast);
6079 #endif
6080   const H225_InfoRequestNak & other = (const H225_InfoRequestNak &)obj;
6081
6082   Comparison result;
6083
6084   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6085     return result;
6086   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6087     return result;
6088   if ((result = m_nakReason.Compare(other.m_nakReason)) != EqualTo)
6089     return result;
6090   if ((result = m_altGKInfo.Compare(other.m_altGKInfo)) != EqualTo)
6091     return result;
6092   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
6093     return result;
6094   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
6095     return result;
6096   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
6097     return result;
6098
6099   return PASN_Sequence::Compare(other);
6100 }
6101
6102
6103 PINDEX H225_InfoRequestNak::GetDataLength() const
6104 {
6105   PINDEX length = 0;
6106   length += m_requestSeqNum.GetObjectLength();
6107   if (HasOptionalField(e_nonStandardData))
6108     length += m_nonStandardData.GetObjectLength();
6109   length += m_nakReason.GetObjectLength();
6110   if (HasOptionalField(e_altGKInfo))
6111     length += m_altGKInfo.GetObjectLength();
6112   if (HasOptionalField(e_tokens))
6113     length += m_tokens.GetObjectLength();
6114   if (HasOptionalField(e_cryptoTokens))
6115     length += m_cryptoTokens.GetObjectLength();
6116   if (HasOptionalField(e_integrityCheckValue))
6117     length += m_integrityCheckValue.GetObjectLength();
6118   return length;
6119 }
6120
6121
6122 BOOL H225_InfoRequestNak::Decode(PASN_Stream & strm)
6123 {
6124   if (!PreambleDecode(strm))
6125     return FALSE;
6126
6127   if (!m_requestSeqNum.Decode(strm))
6128     return FALSE;
6129   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6130     return FALSE;
6131   if (!m_nakReason.Decode(strm))
6132     return FALSE;
6133   if (HasOptionalField(e_altGKInfo) && !m_altGKInfo.Decode(strm))
6134     return FALSE;
6135   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6136     return FALSE;
6137   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6138     return FALSE;
6139   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6140     return FALSE;
6141
6142   return UnknownExtensionsDecode(strm);
6143 }
6144
6145
6146 void H225_InfoRequestNak::Encode(PASN_Stream & strm) const
6147 {
6148   PreambleEncode(strm);
6149
6150   m_requestSeqNum.Encode(strm);
6151   if (HasOptionalField(e_nonStandardData))
6152     m_nonStandardData.Encode(strm);
6153   m_nakReason.Encode(strm);
6154   if (HasOptionalField(e_altGKInfo))
6155     m_altGKInfo.Encode(strm);
6156   if (HasOptionalField(e_tokens))
6157     m_tokens.Encode(strm);
6158   if (HasOptionalField(e_cryptoTokens))
6159     m_cryptoTokens.Encode(strm);
6160   if (HasOptionalField(e_integrityCheckValue))
6161     m_integrityCheckValue.Encode(strm);
6162
6163   UnknownExtensionsEncode(strm);
6164 }
6165
6166
6167 PObject * H225_InfoRequestNak::Clone() const
6168 {
6169 #ifndef PASN_LEANANDMEAN
6170   PAssert(IsClass(H225_InfoRequestNak::Class()), PInvalidCast);
6171 #endif
6172   return new H225_InfoRequestNak(*this);
6173 }
6174
6175
6176 //
6177 // NonStandardMessage
6178 //
6179
6180 H225_NonStandardMessage::H225_NonStandardMessage(unsigned tag, PASN_Object::TagClass tagClass)
6181   : PASN_Sequence(tag, tagClass, 0, TRUE, 5)
6182 {
6183 }
6184
6185
6186 #ifndef PASN_NOPRINTON
6187 void H225_NonStandardMessage::PrintOn(ostream & strm) const
6188 {
6189   int indent = strm.precision() + 2;
6190   strm << "{\n";
6191   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6192   strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6193   if (HasOptionalField(e_tokens))
6194     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6195   if (HasOptionalField(e_cryptoTokens))
6196     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6197   if (HasOptionalField(e_integrityCheckValue))
6198     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6199   if (HasOptionalField(e_featureSet))
6200     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
6201   if (HasOptionalField(e_genericData))
6202     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
6203   strm << setw(indent-1) << setprecision(indent-2) << "}";
6204 }
6205 #endif
6206
6207
6208 PObject::Comparison H225_NonStandardMessage::Compare(const PObject & obj) const
6209 {
6210 #ifndef PASN_LEANANDMEAN
6211   PAssert(PIsDescendant(&obj, H225_NonStandardMessage), PInvalidCast);
6212 #endif
6213   const H225_NonStandardMessage & other = (const H225_NonStandardMessage &)obj;
6214
6215   Comparison result;
6216
6217   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6218     return result;
6219   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6220     return result;
6221
6222   return PASN_Sequence::Compare(other);
6223 }
6224
6225
6226 PINDEX H225_NonStandardMessage::GetDataLength() const
6227 {
6228   PINDEX length = 0;
6229   length += m_requestSeqNum.GetObjectLength();
6230   length += m_nonStandardData.GetObjectLength();
6231   return length;
6232 }
6233
6234
6235 BOOL H225_NonStandardMessage::Decode(PASN_Stream & strm)
6236 {
6237   if (!PreambleDecode(strm))
6238     return FALSE;
6239
6240   if (!m_requestSeqNum.Decode(strm))
6241     return FALSE;
6242   if (!m_nonStandardData.Decode(strm))
6243     return FALSE;
6244   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
6245     return FALSE;
6246   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
6247     return FALSE;
6248   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
6249     return FALSE;
6250   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
6251     return FALSE;
6252   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
6253     return FALSE;
6254
6255   return UnknownExtensionsDecode(strm);
6256 }
6257
6258
6259 void H225_NonStandardMessage::Encode(PASN_Stream & strm) const
6260 {
6261   PreambleEncode(strm);
6262
6263   m_requestSeqNum.Encode(strm);
6264   m_nonStandardData.Encode(strm);
6265   KnownExtensionEncode(strm, e_tokens, m_tokens);
6266   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
6267   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
6268   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
6269   KnownExtensionEncode(strm, e_genericData, m_genericData);
6270
6271   UnknownExtensionsEncode(strm);
6272 }
6273
6274
6275 PObject * H225_NonStandardMessage::Clone() const
6276 {
6277 #ifndef PASN_LEANANDMEAN
6278   PAssert(IsClass(H225_NonStandardMessage::Class()), PInvalidCast);
6279 #endif
6280   return new H225_NonStandardMessage(*this);
6281 }
6282
6283
6284 //
6285 // UnknownMessageResponse
6286 //
6287
6288 H225_UnknownMessageResponse::H225_UnknownMessageResponse(unsigned tag, PASN_Object::TagClass tagClass)
6289   : PASN_Sequence(tag, tagClass, 0, TRUE, 4)
6290 {
6291   IncludeOptionalField(e_messageNotUnderstood);
6292 }
6293
6294
6295 #ifndef PASN_NOPRINTON
6296 void H225_UnknownMessageResponse::PrintOn(ostream & strm) const
6297 {
6298   int indent = strm.precision() + 2;
6299   strm << "{\n";
6300   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6301   if (HasOptionalField(e_tokens))
6302     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6303   if (HasOptionalField(e_cryptoTokens))
6304     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6305   if (HasOptionalField(e_integrityCheckValue))
6306     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6307   if (HasOptionalField(e_messageNotUnderstood))
6308     strm << setw(indent+23) << "messageNotUnderstood = " << setprecision(indent) << m_messageNotUnderstood << '\n';
6309   strm << setw(indent-1) << setprecision(indent-2) << "}";
6310 }
6311 #endif
6312
6313
6314 PObject::Comparison H225_UnknownMessageResponse::Compare(const PObject & obj) const
6315 {
6316 #ifndef PASN_LEANANDMEAN
6317   PAssert(PIsDescendant(&obj, H225_UnknownMessageResponse), PInvalidCast);
6318 #endif
6319   const H225_UnknownMessageResponse & other = (const H225_UnknownMessageResponse &)obj;
6320
6321   Comparison result;
6322
6323   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6324     return result;
6325
6326   return PASN_Sequence::Compare(other);
6327 }
6328
6329
6330 PINDEX H225_UnknownMessageResponse::GetDataLength() const
6331 {
6332   PINDEX length = 0;
6333   length += m_requestSeqNum.GetObjectLength();
6334   return length;
6335 }
6336
6337
6338 BOOL H225_UnknownMessageResponse::Decode(PASN_Stream & strm)
6339 {
6340   if (!PreambleDecode(strm))
6341     return FALSE;
6342
6343   if (!m_requestSeqNum.Decode(strm))
6344     return FALSE;
6345   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
6346     return FALSE;
6347   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
6348     return FALSE;
6349   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
6350     return FALSE;
6351   if (!KnownExtensionDecode(strm, e_messageNotUnderstood, m_messageNotUnderstood))
6352     return FALSE;
6353
6354   return UnknownExtensionsDecode(strm);
6355 }
6356
6357
6358 void H225_UnknownMessageResponse::Encode(PASN_Stream & strm) const
6359 {
6360   PreambleEncode(strm);
6361
6362   m_requestSeqNum.Encode(strm);
6363   KnownExtensionEncode(strm, e_tokens, m_tokens);
6364   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
6365   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
6366   KnownExtensionEncode(strm, e_messageNotUnderstood, m_messageNotUnderstood);
6367
6368   UnknownExtensionsEncode(strm);
6369 }
6370
6371
6372 PObject * H225_UnknownMessageResponse::Clone() const
6373 {
6374 #ifndef PASN_LEANANDMEAN
6375   PAssert(IsClass(H225_UnknownMessageResponse::Class()), PInvalidCast);
6376 #endif
6377   return new H225_UnknownMessageResponse(*this);
6378 }
6379
6380
6381 //
6382 // RequestInProgress
6383 //
6384
6385 H225_RequestInProgress::H225_RequestInProgress(unsigned tag, PASN_Object::TagClass tagClass)
6386   : PASN_Sequence(tag, tagClass, 4, TRUE, 0)
6387 {
6388   m_delay.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
6389 }
6390
6391
6392 #ifndef PASN_NOPRINTON
6393 void H225_RequestInProgress::PrintOn(ostream & strm) const
6394 {
6395   int indent = strm.precision() + 2;
6396   strm << "{\n";
6397   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6398   if (HasOptionalField(e_nonStandardData))
6399     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6400   if (HasOptionalField(e_tokens))
6401     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6402   if (HasOptionalField(e_cryptoTokens))
6403     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6404   if (HasOptionalField(e_integrityCheckValue))
6405     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6406   strm << setw(indent+8) << "delay = " << setprecision(indent) << m_delay << '\n';
6407   strm << setw(indent-1) << setprecision(indent-2) << "}";
6408 }
6409 #endif
6410
6411
6412 PObject::Comparison H225_RequestInProgress::Compare(const PObject & obj) const
6413 {
6414 #ifndef PASN_LEANANDMEAN
6415   PAssert(PIsDescendant(&obj, H225_RequestInProgress), PInvalidCast);
6416 #endif
6417   const H225_RequestInProgress & other = (const H225_RequestInProgress &)obj;
6418
6419   Comparison result;
6420
6421   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6422     return result;
6423   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6424     return result;
6425   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
6426     return result;
6427   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
6428     return result;
6429   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
6430     return result;
6431   if ((result = m_delay.Compare(other.m_delay)) != EqualTo)
6432     return result;
6433
6434   return PASN_Sequence::Compare(other);
6435 }
6436
6437
6438 PINDEX H225_RequestInProgress::GetDataLength() const
6439 {
6440   PINDEX length = 0;
6441   length += m_requestSeqNum.GetObjectLength();
6442   if (HasOptionalField(e_nonStandardData))
6443     length += m_nonStandardData.GetObjectLength();
6444   if (HasOptionalField(e_tokens))
6445     length += m_tokens.GetObjectLength();
6446   if (HasOptionalField(e_cryptoTokens))
6447     length += m_cryptoTokens.GetObjectLength();
6448   if (HasOptionalField(e_integrityCheckValue))
6449     length += m_integrityCheckValue.GetObjectLength();
6450   length += m_delay.GetObjectLength();
6451   return length;
6452 }
6453
6454
6455 BOOL H225_RequestInProgress::Decode(PASN_Stream & strm)
6456 {
6457   if (!PreambleDecode(strm))
6458     return FALSE;
6459
6460   if (!m_requestSeqNum.Decode(strm))
6461     return FALSE;
6462   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6463     return FALSE;
6464   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6465     return FALSE;
6466   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6467     return FALSE;
6468   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6469     return FALSE;
6470   if (!m_delay.Decode(strm))
6471     return FALSE;
6472
6473   return UnknownExtensionsDecode(strm);
6474 }
6475
6476
6477 void H225_RequestInProgress::Encode(PASN_Stream & strm) const
6478 {
6479   PreambleEncode(strm);
6480
6481   m_requestSeqNum.Encode(strm);
6482   if (HasOptionalField(e_nonStandardData))
6483     m_nonStandardData.Encode(strm);
6484   if (HasOptionalField(e_tokens))
6485     m_tokens.Encode(strm);
6486   if (HasOptionalField(e_cryptoTokens))
6487     m_cryptoTokens.Encode(strm);
6488   if (HasOptionalField(e_integrityCheckValue))
6489     m_integrityCheckValue.Encode(strm);
6490   m_delay.Encode(strm);
6491
6492   UnknownExtensionsEncode(strm);
6493 }
6494
6495
6496 PObject * H225_RequestInProgress::Clone() const
6497 {
6498 #ifndef PASN_LEANANDMEAN
6499   PAssert(IsClass(H225_RequestInProgress::Class()), PInvalidCast);
6500 #endif
6501   return new H225_RequestInProgress(*this);
6502 }
6503
6504
6505 //
6506 // ResourcesAvailableConfirm
6507 //
6508
6509 H225_ResourcesAvailableConfirm::H225_ResourcesAvailableConfirm(unsigned tag, PASN_Object::TagClass tagClass)
6510   : PASN_Sequence(tag, tagClass, 4, TRUE, 1)
6511 {
6512 }
6513
6514
6515 #ifndef PASN_NOPRINTON
6516 void H225_ResourcesAvailableConfirm::PrintOn(ostream & strm) const
6517 {
6518   int indent = strm.precision() + 2;
6519   strm << "{\n";
6520   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6521   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
6522   if (HasOptionalField(e_nonStandardData))
6523     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6524   if (HasOptionalField(e_tokens))
6525     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6526   if (HasOptionalField(e_cryptoTokens))
6527     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6528   if (HasOptionalField(e_integrityCheckValue))
6529     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6530   if (HasOptionalField(e_genericData))
6531     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
6532   strm << setw(indent-1) << setprecision(indent-2) << "}";
6533 }
6534 #endif
6535
6536
6537 PObject::Comparison H225_ResourcesAvailableConfirm::Compare(const PObject & obj) const
6538 {
6539 #ifndef PASN_LEANANDMEAN
6540   PAssert(PIsDescendant(&obj, H225_ResourcesAvailableConfirm), PInvalidCast);
6541 #endif
6542   const H225_ResourcesAvailableConfirm & other = (const H225_ResourcesAvailableConfirm &)obj;
6543
6544   Comparison result;
6545
6546   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6547     return result;
6548   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
6549     return result;
6550   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6551     return result;
6552   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
6553     return result;
6554   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
6555     return result;
6556   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
6557     return result;
6558
6559   return PASN_Sequence::Compare(other);
6560 }
6561
6562
6563 PINDEX H225_ResourcesAvailableConfirm::GetDataLength() const
6564 {
6565   PINDEX length = 0;
6566   length += m_requestSeqNum.GetObjectLength();
6567   length += m_protocolIdentifier.GetObjectLength();
6568   if (HasOptionalField(e_nonStandardData))
6569     length += m_nonStandardData.GetObjectLength();
6570   if (HasOptionalField(e_tokens))
6571     length += m_tokens.GetObjectLength();
6572   if (HasOptionalField(e_cryptoTokens))
6573     length += m_cryptoTokens.GetObjectLength();
6574   if (HasOptionalField(e_integrityCheckValue))
6575     length += m_integrityCheckValue.GetObjectLength();
6576   return length;
6577 }
6578
6579
6580 BOOL H225_ResourcesAvailableConfirm::Decode(PASN_Stream & strm)
6581 {
6582   if (!PreambleDecode(strm))
6583     return FALSE;
6584
6585   if (!m_requestSeqNum.Decode(strm))
6586     return FALSE;
6587   if (!m_protocolIdentifier.Decode(strm))
6588     return FALSE;
6589   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6590     return FALSE;
6591   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6592     return FALSE;
6593   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6594     return FALSE;
6595   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6596     return FALSE;
6597   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
6598     return FALSE;
6599
6600   return UnknownExtensionsDecode(strm);
6601 }
6602
6603
6604 void H225_ResourcesAvailableConfirm::Encode(PASN_Stream & strm) const
6605 {
6606   PreambleEncode(strm);
6607
6608   m_requestSeqNum.Encode(strm);
6609   m_protocolIdentifier.Encode(strm);
6610   if (HasOptionalField(e_nonStandardData))
6611     m_nonStandardData.Encode(strm);
6612   if (HasOptionalField(e_tokens))
6613     m_tokens.Encode(strm);
6614   if (HasOptionalField(e_cryptoTokens))
6615     m_cryptoTokens.Encode(strm);
6616   if (HasOptionalField(e_integrityCheckValue))
6617     m_integrityCheckValue.Encode(strm);
6618   KnownExtensionEncode(strm, e_genericData, m_genericData);
6619
6620   UnknownExtensionsEncode(strm);
6621 }
6622
6623
6624 PObject * H225_ResourcesAvailableConfirm::Clone() const
6625 {
6626 #ifndef PASN_LEANANDMEAN
6627   PAssert(IsClass(H225_ResourcesAvailableConfirm::Class()), PInvalidCast);
6628 #endif
6629   return new H225_ResourcesAvailableConfirm(*this);
6630 }
6631
6632
6633 //
6634 // ServiceControlIndication
6635 //
6636
6637 H225_ServiceControlIndication::H225_ServiceControlIndication(unsigned tag, PASN_Object::TagClass tagClass)
6638   : PASN_Sequence(tag, tagClass, 8, TRUE, 0)
6639 {
6640 }
6641
6642
6643 #ifndef PASN_NOPRINTON
6644 void H225_ServiceControlIndication::PrintOn(ostream & strm) const
6645 {
6646   int indent = strm.precision() + 2;
6647   strm << "{\n";
6648   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6649   if (HasOptionalField(e_nonStandardData))
6650     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6651   strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
6652   if (HasOptionalField(e_endpointIdentifier))
6653     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
6654   if (HasOptionalField(e_callSpecific))
6655     strm << setw(indent+15) << "callSpecific = " << setprecision(indent) << m_callSpecific << '\n';
6656   if (HasOptionalField(e_tokens))
6657     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6658   if (HasOptionalField(e_cryptoTokens))
6659     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6660   if (HasOptionalField(e_integrityCheckValue))
6661     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6662   if (HasOptionalField(e_featureSet))
6663     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
6664   if (HasOptionalField(e_genericData))
6665     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
6666   strm << setw(indent-1) << setprecision(indent-2) << "}";
6667 }
6668 #endif
6669
6670
6671 PObject::Comparison H225_ServiceControlIndication::Compare(const PObject & obj) const
6672 {
6673 #ifndef PASN_LEANANDMEAN
6674   PAssert(PIsDescendant(&obj, H225_ServiceControlIndication), PInvalidCast);
6675 #endif
6676   const H225_ServiceControlIndication & other = (const H225_ServiceControlIndication &)obj;
6677
6678   Comparison result;
6679
6680   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6681     return result;
6682   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6683     return result;
6684   if ((result = m_serviceControl.Compare(other.m_serviceControl)) != EqualTo)
6685     return result;
6686   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
6687     return result;
6688   if ((result = m_callSpecific.Compare(other.m_callSpecific)) != EqualTo)
6689     return result;
6690   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
6691     return result;
6692   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
6693     return result;
6694   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
6695     return result;
6696   if ((result = m_featureSet.Compare(other.m_featureSet)) != EqualTo)
6697     return result;
6698   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
6699     return result;
6700
6701   return PASN_Sequence::Compare(other);
6702 }
6703
6704
6705 PINDEX H225_ServiceControlIndication::GetDataLength() const
6706 {
6707   PINDEX length = 0;
6708   length += m_requestSeqNum.GetObjectLength();
6709   if (HasOptionalField(e_nonStandardData))
6710     length += m_nonStandardData.GetObjectLength();
6711   length += m_serviceControl.GetObjectLength();
6712   if (HasOptionalField(e_endpointIdentifier))
6713     length += m_endpointIdentifier.GetObjectLength();
6714   if (HasOptionalField(e_callSpecific))
6715     length += m_callSpecific.GetObjectLength();
6716   if (HasOptionalField(e_tokens))
6717     length += m_tokens.GetObjectLength();
6718   if (HasOptionalField(e_cryptoTokens))
6719     length += m_cryptoTokens.GetObjectLength();
6720   if (HasOptionalField(e_integrityCheckValue))
6721     length += m_integrityCheckValue.GetObjectLength();
6722   if (HasOptionalField(e_featureSet))
6723     length += m_featureSet.GetObjectLength();
6724   if (HasOptionalField(e_genericData))
6725     length += m_genericData.GetObjectLength();
6726   return length;
6727 }
6728
6729
6730 BOOL H225_ServiceControlIndication::Decode(PASN_Stream & strm)
6731 {
6732   if (!PreambleDecode(strm))
6733     return FALSE;
6734
6735   if (!m_requestSeqNum.Decode(strm))
6736     return FALSE;
6737   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6738     return FALSE;
6739   if (!m_serviceControl.Decode(strm))
6740     return FALSE;
6741   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
6742     return FALSE;
6743   if (HasOptionalField(e_callSpecific) && !m_callSpecific.Decode(strm))
6744     return FALSE;
6745   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6746     return FALSE;
6747   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6748     return FALSE;
6749   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6750     return FALSE;
6751   if (HasOptionalField(e_featureSet) && !m_featureSet.Decode(strm))
6752     return FALSE;
6753   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
6754     return FALSE;
6755
6756   return UnknownExtensionsDecode(strm);
6757 }
6758
6759
6760 void H225_ServiceControlIndication::Encode(PASN_Stream & strm) const
6761 {
6762   PreambleEncode(strm);
6763
6764   m_requestSeqNum.Encode(strm);
6765   if (HasOptionalField(e_nonStandardData))
6766     m_nonStandardData.Encode(strm);
6767   m_serviceControl.Encode(strm);
6768   if (HasOptionalField(e_endpointIdentifier))
6769     m_endpointIdentifier.Encode(strm);
6770   if (HasOptionalField(e_callSpecific))
6771     m_callSpecific.Encode(strm);
6772   if (HasOptionalField(e_tokens))
6773     m_tokens.Encode(strm);
6774   if (HasOptionalField(e_cryptoTokens))
6775     m_cryptoTokens.Encode(strm);
6776   if (HasOptionalField(e_integrityCheckValue))
6777     m_integrityCheckValue.Encode(strm);
6778   if (HasOptionalField(e_featureSet))
6779     m_featureSet.Encode(strm);
6780   if (HasOptionalField(e_genericData))
6781     m_genericData.Encode(strm);
6782
6783   UnknownExtensionsEncode(strm);
6784 }
6785
6786
6787 PObject * H225_ServiceControlIndication::Clone() const
6788 {
6789 #ifndef PASN_LEANANDMEAN
6790   PAssert(IsClass(H225_ServiceControlIndication::Class()), PInvalidCast);
6791 #endif
6792   return new H225_ServiceControlIndication(*this);
6793 }
6794
6795
6796 //
6797 // ServiceControlResponse
6798 //
6799
6800 H225_ServiceControlResponse::H225_ServiceControlResponse(unsigned tag, PASN_Object::TagClass tagClass)
6801   : PASN_Sequence(tag, tagClass, 7, TRUE, 0)
6802 {
6803 }
6804
6805
6806 #ifndef PASN_NOPRINTON
6807 void H225_ServiceControlResponse::PrintOn(ostream & strm) const
6808 {
6809   int indent = strm.precision() + 2;
6810   strm << "{\n";
6811   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
6812   if (HasOptionalField(e_result))
6813     strm << setw(indent+9) << "result = " << setprecision(indent) << m_result << '\n';
6814   if (HasOptionalField(e_nonStandardData))
6815     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6816   if (HasOptionalField(e_tokens))
6817     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
6818   if (HasOptionalField(e_cryptoTokens))
6819     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
6820   if (HasOptionalField(e_integrityCheckValue))
6821     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
6822   if (HasOptionalField(e_featureSet))
6823     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
6824   if (HasOptionalField(e_genericData))
6825     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
6826   strm << setw(indent-1) << setprecision(indent-2) << "}";
6827 }
6828 #endif
6829
6830
6831 PObject::Comparison H225_ServiceControlResponse::Compare(const PObject & obj) const
6832 {
6833 #ifndef PASN_LEANANDMEAN
6834   PAssert(PIsDescendant(&obj, H225_ServiceControlResponse), PInvalidCast);
6835 #endif
6836   const H225_ServiceControlResponse & other = (const H225_ServiceControlResponse &)obj;
6837
6838   Comparison result;
6839
6840   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
6841     return result;
6842   if ((result = m_result.Compare(other.m_result)) != EqualTo)
6843     return result;
6844   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6845     return result;
6846   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
6847     return result;
6848   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
6849     return result;
6850   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
6851     return result;
6852   if ((result = m_featureSet.Compare(other.m_featureSet)) != EqualTo)
6853     return result;
6854   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
6855     return result;
6856
6857   return PASN_Sequence::Compare(other);
6858 }
6859
6860
6861 PINDEX H225_ServiceControlResponse::GetDataLength() const
6862 {
6863   PINDEX length = 0;
6864   length += m_requestSeqNum.GetObjectLength();
6865   if (HasOptionalField(e_result))
6866     length += m_result.GetObjectLength();
6867   if (HasOptionalField(e_nonStandardData))
6868     length += m_nonStandardData.GetObjectLength();
6869   if (HasOptionalField(e_tokens))
6870     length += m_tokens.GetObjectLength();
6871   if (HasOptionalField(e_cryptoTokens))
6872     length += m_cryptoTokens.GetObjectLength();
6873   if (HasOptionalField(e_integrityCheckValue))
6874     length += m_integrityCheckValue.GetObjectLength();
6875   if (HasOptionalField(e_featureSet))
6876     length += m_featureSet.GetObjectLength();
6877   if (HasOptionalField(e_genericData))
6878     length += m_genericData.GetObjectLength();
6879   return length;
6880 }
6881
6882
6883 BOOL H225_ServiceControlResponse::Decode(PASN_Stream & strm)
6884 {
6885   if (!PreambleDecode(strm))
6886     return FALSE;
6887
6888   if (!m_requestSeqNum.Decode(strm))
6889     return FALSE;
6890   if (HasOptionalField(e_result) && !m_result.Decode(strm))
6891     return FALSE;
6892   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
6893     return FALSE;
6894   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
6895     return FALSE;
6896   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
6897     return FALSE;
6898   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
6899     return FALSE;
6900   if (HasOptionalField(e_featureSet) && !m_featureSet.Decode(strm))
6901     return FALSE;
6902   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
6903     return FALSE;
6904
6905   return UnknownExtensionsDecode(strm);
6906 }
6907
6908
6909 void H225_ServiceControlResponse::Encode(PASN_Stream & strm) const
6910 {
6911   PreambleEncode(strm);
6912
6913   m_requestSeqNum.Encode(strm);
6914   if (HasOptionalField(e_result))
6915     m_result.Encode(strm);
6916   if (HasOptionalField(e_nonStandardData))
6917     m_nonStandardData.Encode(strm);
6918   if (HasOptionalField(e_tokens))
6919     m_tokens.Encode(strm);
6920   if (HasOptionalField(e_cryptoTokens))
6921     m_cryptoTokens.Encode(strm);
6922   if (HasOptionalField(e_integrityCheckValue))
6923     m_integrityCheckValue.Encode(strm);
6924   if (HasOptionalField(e_featureSet))
6925     m_featureSet.Encode(strm);
6926   if (HasOptionalField(e_genericData))
6927     m_genericData.Encode(strm);
6928
6929   UnknownExtensionsEncode(strm);
6930 }
6931
6932
6933 PObject * H225_ServiceControlResponse::Clone() const
6934 {
6935 #ifndef PASN_LEANANDMEAN
6936   PAssert(IsClass(H225_ServiceControlResponse::Class()), PInvalidCast);
6937 #endif
6938   return new H225_ServiceControlResponse(*this);
6939 }
6940
6941
6942 //
6943 // H323-UU-PDU_tunnelledSignallingMessage
6944 //
6945
6946 H225_H323_UU_PDU_tunnelledSignallingMessage::H225_H323_UU_PDU_tunnelledSignallingMessage(unsigned tag, PASN_Object::TagClass tagClass)
6947   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
6948 {
6949 }
6950
6951
6952 #ifndef PASN_NOPRINTON
6953 void H225_H323_UU_PDU_tunnelledSignallingMessage::PrintOn(ostream & strm) const
6954 {
6955   int indent = strm.precision() + 2;
6956   strm << "{\n";
6957   strm << setw(indent+22) << "tunnelledProtocolID = " << setprecision(indent) << m_tunnelledProtocolID << '\n';
6958   strm << setw(indent+17) << "messageContent = " << setprecision(indent) << m_messageContent << '\n';
6959   if (HasOptionalField(e_tunnellingRequired))
6960     strm << setw(indent+21) << "tunnellingRequired = " << setprecision(indent) << m_tunnellingRequired << '\n';
6961   if (HasOptionalField(e_nonStandardData))
6962     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
6963   strm << setw(indent-1) << setprecision(indent-2) << "}";
6964 }
6965 #endif
6966
6967
6968 PObject::Comparison H225_H323_UU_PDU_tunnelledSignallingMessage::Compare(const PObject & obj) const
6969 {
6970 #ifndef PASN_LEANANDMEAN
6971   PAssert(PIsDescendant(&obj, H225_H323_UU_PDU_tunnelledSignallingMessage), PInvalidCast);
6972 #endif
6973   const H225_H323_UU_PDU_tunnelledSignallingMessage & other = (const H225_H323_UU_PDU_tunnelledSignallingMessage &)obj;
6974
6975   Comparison result;
6976
6977   if ((result = m_tunnelledProtocolID.Compare(other.m_tunnelledProtocolID)) != EqualTo)
6978     return result;
6979   if ((result = m_messageContent.Compare(other.m_messageContent)) != EqualTo)
6980     return result;
6981   if ((result = m_tunnellingRequired.Compare(other.m_tunnellingRequired)) != EqualTo)
6982     return result;
6983   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
6984     return result;
6985
6986   return PASN_Sequence::Compare(other);
6987 }
6988
6989
6990 PINDEX H225_H323_UU_PDU_tunnelledSignallingMessage::GetDataLength() const
6991 {
6992   PINDEX length = 0;
6993   length += m_tunnelledProtocolID.GetObjectLength();
6994   length += m_messageContent.GetObjectLength();
6995   if (HasOptionalField(e_tunnellingRequired))
6996     length += m_tunnellingRequired.GetObjectLength();
6997   if (HasOptionalField(e_nonStandardData))
6998     length += m_nonStandardData.GetObjectLength();
6999   return length;
7000 }
7001
7002
7003 BOOL H225_H323_UU_PDU_tunnelledSignallingMessage::Decode(PASN_Stream & strm)
7004 {
7005   if (!PreambleDecode(strm))
7006     return FALSE;
7007
7008   if (!m_tunnelledProtocolID.Decode(strm))
7009     return FALSE;
7010   if (!m_messageContent.Decode(strm))
7011     return FALSE;
7012   if (HasOptionalField(e_tunnellingRequired) && !m_tunnellingRequired.Decode(strm))
7013     return FALSE;
7014   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7015     return FALSE;
7016
7017   return UnknownExtensionsDecode(strm);
7018 }
7019
7020
7021 void H225_H323_UU_PDU_tunnelledSignallingMessage::Encode(PASN_Stream & strm) const
7022 {
7023   PreambleEncode(strm);
7024
7025   m_tunnelledProtocolID.Encode(strm);
7026   m_messageContent.Encode(strm);
7027   if (HasOptionalField(e_tunnellingRequired))
7028     m_tunnellingRequired.Encode(strm);
7029   if (HasOptionalField(e_nonStandardData))
7030     m_nonStandardData.Encode(strm);
7031
7032   UnknownExtensionsEncode(strm);
7033 }
7034
7035
7036 PObject * H225_H323_UU_PDU_tunnelledSignallingMessage::Clone() const
7037 {
7038 #ifndef PASN_LEANANDMEAN
7039   PAssert(IsClass(H225_H323_UU_PDU_tunnelledSignallingMessage::Class()), PInvalidCast);
7040 #endif
7041   return new H225_H323_UU_PDU_tunnelledSignallingMessage(*this);
7042 }
7043
7044
7045 //
7046 // TransportAddress_ipSourceRoute
7047 //
7048
7049 H225_TransportAddress_ipSourceRoute::H225_TransportAddress_ipSourceRoute(unsigned tag, PASN_Object::TagClass tagClass)
7050   : PASN_Sequence(tag, tagClass, 0, TRUE, 0)
7051 {
7052   m_ip.SetConstraints(PASN_Object::FixedConstraint, 4);
7053   m_port.SetConstraints(PASN_Object::FixedConstraint, 0, 65535);
7054 }
7055
7056
7057 #ifndef PASN_NOPRINTON
7058 void H225_TransportAddress_ipSourceRoute::PrintOn(ostream & strm) const
7059 {
7060   int indent = strm.precision() + 2;
7061   strm << "{\n";
7062   strm << setw(indent+5) << "ip = " << setprecision(indent) << m_ip << '\n';
7063   strm << setw(indent+7) << "port = " << setprecision(indent) << m_port << '\n';
7064   strm << setw(indent+8) << "route = " << setprecision(indent) << m_route << '\n';
7065   strm << setw(indent+10) << "routing = " << setprecision(indent) << m_routing << '\n';
7066   strm << setw(indent-1) << setprecision(indent-2) << "}";
7067 }
7068 #endif
7069
7070
7071 PObject::Comparison H225_TransportAddress_ipSourceRoute::Compare(const PObject & obj) const
7072 {
7073 #ifndef PASN_LEANANDMEAN
7074   PAssert(PIsDescendant(&obj, H225_TransportAddress_ipSourceRoute), PInvalidCast);
7075 #endif
7076   const H225_TransportAddress_ipSourceRoute & other = (const H225_TransportAddress_ipSourceRoute &)obj;
7077
7078   Comparison result;
7079
7080   if ((result = m_ip.Compare(other.m_ip)) != EqualTo)
7081     return result;
7082   if ((result = m_port.Compare(other.m_port)) != EqualTo)
7083     return result;
7084   if ((result = m_route.Compare(other.m_route)) != EqualTo)
7085     return result;
7086   if ((result = m_routing.Compare(other.m_routing)) != EqualTo)
7087     return result;
7088
7089   return PASN_Sequence::Compare(other);
7090 }
7091
7092
7093 PINDEX H225_TransportAddress_ipSourceRoute::GetDataLength() const
7094 {
7095   PINDEX length = 0;
7096   length += m_ip.GetObjectLength();
7097   length += m_port.GetObjectLength();
7098   length += m_route.GetObjectLength();
7099   length += m_routing.GetObjectLength();
7100   return length;
7101 }
7102
7103
7104 BOOL H225_TransportAddress_ipSourceRoute::Decode(PASN_Stream & strm)
7105 {
7106   if (!PreambleDecode(strm))
7107     return FALSE;
7108
7109   if (!m_ip.Decode(strm))
7110     return FALSE;
7111   if (!m_port.Decode(strm))
7112     return FALSE;
7113   if (!m_route.Decode(strm))
7114     return FALSE;
7115   if (!m_routing.Decode(strm))
7116     return FALSE;
7117
7118   return UnknownExtensionsDecode(strm);
7119 }
7120
7121
7122 void H225_TransportAddress_ipSourceRoute::Encode(PASN_Stream & strm) const
7123 {
7124   PreambleEncode(strm);
7125
7126   m_ip.Encode(strm);
7127   m_port.Encode(strm);
7128   m_route.Encode(strm);
7129   m_routing.Encode(strm);
7130
7131   UnknownExtensionsEncode(strm);
7132 }
7133
7134
7135 PObject * H225_TransportAddress_ipSourceRoute::Clone() const
7136 {
7137 #ifndef PASN_LEANANDMEAN
7138   PAssert(IsClass(H225_TransportAddress_ipSourceRoute::Class()), PInvalidCast);
7139 #endif
7140   return new H225_TransportAddress_ipSourceRoute(*this);
7141 }
7142
7143
7144 //
7145 // RegistrationConfirm_preGrantedARQ
7146 //
7147
7148 H225_RegistrationConfirm_preGrantedARQ::H225_RegistrationConfirm_preGrantedARQ(unsigned tag, PASN_Object::TagClass tagClass)
7149   : PASN_Sequence(tag, tagClass, 0, TRUE, 4)
7150 {
7151   m_irrFrequencyInCall.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
7152 }
7153
7154
7155 #ifndef PASN_NOPRINTON
7156 void H225_RegistrationConfirm_preGrantedARQ::PrintOn(ostream & strm) const
7157 {
7158   int indent = strm.precision() + 2;
7159   strm << "{\n";
7160   strm << setw(indent+11) << "makeCall = " << setprecision(indent) << m_makeCall << '\n';
7161   strm << setw(indent+35) << "useGKCallSignalAddressToMakeCall = " << setprecision(indent) << m_useGKCallSignalAddressToMakeCall << '\n';
7162   strm << setw(indent+13) << "answerCall = " << setprecision(indent) << m_answerCall << '\n';
7163   strm << setw(indent+33) << "useGKCallSignalAddressToAnswer = " << setprecision(indent) << m_useGKCallSignalAddressToAnswer << '\n';
7164   if (HasOptionalField(e_irrFrequencyInCall))
7165     strm << setw(indent+21) << "irrFrequencyInCall = " << setprecision(indent) << m_irrFrequencyInCall << '\n';
7166   if (HasOptionalField(e_totalBandwidthRestriction))
7167     strm << setw(indent+28) << "totalBandwidthRestriction = " << setprecision(indent) << m_totalBandwidthRestriction << '\n';
7168   if (HasOptionalField(e_alternateTransportAddresses))
7169     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
7170   if (HasOptionalField(e_useSpecifiedTransport))
7171     strm << setw(indent+24) << "useSpecifiedTransport = " << setprecision(indent) << m_useSpecifiedTransport << '\n';
7172   strm << setw(indent-1) << setprecision(indent-2) << "}";
7173 }
7174 #endif
7175
7176
7177 PObject::Comparison H225_RegistrationConfirm_preGrantedARQ::Compare(const PObject & obj) const
7178 {
7179 #ifndef PASN_LEANANDMEAN
7180   PAssert(PIsDescendant(&obj, H225_RegistrationConfirm_preGrantedARQ), PInvalidCast);
7181 #endif
7182   const H225_RegistrationConfirm_preGrantedARQ & other = (const H225_RegistrationConfirm_preGrantedARQ &)obj;
7183
7184   Comparison result;
7185
7186   if ((result = m_makeCall.Compare(other.m_makeCall)) != EqualTo)
7187     return result;
7188   if ((result = m_useGKCallSignalAddressToMakeCall.Compare(other.m_useGKCallSignalAddressToMakeCall)) != EqualTo)
7189     return result;
7190   if ((result = m_answerCall.Compare(other.m_answerCall)) != EqualTo)
7191     return result;
7192   if ((result = m_useGKCallSignalAddressToAnswer.Compare(other.m_useGKCallSignalAddressToAnswer)) != EqualTo)
7193     return result;
7194
7195   return PASN_Sequence::Compare(other);
7196 }
7197
7198
7199 PINDEX H225_RegistrationConfirm_preGrantedARQ::GetDataLength() const
7200 {
7201   PINDEX length = 0;
7202   length += m_makeCall.GetObjectLength();
7203   length += m_useGKCallSignalAddressToMakeCall.GetObjectLength();
7204   length += m_answerCall.GetObjectLength();
7205   length += m_useGKCallSignalAddressToAnswer.GetObjectLength();
7206   return length;
7207 }
7208
7209
7210 BOOL H225_RegistrationConfirm_preGrantedARQ::Decode(PASN_Stream & strm)
7211 {
7212   if (!PreambleDecode(strm))
7213     return FALSE;
7214
7215   if (!m_makeCall.Decode(strm))
7216     return FALSE;
7217   if (!m_useGKCallSignalAddressToMakeCall.Decode(strm))
7218     return FALSE;
7219   if (!m_answerCall.Decode(strm))
7220     return FALSE;
7221   if (!m_useGKCallSignalAddressToAnswer.Decode(strm))
7222     return FALSE;
7223   if (!KnownExtensionDecode(strm, e_irrFrequencyInCall, m_irrFrequencyInCall))
7224     return FALSE;
7225   if (!KnownExtensionDecode(strm, e_totalBandwidthRestriction, m_totalBandwidthRestriction))
7226     return FALSE;
7227   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
7228     return FALSE;
7229   if (!KnownExtensionDecode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport))
7230     return FALSE;
7231
7232   return UnknownExtensionsDecode(strm);
7233 }
7234
7235
7236 void H225_RegistrationConfirm_preGrantedARQ::Encode(PASN_Stream & strm) const
7237 {
7238   PreambleEncode(strm);
7239
7240   m_makeCall.Encode(strm);
7241   m_useGKCallSignalAddressToMakeCall.Encode(strm);
7242   m_answerCall.Encode(strm);
7243   m_useGKCallSignalAddressToAnswer.Encode(strm);
7244   KnownExtensionEncode(strm, e_irrFrequencyInCall, m_irrFrequencyInCall);
7245   KnownExtensionEncode(strm, e_totalBandwidthRestriction, m_totalBandwidthRestriction);
7246   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
7247   KnownExtensionEncode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport);
7248
7249   UnknownExtensionsEncode(strm);
7250 }
7251
7252
7253 PObject * H225_RegistrationConfirm_preGrantedARQ::Clone() const
7254 {
7255 #ifndef PASN_LEANANDMEAN
7256   PAssert(IsClass(H225_RegistrationConfirm_preGrantedARQ::Class()), PInvalidCast);
7257 #endif
7258   return new H225_RegistrationConfirm_preGrantedARQ(*this);
7259 }
7260
7261
7262 //
7263 // StimulusControl
7264 //
7265
7266 H225_StimulusControl::H225_StimulusControl(unsigned tag, PASN_Object::TagClass tagClass)
7267   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
7268 {
7269 }
7270
7271
7272 #ifndef PASN_NOPRINTON
7273 void H225_StimulusControl::PrintOn(ostream & strm) const
7274 {
7275   int indent = strm.precision() + 2;
7276   strm << "{\n";
7277   if (HasOptionalField(e_nonStandard))
7278     strm << setw(indent+14) << "nonStandard = " << setprecision(indent) << m_nonStandard << '\n';
7279   if (HasOptionalField(e_isText))
7280     strm << setw(indent+9) << "isText = " << setprecision(indent) << m_isText << '\n';
7281   if (HasOptionalField(e_h248Message))
7282     strm << setw(indent+14) << "h248Message = " << setprecision(indent) << m_h248Message << '\n';
7283   strm << setw(indent-1) << setprecision(indent-2) << "}";
7284 }
7285 #endif
7286
7287
7288 PObject::Comparison H225_StimulusControl::Compare(const PObject & obj) const
7289 {
7290 #ifndef PASN_LEANANDMEAN
7291   PAssert(PIsDescendant(&obj, H225_StimulusControl), PInvalidCast);
7292 #endif
7293   const H225_StimulusControl & other = (const H225_StimulusControl &)obj;
7294
7295   Comparison result;
7296
7297   if ((result = m_nonStandard.Compare(other.m_nonStandard)) != EqualTo)
7298     return result;
7299   if ((result = m_isText.Compare(other.m_isText)) != EqualTo)
7300     return result;
7301   if ((result = m_h248Message.Compare(other.m_h248Message)) != EqualTo)
7302     return result;
7303
7304   return PASN_Sequence::Compare(other);
7305 }
7306
7307
7308 PINDEX H225_StimulusControl::GetDataLength() const
7309 {
7310   PINDEX length = 0;
7311   if (HasOptionalField(e_nonStandard))
7312     length += m_nonStandard.GetObjectLength();
7313   if (HasOptionalField(e_isText))
7314     length += m_isText.GetObjectLength();
7315   if (HasOptionalField(e_h248Message))
7316     length += m_h248Message.GetObjectLength();
7317   return length;
7318 }
7319
7320
7321 BOOL H225_StimulusControl::Decode(PASN_Stream & strm)
7322 {
7323   if (!PreambleDecode(strm))
7324     return FALSE;
7325
7326   if (HasOptionalField(e_nonStandard) && !m_nonStandard.Decode(strm))
7327     return FALSE;
7328   if (HasOptionalField(e_isText) && !m_isText.Decode(strm))
7329     return FALSE;
7330   if (HasOptionalField(e_h248Message) && !m_h248Message.Decode(strm))
7331     return FALSE;
7332
7333   return UnknownExtensionsDecode(strm);
7334 }
7335
7336
7337 void H225_StimulusControl::Encode(PASN_Stream & strm) const
7338 {
7339   PreambleEncode(strm);
7340
7341   if (HasOptionalField(e_nonStandard))
7342     m_nonStandard.Encode(strm);
7343   if (HasOptionalField(e_isText))
7344     m_isText.Encode(strm);
7345   if (HasOptionalField(e_h248Message))
7346     m_h248Message.Encode(strm);
7347
7348   UnknownExtensionsEncode(strm);
7349 }
7350
7351
7352 PObject * H225_StimulusControl::Clone() const
7353 {
7354 #ifndef PASN_LEANANDMEAN
7355   PAssert(IsClass(H225_StimulusControl::Class()), PInvalidCast);
7356 #endif
7357   return new H225_StimulusControl(*this);
7358 }
7359
7360
7361 //
7362 // ConferenceList
7363 //
7364
7365 H225_ConferenceList::H225_ConferenceList(unsigned tag, PASN_Object::TagClass tagClass)
7366   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
7367 {
7368 }
7369
7370
7371 #ifndef PASN_NOPRINTON
7372 void H225_ConferenceList::PrintOn(ostream & strm) const
7373 {
7374   int indent = strm.precision() + 2;
7375   strm << "{\n";
7376   if (HasOptionalField(e_conferenceID))
7377     strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
7378   if (HasOptionalField(e_conferenceAlias))
7379     strm << setw(indent+18) << "conferenceAlias = " << setprecision(indent) << m_conferenceAlias << '\n';
7380   if (HasOptionalField(e_nonStandardData))
7381     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7382   strm << setw(indent-1) << setprecision(indent-2) << "}";
7383 }
7384 #endif
7385
7386
7387 PObject::Comparison H225_ConferenceList::Compare(const PObject & obj) const
7388 {
7389 #ifndef PASN_LEANANDMEAN
7390   PAssert(PIsDescendant(&obj, H225_ConferenceList), PInvalidCast);
7391 #endif
7392   const H225_ConferenceList & other = (const H225_ConferenceList &)obj;
7393
7394   Comparison result;
7395
7396   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
7397     return result;
7398   if ((result = m_conferenceAlias.Compare(other.m_conferenceAlias)) != EqualTo)
7399     return result;
7400   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7401     return result;
7402
7403   return PASN_Sequence::Compare(other);
7404 }
7405
7406
7407 PINDEX H225_ConferenceList::GetDataLength() const
7408 {
7409   PINDEX length = 0;
7410   if (HasOptionalField(e_conferenceID))
7411     length += m_conferenceID.GetObjectLength();
7412   if (HasOptionalField(e_conferenceAlias))
7413     length += m_conferenceAlias.GetObjectLength();
7414   if (HasOptionalField(e_nonStandardData))
7415     length += m_nonStandardData.GetObjectLength();
7416   return length;
7417 }
7418
7419
7420 BOOL H225_ConferenceList::Decode(PASN_Stream & strm)
7421 {
7422   if (!PreambleDecode(strm))
7423     return FALSE;
7424
7425   if (HasOptionalField(e_conferenceID) && !m_conferenceID.Decode(strm))
7426     return FALSE;
7427   if (HasOptionalField(e_conferenceAlias) && !m_conferenceAlias.Decode(strm))
7428     return FALSE;
7429   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7430     return FALSE;
7431
7432   return UnknownExtensionsDecode(strm);
7433 }
7434
7435
7436 void H225_ConferenceList::Encode(PASN_Stream & strm) const
7437 {
7438   PreambleEncode(strm);
7439
7440   if (HasOptionalField(e_conferenceID))
7441     m_conferenceID.Encode(strm);
7442   if (HasOptionalField(e_conferenceAlias))
7443     m_conferenceAlias.Encode(strm);
7444   if (HasOptionalField(e_nonStandardData))
7445     m_nonStandardData.Encode(strm);
7446
7447   UnknownExtensionsEncode(strm);
7448 }
7449
7450
7451 PObject * H225_ConferenceList::Clone() const
7452 {
7453 #ifndef PASN_LEANANDMEAN
7454   PAssert(IsClass(H225_ConferenceList::Class()), PInvalidCast);
7455 #endif
7456   return new H225_ConferenceList(*this);
7457 }
7458
7459
7460 //
7461 // GatewayInfo
7462 //
7463
7464 H225_GatewayInfo::H225_GatewayInfo(unsigned tag, PASN_Object::TagClass tagClass)
7465   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
7466 {
7467 }
7468
7469
7470 #ifndef PASN_NOPRINTON
7471 void H225_GatewayInfo::PrintOn(ostream & strm) const
7472 {
7473   int indent = strm.precision() + 2;
7474   strm << "{\n";
7475   if (HasOptionalField(e_protocol))
7476     strm << setw(indent+11) << "protocol = " << setprecision(indent) << m_protocol << '\n';
7477   if (HasOptionalField(e_nonStandardData))
7478     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7479   strm << setw(indent-1) << setprecision(indent-2) << "}";
7480 }
7481 #endif
7482
7483
7484 PObject::Comparison H225_GatewayInfo::Compare(const PObject & obj) const
7485 {
7486 #ifndef PASN_LEANANDMEAN
7487   PAssert(PIsDescendant(&obj, H225_GatewayInfo), PInvalidCast);
7488 #endif
7489   const H225_GatewayInfo & other = (const H225_GatewayInfo &)obj;
7490
7491   Comparison result;
7492
7493   if ((result = m_protocol.Compare(other.m_protocol)) != EqualTo)
7494     return result;
7495   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7496     return result;
7497
7498   return PASN_Sequence::Compare(other);
7499 }
7500
7501
7502 PINDEX H225_GatewayInfo::GetDataLength() const
7503 {
7504   PINDEX length = 0;
7505   if (HasOptionalField(e_protocol))
7506     length += m_protocol.GetObjectLength();
7507   if (HasOptionalField(e_nonStandardData))
7508     length += m_nonStandardData.GetObjectLength();
7509   return length;
7510 }
7511
7512
7513 BOOL H225_GatewayInfo::Decode(PASN_Stream & strm)
7514 {
7515   if (!PreambleDecode(strm))
7516     return FALSE;
7517
7518   if (HasOptionalField(e_protocol) && !m_protocol.Decode(strm))
7519     return FALSE;
7520   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7521     return FALSE;
7522
7523   return UnknownExtensionsDecode(strm);
7524 }
7525
7526
7527 void H225_GatewayInfo::Encode(PASN_Stream & strm) const
7528 {
7529   PreambleEncode(strm);
7530
7531   if (HasOptionalField(e_protocol))
7532     m_protocol.Encode(strm);
7533   if (HasOptionalField(e_nonStandardData))
7534     m_nonStandardData.Encode(strm);
7535
7536   UnknownExtensionsEncode(strm);
7537 }
7538
7539
7540 PObject * H225_GatewayInfo::Clone() const
7541 {
7542 #ifndef PASN_LEANANDMEAN
7543   PAssert(IsClass(H225_GatewayInfo::Class()), PInvalidCast);
7544 #endif
7545   return new H225_GatewayInfo(*this);
7546 }
7547
7548
7549 //
7550 // H310Caps
7551 //
7552
7553 H225_H310Caps::H225_H310Caps(unsigned tag, PASN_Object::TagClass tagClass)
7554   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
7555 {
7556   IncludeOptionalField(e_supportedPrefixes);
7557 }
7558
7559
7560 #ifndef PASN_NOPRINTON
7561 void H225_H310Caps::PrintOn(ostream & strm) const
7562 {
7563   int indent = strm.precision() + 2;
7564   strm << "{\n";
7565   if (HasOptionalField(e_nonStandardData))
7566     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7567   if (HasOptionalField(e_dataRatesSupported))
7568     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
7569   if (HasOptionalField(e_supportedPrefixes))
7570     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
7571   strm << setw(indent-1) << setprecision(indent-2) << "}";
7572 }
7573 #endif
7574
7575
7576 PObject::Comparison H225_H310Caps::Compare(const PObject & obj) const
7577 {
7578 #ifndef PASN_LEANANDMEAN
7579   PAssert(PIsDescendant(&obj, H225_H310Caps), PInvalidCast);
7580 #endif
7581   const H225_H310Caps & other = (const H225_H310Caps &)obj;
7582
7583   Comparison result;
7584
7585   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7586     return result;
7587
7588   return PASN_Sequence::Compare(other);
7589 }
7590
7591
7592 PINDEX H225_H310Caps::GetDataLength() const
7593 {
7594   PINDEX length = 0;
7595   if (HasOptionalField(e_nonStandardData))
7596     length += m_nonStandardData.GetObjectLength();
7597   return length;
7598 }
7599
7600
7601 BOOL H225_H310Caps::Decode(PASN_Stream & strm)
7602 {
7603   if (!PreambleDecode(strm))
7604     return FALSE;
7605
7606   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7607     return FALSE;
7608   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
7609     return FALSE;
7610   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
7611     return FALSE;
7612
7613   return UnknownExtensionsDecode(strm);
7614 }
7615
7616
7617 void H225_H310Caps::Encode(PASN_Stream & strm) const
7618 {
7619   PreambleEncode(strm);
7620
7621   if (HasOptionalField(e_nonStandardData))
7622     m_nonStandardData.Encode(strm);
7623   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
7624   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
7625
7626   UnknownExtensionsEncode(strm);
7627 }
7628
7629
7630 PObject * H225_H310Caps::Clone() const
7631 {
7632 #ifndef PASN_LEANANDMEAN
7633   PAssert(IsClass(H225_H310Caps::Class()), PInvalidCast);
7634 #endif
7635   return new H225_H310Caps(*this);
7636 }
7637
7638
7639 //
7640 // H320Caps
7641 //
7642
7643 H225_H320Caps::H225_H320Caps(unsigned tag, PASN_Object::TagClass tagClass)
7644   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
7645 {
7646   IncludeOptionalField(e_supportedPrefixes);
7647 }
7648
7649
7650 #ifndef PASN_NOPRINTON
7651 void H225_H320Caps::PrintOn(ostream & strm) const
7652 {
7653   int indent = strm.precision() + 2;
7654   strm << "{\n";
7655   if (HasOptionalField(e_nonStandardData))
7656     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7657   if (HasOptionalField(e_dataRatesSupported))
7658     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
7659   if (HasOptionalField(e_supportedPrefixes))
7660     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
7661   strm << setw(indent-1) << setprecision(indent-2) << "}";
7662 }
7663 #endif
7664
7665
7666 PObject::Comparison H225_H320Caps::Compare(const PObject & obj) const
7667 {
7668 #ifndef PASN_LEANANDMEAN
7669   PAssert(PIsDescendant(&obj, H225_H320Caps), PInvalidCast);
7670 #endif
7671   const H225_H320Caps & other = (const H225_H320Caps &)obj;
7672
7673   Comparison result;
7674
7675   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7676     return result;
7677
7678   return PASN_Sequence::Compare(other);
7679 }
7680
7681
7682 PINDEX H225_H320Caps::GetDataLength() const
7683 {
7684   PINDEX length = 0;
7685   if (HasOptionalField(e_nonStandardData))
7686     length += m_nonStandardData.GetObjectLength();
7687   return length;
7688 }
7689
7690
7691 BOOL H225_H320Caps::Decode(PASN_Stream & strm)
7692 {
7693   if (!PreambleDecode(strm))
7694     return FALSE;
7695
7696   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7697     return FALSE;
7698   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
7699     return FALSE;
7700   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
7701     return FALSE;
7702
7703   return UnknownExtensionsDecode(strm);
7704 }
7705
7706
7707 void H225_H320Caps::Encode(PASN_Stream & strm) const
7708 {
7709   PreambleEncode(strm);
7710
7711   if (HasOptionalField(e_nonStandardData))
7712     m_nonStandardData.Encode(strm);
7713   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
7714   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
7715
7716   UnknownExtensionsEncode(strm);
7717 }
7718
7719
7720 PObject * H225_H320Caps::Clone() const
7721 {
7722 #ifndef PASN_LEANANDMEAN
7723   PAssert(IsClass(H225_H320Caps::Class()), PInvalidCast);
7724 #endif
7725   return new H225_H320Caps(*this);
7726 }
7727
7728
7729 //
7730 // H321Caps
7731 //
7732
7733 H225_H321Caps::H225_H321Caps(unsigned tag, PASN_Object::TagClass tagClass)
7734   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
7735 {
7736   IncludeOptionalField(e_supportedPrefixes);
7737 }
7738
7739
7740 #ifndef PASN_NOPRINTON
7741 void H225_H321Caps::PrintOn(ostream & strm) const
7742 {
7743   int indent = strm.precision() + 2;
7744   strm << "{\n";
7745   if (HasOptionalField(e_nonStandardData))
7746     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7747   if (HasOptionalField(e_dataRatesSupported))
7748     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
7749   if (HasOptionalField(e_supportedPrefixes))
7750     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
7751   strm << setw(indent-1) << setprecision(indent-2) << "}";
7752 }
7753 #endif
7754
7755
7756 PObject::Comparison H225_H321Caps::Compare(const PObject & obj) const
7757 {
7758 #ifndef PASN_LEANANDMEAN
7759   PAssert(PIsDescendant(&obj, H225_H321Caps), PInvalidCast);
7760 #endif
7761   const H225_H321Caps & other = (const H225_H321Caps &)obj;
7762
7763   Comparison result;
7764
7765   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7766     return result;
7767
7768   return PASN_Sequence::Compare(other);
7769 }
7770
7771
7772 PINDEX H225_H321Caps::GetDataLength() const
7773 {
7774   PINDEX length = 0;
7775   if (HasOptionalField(e_nonStandardData))
7776     length += m_nonStandardData.GetObjectLength();
7777   return length;
7778 }
7779
7780
7781 BOOL H225_H321Caps::Decode(PASN_Stream & strm)
7782 {
7783   if (!PreambleDecode(strm))
7784     return FALSE;
7785
7786   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7787     return FALSE;
7788   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
7789     return FALSE;
7790   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
7791     return FALSE;
7792
7793   return UnknownExtensionsDecode(strm);
7794 }
7795
7796
7797 void H225_H321Caps::Encode(PASN_Stream & strm) const
7798 {
7799   PreambleEncode(strm);
7800
7801   if (HasOptionalField(e_nonStandardData))
7802     m_nonStandardData.Encode(strm);
7803   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
7804   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
7805
7806   UnknownExtensionsEncode(strm);
7807 }
7808
7809
7810 PObject * H225_H321Caps::Clone() const
7811 {
7812 #ifndef PASN_LEANANDMEAN
7813   PAssert(IsClass(H225_H321Caps::Class()), PInvalidCast);
7814 #endif
7815   return new H225_H321Caps(*this);
7816 }
7817
7818
7819 //
7820 // H322Caps
7821 //
7822
7823 H225_H322Caps::H225_H322Caps(unsigned tag, PASN_Object::TagClass tagClass)
7824   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
7825 {
7826   IncludeOptionalField(e_supportedPrefixes);
7827 }
7828
7829
7830 #ifndef PASN_NOPRINTON
7831 void H225_H322Caps::PrintOn(ostream & strm) const
7832 {
7833   int indent = strm.precision() + 2;
7834   strm << "{\n";
7835   if (HasOptionalField(e_nonStandardData))
7836     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7837   if (HasOptionalField(e_dataRatesSupported))
7838     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
7839   if (HasOptionalField(e_supportedPrefixes))
7840     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
7841   strm << setw(indent-1) << setprecision(indent-2) << "}";
7842 }
7843 #endif
7844
7845
7846 PObject::Comparison H225_H322Caps::Compare(const PObject & obj) const
7847 {
7848 #ifndef PASN_LEANANDMEAN
7849   PAssert(PIsDescendant(&obj, H225_H322Caps), PInvalidCast);
7850 #endif
7851   const H225_H322Caps & other = (const H225_H322Caps &)obj;
7852
7853   Comparison result;
7854
7855   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7856     return result;
7857
7858   return PASN_Sequence::Compare(other);
7859 }
7860
7861
7862 PINDEX H225_H322Caps::GetDataLength() const
7863 {
7864   PINDEX length = 0;
7865   if (HasOptionalField(e_nonStandardData))
7866     length += m_nonStandardData.GetObjectLength();
7867   return length;
7868 }
7869
7870
7871 BOOL H225_H322Caps::Decode(PASN_Stream & strm)
7872 {
7873   if (!PreambleDecode(strm))
7874     return FALSE;
7875
7876   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7877     return FALSE;
7878   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
7879     return FALSE;
7880   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
7881     return FALSE;
7882
7883   return UnknownExtensionsDecode(strm);
7884 }
7885
7886
7887 void H225_H322Caps::Encode(PASN_Stream & strm) const
7888 {
7889   PreambleEncode(strm);
7890
7891   if (HasOptionalField(e_nonStandardData))
7892     m_nonStandardData.Encode(strm);
7893   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
7894   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
7895
7896   UnknownExtensionsEncode(strm);
7897 }
7898
7899
7900 PObject * H225_H322Caps::Clone() const
7901 {
7902 #ifndef PASN_LEANANDMEAN
7903   PAssert(IsClass(H225_H322Caps::Class()), PInvalidCast);
7904 #endif
7905   return new H225_H322Caps(*this);
7906 }
7907
7908
7909 //
7910 // H323Caps
7911 //
7912
7913 H225_H323Caps::H225_H323Caps(unsigned tag, PASN_Object::TagClass tagClass)
7914   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
7915 {
7916   IncludeOptionalField(e_supportedPrefixes);
7917 }
7918
7919
7920 #ifndef PASN_NOPRINTON
7921 void H225_H323Caps::PrintOn(ostream & strm) const
7922 {
7923   int indent = strm.precision() + 2;
7924   strm << "{\n";
7925   if (HasOptionalField(e_nonStandardData))
7926     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
7927   if (HasOptionalField(e_dataRatesSupported))
7928     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
7929   if (HasOptionalField(e_supportedPrefixes))
7930     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
7931   strm << setw(indent-1) << setprecision(indent-2) << "}";
7932 }
7933 #endif
7934
7935
7936 PObject::Comparison H225_H323Caps::Compare(const PObject & obj) const
7937 {
7938 #ifndef PASN_LEANANDMEAN
7939   PAssert(PIsDescendant(&obj, H225_H323Caps), PInvalidCast);
7940 #endif
7941   const H225_H323Caps & other = (const H225_H323Caps &)obj;
7942
7943   Comparison result;
7944
7945   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
7946     return result;
7947
7948   return PASN_Sequence::Compare(other);
7949 }
7950
7951
7952 PINDEX H225_H323Caps::GetDataLength() const
7953 {
7954   PINDEX length = 0;
7955   if (HasOptionalField(e_nonStandardData))
7956     length += m_nonStandardData.GetObjectLength();
7957   return length;
7958 }
7959
7960
7961 BOOL H225_H323Caps::Decode(PASN_Stream & strm)
7962 {
7963   if (!PreambleDecode(strm))
7964     return FALSE;
7965
7966   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
7967     return FALSE;
7968   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
7969     return FALSE;
7970   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
7971     return FALSE;
7972
7973   return UnknownExtensionsDecode(strm);
7974 }
7975
7976
7977 void H225_H323Caps::Encode(PASN_Stream & strm) const
7978 {
7979   PreambleEncode(strm);
7980
7981   if (HasOptionalField(e_nonStandardData))
7982     m_nonStandardData.Encode(strm);
7983   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
7984   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
7985
7986   UnknownExtensionsEncode(strm);
7987 }
7988
7989
7990 PObject * H225_H323Caps::Clone() const
7991 {
7992 #ifndef PASN_LEANANDMEAN
7993   PAssert(IsClass(H225_H323Caps::Class()), PInvalidCast);
7994 #endif
7995   return new H225_H323Caps(*this);
7996 }
7997
7998
7999 //
8000 // H324Caps
8001 //
8002
8003 H225_H324Caps::H225_H324Caps(unsigned tag, PASN_Object::TagClass tagClass)
8004   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
8005 {
8006   IncludeOptionalField(e_supportedPrefixes);
8007 }
8008
8009
8010 #ifndef PASN_NOPRINTON
8011 void H225_H324Caps::PrintOn(ostream & strm) const
8012 {
8013   int indent = strm.precision() + 2;
8014   strm << "{\n";
8015   if (HasOptionalField(e_nonStandardData))
8016     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8017   if (HasOptionalField(e_dataRatesSupported))
8018     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8019   if (HasOptionalField(e_supportedPrefixes))
8020     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8021   strm << setw(indent-1) << setprecision(indent-2) << "}";
8022 }
8023 #endif
8024
8025
8026 PObject::Comparison H225_H324Caps::Compare(const PObject & obj) const
8027 {
8028 #ifndef PASN_LEANANDMEAN
8029   PAssert(PIsDescendant(&obj, H225_H324Caps), PInvalidCast);
8030 #endif
8031   const H225_H324Caps & other = (const H225_H324Caps &)obj;
8032
8033   Comparison result;
8034
8035   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8036     return result;
8037
8038   return PASN_Sequence::Compare(other);
8039 }
8040
8041
8042 PINDEX H225_H324Caps::GetDataLength() const
8043 {
8044   PINDEX length = 0;
8045   if (HasOptionalField(e_nonStandardData))
8046     length += m_nonStandardData.GetObjectLength();
8047   return length;
8048 }
8049
8050
8051 BOOL H225_H324Caps::Decode(PASN_Stream & strm)
8052 {
8053   if (!PreambleDecode(strm))
8054     return FALSE;
8055
8056   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8057     return FALSE;
8058   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
8059     return FALSE;
8060   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
8061     return FALSE;
8062
8063   return UnknownExtensionsDecode(strm);
8064 }
8065
8066
8067 void H225_H324Caps::Encode(PASN_Stream & strm) const
8068 {
8069   PreambleEncode(strm);
8070
8071   if (HasOptionalField(e_nonStandardData))
8072     m_nonStandardData.Encode(strm);
8073   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
8074   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
8075
8076   UnknownExtensionsEncode(strm);
8077 }
8078
8079
8080 PObject * H225_H324Caps::Clone() const
8081 {
8082 #ifndef PASN_LEANANDMEAN
8083   PAssert(IsClass(H225_H324Caps::Class()), PInvalidCast);
8084 #endif
8085   return new H225_H324Caps(*this);
8086 }
8087
8088
8089 //
8090 // VoiceCaps
8091 //
8092
8093 H225_VoiceCaps::H225_VoiceCaps(unsigned tag, PASN_Object::TagClass tagClass)
8094   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
8095 {
8096   IncludeOptionalField(e_supportedPrefixes);
8097 }
8098
8099
8100 #ifndef PASN_NOPRINTON
8101 void H225_VoiceCaps::PrintOn(ostream & strm) const
8102 {
8103   int indent = strm.precision() + 2;
8104   strm << "{\n";
8105   if (HasOptionalField(e_nonStandardData))
8106     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8107   if (HasOptionalField(e_dataRatesSupported))
8108     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8109   if (HasOptionalField(e_supportedPrefixes))
8110     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8111   strm << setw(indent-1) << setprecision(indent-2) << "}";
8112 }
8113 #endif
8114
8115
8116 PObject::Comparison H225_VoiceCaps::Compare(const PObject & obj) const
8117 {
8118 #ifndef PASN_LEANANDMEAN
8119   PAssert(PIsDescendant(&obj, H225_VoiceCaps), PInvalidCast);
8120 #endif
8121   const H225_VoiceCaps & other = (const H225_VoiceCaps &)obj;
8122
8123   Comparison result;
8124
8125   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8126     return result;
8127
8128   return PASN_Sequence::Compare(other);
8129 }
8130
8131
8132 PINDEX H225_VoiceCaps::GetDataLength() const
8133 {
8134   PINDEX length = 0;
8135   if (HasOptionalField(e_nonStandardData))
8136     length += m_nonStandardData.GetObjectLength();
8137   return length;
8138 }
8139
8140
8141 BOOL H225_VoiceCaps::Decode(PASN_Stream & strm)
8142 {
8143   if (!PreambleDecode(strm))
8144     return FALSE;
8145
8146   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8147     return FALSE;
8148   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
8149     return FALSE;
8150   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
8151     return FALSE;
8152
8153   return UnknownExtensionsDecode(strm);
8154 }
8155
8156
8157 void H225_VoiceCaps::Encode(PASN_Stream & strm) const
8158 {
8159   PreambleEncode(strm);
8160
8161   if (HasOptionalField(e_nonStandardData))
8162     m_nonStandardData.Encode(strm);
8163   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
8164   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
8165
8166   UnknownExtensionsEncode(strm);
8167 }
8168
8169
8170 PObject * H225_VoiceCaps::Clone() const
8171 {
8172 #ifndef PASN_LEANANDMEAN
8173   PAssert(IsClass(H225_VoiceCaps::Class()), PInvalidCast);
8174 #endif
8175   return new H225_VoiceCaps(*this);
8176 }
8177
8178
8179 //
8180 // T120OnlyCaps
8181 //
8182
8183 H225_T120OnlyCaps::H225_T120OnlyCaps(unsigned tag, PASN_Object::TagClass tagClass)
8184   : PASN_Sequence(tag, tagClass, 1, TRUE, 2)
8185 {
8186   IncludeOptionalField(e_supportedPrefixes);
8187 }
8188
8189
8190 #ifndef PASN_NOPRINTON
8191 void H225_T120OnlyCaps::PrintOn(ostream & strm) const
8192 {
8193   int indent = strm.precision() + 2;
8194   strm << "{\n";
8195   if (HasOptionalField(e_nonStandardData))
8196     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8197   if (HasOptionalField(e_dataRatesSupported))
8198     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8199   if (HasOptionalField(e_supportedPrefixes))
8200     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8201   strm << setw(indent-1) << setprecision(indent-2) << "}";
8202 }
8203 #endif
8204
8205
8206 PObject::Comparison H225_T120OnlyCaps::Compare(const PObject & obj) const
8207 {
8208 #ifndef PASN_LEANANDMEAN
8209   PAssert(PIsDescendant(&obj, H225_T120OnlyCaps), PInvalidCast);
8210 #endif
8211   const H225_T120OnlyCaps & other = (const H225_T120OnlyCaps &)obj;
8212
8213   Comparison result;
8214
8215   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8216     return result;
8217
8218   return PASN_Sequence::Compare(other);
8219 }
8220
8221
8222 PINDEX H225_T120OnlyCaps::GetDataLength() const
8223 {
8224   PINDEX length = 0;
8225   if (HasOptionalField(e_nonStandardData))
8226     length += m_nonStandardData.GetObjectLength();
8227   return length;
8228 }
8229
8230
8231 BOOL H225_T120OnlyCaps::Decode(PASN_Stream & strm)
8232 {
8233   if (!PreambleDecode(strm))
8234     return FALSE;
8235
8236   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8237     return FALSE;
8238   if (!KnownExtensionDecode(strm, e_dataRatesSupported, m_dataRatesSupported))
8239     return FALSE;
8240   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
8241     return FALSE;
8242
8243   return UnknownExtensionsDecode(strm);
8244 }
8245
8246
8247 void H225_T120OnlyCaps::Encode(PASN_Stream & strm) const
8248 {
8249   PreambleEncode(strm);
8250
8251   if (HasOptionalField(e_nonStandardData))
8252     m_nonStandardData.Encode(strm);
8253   KnownExtensionEncode(strm, e_dataRatesSupported, m_dataRatesSupported);
8254   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
8255
8256   UnknownExtensionsEncode(strm);
8257 }
8258
8259
8260 PObject * H225_T120OnlyCaps::Clone() const
8261 {
8262 #ifndef PASN_LEANANDMEAN
8263   PAssert(IsClass(H225_T120OnlyCaps::Class()), PInvalidCast);
8264 #endif
8265   return new H225_T120OnlyCaps(*this);
8266 }
8267
8268
8269 //
8270 // NonStandardProtocol
8271 //
8272
8273 H225_NonStandardProtocol::H225_NonStandardProtocol(unsigned tag, PASN_Object::TagClass tagClass)
8274   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
8275 {
8276 }
8277
8278
8279 #ifndef PASN_NOPRINTON
8280 void H225_NonStandardProtocol::PrintOn(ostream & strm) const
8281 {
8282   int indent = strm.precision() + 2;
8283   strm << "{\n";
8284   if (HasOptionalField(e_nonStandardData))
8285     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8286   if (HasOptionalField(e_dataRatesSupported))
8287     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8288   strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8289   strm << setw(indent-1) << setprecision(indent-2) << "}";
8290 }
8291 #endif
8292
8293
8294 PObject::Comparison H225_NonStandardProtocol::Compare(const PObject & obj) const
8295 {
8296 #ifndef PASN_LEANANDMEAN
8297   PAssert(PIsDescendant(&obj, H225_NonStandardProtocol), PInvalidCast);
8298 #endif
8299   const H225_NonStandardProtocol & other = (const H225_NonStandardProtocol &)obj;
8300
8301   Comparison result;
8302
8303   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8304     return result;
8305   if ((result = m_dataRatesSupported.Compare(other.m_dataRatesSupported)) != EqualTo)
8306     return result;
8307   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
8308     return result;
8309
8310   return PASN_Sequence::Compare(other);
8311 }
8312
8313
8314 PINDEX H225_NonStandardProtocol::GetDataLength() const
8315 {
8316   PINDEX length = 0;
8317   if (HasOptionalField(e_nonStandardData))
8318     length += m_nonStandardData.GetObjectLength();
8319   if (HasOptionalField(e_dataRatesSupported))
8320     length += m_dataRatesSupported.GetObjectLength();
8321   length += m_supportedPrefixes.GetObjectLength();
8322   return length;
8323 }
8324
8325
8326 BOOL H225_NonStandardProtocol::Decode(PASN_Stream & strm)
8327 {
8328   if (!PreambleDecode(strm))
8329     return FALSE;
8330
8331   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8332     return FALSE;
8333   if (HasOptionalField(e_dataRatesSupported) && !m_dataRatesSupported.Decode(strm))
8334     return FALSE;
8335   if (!m_supportedPrefixes.Decode(strm))
8336     return FALSE;
8337
8338   return UnknownExtensionsDecode(strm);
8339 }
8340
8341
8342 void H225_NonStandardProtocol::Encode(PASN_Stream & strm) const
8343 {
8344   PreambleEncode(strm);
8345
8346   if (HasOptionalField(e_nonStandardData))
8347     m_nonStandardData.Encode(strm);
8348   if (HasOptionalField(e_dataRatesSupported))
8349     m_dataRatesSupported.Encode(strm);
8350   m_supportedPrefixes.Encode(strm);
8351
8352   UnknownExtensionsEncode(strm);
8353 }
8354
8355
8356 PObject * H225_NonStandardProtocol::Clone() const
8357 {
8358 #ifndef PASN_LEANANDMEAN
8359   PAssert(IsClass(H225_NonStandardProtocol::Class()), PInvalidCast);
8360 #endif
8361   return new H225_NonStandardProtocol(*this);
8362 }
8363
8364
8365 //
8366 // T38FaxAnnexbOnlyCaps
8367 //
8368
8369 H225_T38FaxAnnexbOnlyCaps::H225_T38FaxAnnexbOnlyCaps(unsigned tag, PASN_Object::TagClass tagClass)
8370   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
8371 {
8372 }
8373
8374
8375 #ifndef PASN_NOPRINTON
8376 void H225_T38FaxAnnexbOnlyCaps::PrintOn(ostream & strm) const
8377 {
8378   int indent = strm.precision() + 2;
8379   strm << "{\n";
8380   if (HasOptionalField(e_nonStandardData))
8381     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8382   if (HasOptionalField(e_dataRatesSupported))
8383     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8384   strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8385   strm << setw(indent+17) << "t38FaxProtocol = " << setprecision(indent) << m_t38FaxProtocol << '\n';
8386   strm << setw(indent+16) << "t38FaxProfile = " << setprecision(indent) << m_t38FaxProfile << '\n';
8387   strm << setw(indent-1) << setprecision(indent-2) << "}";
8388 }
8389 #endif
8390
8391
8392 PObject::Comparison H225_T38FaxAnnexbOnlyCaps::Compare(const PObject & obj) const
8393 {
8394 #ifndef PASN_LEANANDMEAN
8395   PAssert(PIsDescendant(&obj, H225_T38FaxAnnexbOnlyCaps), PInvalidCast);
8396 #endif
8397   const H225_T38FaxAnnexbOnlyCaps & other = (const H225_T38FaxAnnexbOnlyCaps &)obj;
8398
8399   Comparison result;
8400
8401   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8402     return result;
8403   if ((result = m_dataRatesSupported.Compare(other.m_dataRatesSupported)) != EqualTo)
8404     return result;
8405   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
8406     return result;
8407   if ((result = m_t38FaxProtocol.Compare(other.m_t38FaxProtocol)) != EqualTo)
8408     return result;
8409   if ((result = m_t38FaxProfile.Compare(other.m_t38FaxProfile)) != EqualTo)
8410     return result;
8411
8412   return PASN_Sequence::Compare(other);
8413 }
8414
8415
8416 PINDEX H225_T38FaxAnnexbOnlyCaps::GetDataLength() const
8417 {
8418   PINDEX length = 0;
8419   if (HasOptionalField(e_nonStandardData))
8420     length += m_nonStandardData.GetObjectLength();
8421   if (HasOptionalField(e_dataRatesSupported))
8422     length += m_dataRatesSupported.GetObjectLength();
8423   length += m_supportedPrefixes.GetObjectLength();
8424   length += m_t38FaxProtocol.GetObjectLength();
8425   length += m_t38FaxProfile.GetObjectLength();
8426   return length;
8427 }
8428
8429
8430 BOOL H225_T38FaxAnnexbOnlyCaps::Decode(PASN_Stream & strm)
8431 {
8432   if (!PreambleDecode(strm))
8433     return FALSE;
8434
8435   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8436     return FALSE;
8437   if (HasOptionalField(e_dataRatesSupported) && !m_dataRatesSupported.Decode(strm))
8438     return FALSE;
8439   if (!m_supportedPrefixes.Decode(strm))
8440     return FALSE;
8441   if (!m_t38FaxProtocol.Decode(strm))
8442     return FALSE;
8443   if (!m_t38FaxProfile.Decode(strm))
8444     return FALSE;
8445
8446   return UnknownExtensionsDecode(strm);
8447 }
8448
8449
8450 void H225_T38FaxAnnexbOnlyCaps::Encode(PASN_Stream & strm) const
8451 {
8452   PreambleEncode(strm);
8453
8454   if (HasOptionalField(e_nonStandardData))
8455     m_nonStandardData.Encode(strm);
8456   if (HasOptionalField(e_dataRatesSupported))
8457     m_dataRatesSupported.Encode(strm);
8458   m_supportedPrefixes.Encode(strm);
8459   m_t38FaxProtocol.Encode(strm);
8460   m_t38FaxProfile.Encode(strm);
8461
8462   UnknownExtensionsEncode(strm);
8463 }
8464
8465
8466 PObject * H225_T38FaxAnnexbOnlyCaps::Clone() const
8467 {
8468 #ifndef PASN_LEANANDMEAN
8469   PAssert(IsClass(H225_T38FaxAnnexbOnlyCaps::Class()), PInvalidCast);
8470 #endif
8471   return new H225_T38FaxAnnexbOnlyCaps(*this);
8472 }
8473
8474
8475 //
8476 // SIPCaps
8477 //
8478
8479 H225_SIPCaps::H225_SIPCaps(unsigned tag, PASN_Object::TagClass tagClass)
8480   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
8481 {
8482 }
8483
8484
8485 #ifndef PASN_NOPRINTON
8486 void H225_SIPCaps::PrintOn(ostream & strm) const
8487 {
8488   int indent = strm.precision() + 2;
8489   strm << "{\n";
8490   if (HasOptionalField(e_nonStandardData))
8491     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8492   if (HasOptionalField(e_dataRatesSupported))
8493     strm << setw(indent+21) << "dataRatesSupported = " << setprecision(indent) << m_dataRatesSupported << '\n';
8494   if (HasOptionalField(e_supportedPrefixes))
8495     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
8496   strm << setw(indent-1) << setprecision(indent-2) << "}";
8497 }
8498 #endif
8499
8500
8501 PObject::Comparison H225_SIPCaps::Compare(const PObject & obj) const
8502 {
8503 #ifndef PASN_LEANANDMEAN
8504   PAssert(PIsDescendant(&obj, H225_SIPCaps), PInvalidCast);
8505 #endif
8506   const H225_SIPCaps & other = (const H225_SIPCaps &)obj;
8507
8508   Comparison result;
8509
8510   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8511     return result;
8512   if ((result = m_dataRatesSupported.Compare(other.m_dataRatesSupported)) != EqualTo)
8513     return result;
8514   if ((result = m_supportedPrefixes.Compare(other.m_supportedPrefixes)) != EqualTo)
8515     return result;
8516
8517   return PASN_Sequence::Compare(other);
8518 }
8519
8520
8521 PINDEX H225_SIPCaps::GetDataLength() const
8522 {
8523   PINDEX length = 0;
8524   if (HasOptionalField(e_nonStandardData))
8525     length += m_nonStandardData.GetObjectLength();
8526   if (HasOptionalField(e_dataRatesSupported))
8527     length += m_dataRatesSupported.GetObjectLength();
8528   if (HasOptionalField(e_supportedPrefixes))
8529     length += m_supportedPrefixes.GetObjectLength();
8530   return length;
8531 }
8532
8533
8534 BOOL H225_SIPCaps::Decode(PASN_Stream & strm)
8535 {
8536   if (!PreambleDecode(strm))
8537     return FALSE;
8538
8539   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8540     return FALSE;
8541   if (HasOptionalField(e_dataRatesSupported) && !m_dataRatesSupported.Decode(strm))
8542     return FALSE;
8543   if (HasOptionalField(e_supportedPrefixes) && !m_supportedPrefixes.Decode(strm))
8544     return FALSE;
8545
8546   return UnknownExtensionsDecode(strm);
8547 }
8548
8549
8550 void H225_SIPCaps::Encode(PASN_Stream & strm) const
8551 {
8552   PreambleEncode(strm);
8553
8554   if (HasOptionalField(e_nonStandardData))
8555     m_nonStandardData.Encode(strm);
8556   if (HasOptionalField(e_dataRatesSupported))
8557     m_dataRatesSupported.Encode(strm);
8558   if (HasOptionalField(e_supportedPrefixes))
8559     m_supportedPrefixes.Encode(strm);
8560
8561   UnknownExtensionsEncode(strm);
8562 }
8563
8564
8565 PObject * H225_SIPCaps::Clone() const
8566 {
8567 #ifndef PASN_LEANANDMEAN
8568   PAssert(IsClass(H225_SIPCaps::Class()), PInvalidCast);
8569 #endif
8570   return new H225_SIPCaps(*this);
8571 }
8572
8573
8574 //
8575 // McuInfo
8576 //
8577
8578 H225_McuInfo::H225_McuInfo(unsigned tag, PASN_Object::TagClass tagClass)
8579   : PASN_Sequence(tag, tagClass, 1, TRUE, 1)
8580 {
8581 }
8582
8583
8584 #ifndef PASN_NOPRINTON
8585 void H225_McuInfo::PrintOn(ostream & strm) const
8586 {
8587   int indent = strm.precision() + 2;
8588   strm << "{\n";
8589   if (HasOptionalField(e_nonStandardData))
8590     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8591   if (HasOptionalField(e_protocol))
8592     strm << setw(indent+11) << "protocol = " << setprecision(indent) << m_protocol << '\n';
8593   strm << setw(indent-1) << setprecision(indent-2) << "}";
8594 }
8595 #endif
8596
8597
8598 PObject::Comparison H225_McuInfo::Compare(const PObject & obj) const
8599 {
8600 #ifndef PASN_LEANANDMEAN
8601   PAssert(PIsDescendant(&obj, H225_McuInfo), PInvalidCast);
8602 #endif
8603   const H225_McuInfo & other = (const H225_McuInfo &)obj;
8604
8605   Comparison result;
8606
8607   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8608     return result;
8609
8610   return PASN_Sequence::Compare(other);
8611 }
8612
8613
8614 PINDEX H225_McuInfo::GetDataLength() const
8615 {
8616   PINDEX length = 0;
8617   if (HasOptionalField(e_nonStandardData))
8618     length += m_nonStandardData.GetObjectLength();
8619   return length;
8620 }
8621
8622
8623 BOOL H225_McuInfo::Decode(PASN_Stream & strm)
8624 {
8625   if (!PreambleDecode(strm))
8626     return FALSE;
8627
8628   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8629     return FALSE;
8630   if (!KnownExtensionDecode(strm, e_protocol, m_protocol))
8631     return FALSE;
8632
8633   return UnknownExtensionsDecode(strm);
8634 }
8635
8636
8637 void H225_McuInfo::Encode(PASN_Stream & strm) const
8638 {
8639   PreambleEncode(strm);
8640
8641   if (HasOptionalField(e_nonStandardData))
8642     m_nonStandardData.Encode(strm);
8643   KnownExtensionEncode(strm, e_protocol, m_protocol);
8644
8645   UnknownExtensionsEncode(strm);
8646 }
8647
8648
8649 PObject * H225_McuInfo::Clone() const
8650 {
8651 #ifndef PASN_LEANANDMEAN
8652   PAssert(IsClass(H225_McuInfo::Class()), PInvalidCast);
8653 #endif
8654   return new H225_McuInfo(*this);
8655 }
8656
8657
8658 //
8659 // TerminalInfo
8660 //
8661
8662 H225_TerminalInfo::H225_TerminalInfo(unsigned tag, PASN_Object::TagClass tagClass)
8663   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8664 {
8665 }
8666
8667
8668 #ifndef PASN_NOPRINTON
8669 void H225_TerminalInfo::PrintOn(ostream & strm) const
8670 {
8671   int indent = strm.precision() + 2;
8672   strm << "{\n";
8673   if (HasOptionalField(e_nonStandardData))
8674     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8675   strm << setw(indent-1) << setprecision(indent-2) << "}";
8676 }
8677 #endif
8678
8679
8680 PObject::Comparison H225_TerminalInfo::Compare(const PObject & obj) const
8681 {
8682 #ifndef PASN_LEANANDMEAN
8683   PAssert(PIsDescendant(&obj, H225_TerminalInfo), PInvalidCast);
8684 #endif
8685   const H225_TerminalInfo & other = (const H225_TerminalInfo &)obj;
8686
8687   Comparison result;
8688
8689   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8690     return result;
8691
8692   return PASN_Sequence::Compare(other);
8693 }
8694
8695
8696 PINDEX H225_TerminalInfo::GetDataLength() const
8697 {
8698   PINDEX length = 0;
8699   if (HasOptionalField(e_nonStandardData))
8700     length += m_nonStandardData.GetObjectLength();
8701   return length;
8702 }
8703
8704
8705 BOOL H225_TerminalInfo::Decode(PASN_Stream & strm)
8706 {
8707   if (!PreambleDecode(strm))
8708     return FALSE;
8709
8710   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8711     return FALSE;
8712
8713   return UnknownExtensionsDecode(strm);
8714 }
8715
8716
8717 void H225_TerminalInfo::Encode(PASN_Stream & strm) const
8718 {
8719   PreambleEncode(strm);
8720
8721   if (HasOptionalField(e_nonStandardData))
8722     m_nonStandardData.Encode(strm);
8723
8724   UnknownExtensionsEncode(strm);
8725 }
8726
8727
8728 PObject * H225_TerminalInfo::Clone() const
8729 {
8730 #ifndef PASN_LEANANDMEAN
8731   PAssert(IsClass(H225_TerminalInfo::Class()), PInvalidCast);
8732 #endif
8733   return new H225_TerminalInfo(*this);
8734 }
8735
8736
8737 //
8738 // GatekeeperInfo
8739 //
8740
8741 H225_GatekeeperInfo::H225_GatekeeperInfo(unsigned tag, PASN_Object::TagClass tagClass)
8742   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
8743 {
8744 }
8745
8746
8747 #ifndef PASN_NOPRINTON
8748 void H225_GatekeeperInfo::PrintOn(ostream & strm) const
8749 {
8750   int indent = strm.precision() + 2;
8751   strm << "{\n";
8752   if (HasOptionalField(e_nonStandardData))
8753     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
8754   strm << setw(indent-1) << setprecision(indent-2) << "}";
8755 }
8756 #endif
8757
8758
8759 PObject::Comparison H225_GatekeeperInfo::Compare(const PObject & obj) const
8760 {
8761 #ifndef PASN_LEANANDMEAN
8762   PAssert(PIsDescendant(&obj, H225_GatekeeperInfo), PInvalidCast);
8763 #endif
8764   const H225_GatekeeperInfo & other = (const H225_GatekeeperInfo &)obj;
8765
8766   Comparison result;
8767
8768   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
8769     return result;
8770
8771   return PASN_Sequence::Compare(other);
8772 }
8773
8774
8775 PINDEX H225_GatekeeperInfo::GetDataLength() const
8776 {
8777   PINDEX length = 0;
8778   if (HasOptionalField(e_nonStandardData))
8779     length += m_nonStandardData.GetObjectLength();
8780   return length;
8781 }
8782
8783
8784 BOOL H225_GatekeeperInfo::Decode(PASN_Stream & strm)
8785 {
8786   if (!PreambleDecode(strm))
8787     return FALSE;
8788
8789   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
8790     return FALSE;
8791
8792   return UnknownExtensionsDecode(strm);
8793 }
8794
8795
8796 void H225_GatekeeperInfo::Encode(PASN_Stream & strm) const
8797 {
8798   PreambleEncode(strm);
8799
8800   if (HasOptionalField(e_nonStandardData))
8801     m_nonStandardData.Encode(strm);
8802
8803   UnknownExtensionsEncode(strm);
8804 }
8805
8806
8807 PObject * H225_GatekeeperInfo::Clone() const
8808 {
8809 #ifndef PASN_LEANANDMEAN
8810   PAssert(IsClass(H225_GatekeeperInfo::Class()), PInvalidCast);
8811 #endif
8812   return new H225_GatekeeperInfo(*this);
8813 }
8814
8815
8816 //
8817 // FeatureDescriptor
8818 //
8819
8820 H225_FeatureDescriptor::H225_FeatureDescriptor(unsigned tag, PASN_Object::TagClass tagClass)
8821   : H225_GenericData(tag, tagClass)
8822 {
8823 }
8824
8825
8826 PObject * H225_FeatureDescriptor::Clone() const
8827 {
8828 #ifndef PASN_LEANANDMEAN
8829   PAssert(IsClass(H225_FeatureDescriptor::Class()), PInvalidCast);
8830 #endif
8831   return new H225_FeatureDescriptor(*this);
8832 }
8833
8834
8835 //
8836 // CallCapacity
8837 //
8838
8839 H225_CallCapacity::H225_CallCapacity(unsigned tag, PASN_Object::TagClass tagClass)
8840   : PASN_Sequence(tag, tagClass, 2, TRUE, 0)
8841 {
8842 }
8843
8844
8845 #ifndef PASN_NOPRINTON
8846 void H225_CallCapacity::PrintOn(ostream & strm) const
8847 {
8848   int indent = strm.precision() + 2;
8849   strm << "{\n";
8850   if (HasOptionalField(e_maximumCallCapacity))
8851     strm << setw(indent+22) << "maximumCallCapacity = " << setprecision(indent) << m_maximumCallCapacity << '\n';
8852   if (HasOptionalField(e_currentCallCapacity))
8853     strm << setw(indent+22) << "currentCallCapacity = " << setprecision(indent) << m_currentCallCapacity << '\n';
8854   strm << setw(indent-1) << setprecision(indent-2) << "}";
8855 }
8856 #endif
8857
8858
8859 PObject::Comparison H225_CallCapacity::Compare(const PObject & obj) const
8860 {
8861 #ifndef PASN_LEANANDMEAN
8862   PAssert(PIsDescendant(&obj, H225_CallCapacity), PInvalidCast);
8863 #endif
8864   const H225_CallCapacity & other = (const H225_CallCapacity &)obj;
8865
8866   Comparison result;
8867
8868   if ((result = m_maximumCallCapacity.Compare(other.m_maximumCallCapacity)) != EqualTo)
8869     return result;
8870   if ((result = m_currentCallCapacity.Compare(other.m_currentCallCapacity)) != EqualTo)
8871     return result;
8872
8873   return PASN_Sequence::Compare(other);
8874 }
8875
8876
8877 PINDEX H225_CallCapacity::GetDataLength() const
8878 {
8879   PINDEX length = 0;
8880   if (HasOptionalField(e_maximumCallCapacity))
8881     length += m_maximumCallCapacity.GetObjectLength();
8882   if (HasOptionalField(e_currentCallCapacity))
8883     length += m_currentCallCapacity.GetObjectLength();
8884   return length;
8885 }
8886
8887
8888 BOOL H225_CallCapacity::Decode(PASN_Stream & strm)
8889 {
8890   if (!PreambleDecode(strm))
8891     return FALSE;
8892
8893   if (HasOptionalField(e_maximumCallCapacity) && !m_maximumCallCapacity.Decode(strm))
8894     return FALSE;
8895   if (HasOptionalField(e_currentCallCapacity) && !m_currentCallCapacity.Decode(strm))
8896     return FALSE;
8897
8898   return UnknownExtensionsDecode(strm);
8899 }
8900
8901
8902 void H225_CallCapacity::Encode(PASN_Stream & strm) const
8903 {
8904   PreambleEncode(strm);
8905
8906   if (HasOptionalField(e_maximumCallCapacity))
8907     m_maximumCallCapacity.Encode(strm);
8908   if (HasOptionalField(e_currentCallCapacity))
8909     m_currentCallCapacity.Encode(strm);
8910
8911   UnknownExtensionsEncode(strm);
8912 }
8913
8914
8915 PObject * H225_CallCapacity::Clone() const
8916 {
8917 #ifndef PASN_LEANANDMEAN
8918   PAssert(IsClass(H225_CallCapacity::Class()), PInvalidCast);
8919 #endif
8920   return new H225_CallCapacity(*this);
8921 }
8922
8923
8924 //
8925 // CircuitIdentifier
8926 //
8927
8928 H225_CircuitIdentifier::H225_CircuitIdentifier(unsigned tag, PASN_Object::TagClass tagClass)
8929   : PASN_Sequence(tag, tagClass, 2, TRUE, 1)
8930 {
8931 }
8932
8933
8934 #ifndef PASN_NOPRINTON
8935 void H225_CircuitIdentifier::PrintOn(ostream & strm) const
8936 {
8937   int indent = strm.precision() + 2;
8938   strm << "{\n";
8939   if (HasOptionalField(e_cic))
8940     strm << setw(indent+6) << "cic = " << setprecision(indent) << m_cic << '\n';
8941   if (HasOptionalField(e_group))
8942     strm << setw(indent+8) << "group = " << setprecision(indent) << m_group << '\n';
8943   if (HasOptionalField(e_carrier))
8944     strm << setw(indent+10) << "carrier = " << setprecision(indent) << m_carrier << '\n';
8945   strm << setw(indent-1) << setprecision(indent-2) << "}";
8946 }
8947 #endif
8948
8949
8950 PObject::Comparison H225_CircuitIdentifier::Compare(const PObject & obj) const
8951 {
8952 #ifndef PASN_LEANANDMEAN
8953   PAssert(PIsDescendant(&obj, H225_CircuitIdentifier), PInvalidCast);
8954 #endif
8955   const H225_CircuitIdentifier & other = (const H225_CircuitIdentifier &)obj;
8956
8957   Comparison result;
8958
8959   if ((result = m_cic.Compare(other.m_cic)) != EqualTo)
8960     return result;
8961   if ((result = m_group.Compare(other.m_group)) != EqualTo)
8962     return result;
8963
8964   return PASN_Sequence::Compare(other);
8965 }
8966
8967
8968 PINDEX H225_CircuitIdentifier::GetDataLength() const
8969 {
8970   PINDEX length = 0;
8971   if (HasOptionalField(e_cic))
8972     length += m_cic.GetObjectLength();
8973   if (HasOptionalField(e_group))
8974     length += m_group.GetObjectLength();
8975   return length;
8976 }
8977
8978
8979 BOOL H225_CircuitIdentifier::Decode(PASN_Stream & strm)
8980 {
8981   if (!PreambleDecode(strm))
8982     return FALSE;
8983
8984   if (HasOptionalField(e_cic) && !m_cic.Decode(strm))
8985     return FALSE;
8986   if (HasOptionalField(e_group) && !m_group.Decode(strm))
8987     return FALSE;
8988   if (!KnownExtensionDecode(strm, e_carrier, m_carrier))
8989     return FALSE;
8990
8991   return UnknownExtensionsDecode(strm);
8992 }
8993
8994
8995 void H225_CircuitIdentifier::Encode(PASN_Stream & strm) const
8996 {
8997   PreambleEncode(strm);
8998
8999   if (HasOptionalField(e_cic))
9000     m_cic.Encode(strm);
9001   if (HasOptionalField(e_group))
9002     m_group.Encode(strm);
9003   KnownExtensionEncode(strm, e_carrier, m_carrier);
9004
9005   UnknownExtensionsEncode(strm);
9006 }
9007
9008
9009 PObject * H225_CircuitIdentifier::Clone() const
9010 {
9011 #ifndef PASN_LEANANDMEAN
9012   PAssert(IsClass(H225_CircuitIdentifier::Class()), PInvalidCast);
9013 #endif
9014   return new H225_CircuitIdentifier(*this);
9015 }
9016
9017
9018 //
9019 // RegistrationConfirm
9020 //
9021
9022 H225_RegistrationConfirm::H225_RegistrationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
9023   : PASN_Sequence(tag, tagClass, 3, TRUE, 20)
9024 {
9025   IncludeOptionalField(e_willRespondToIRR);
9026   IncludeOptionalField(e_maintainConnection);
9027 }
9028
9029
9030 #ifndef PASN_NOPRINTON
9031 void H225_RegistrationConfirm::PrintOn(ostream & strm) const
9032 {
9033   int indent = strm.precision() + 2;
9034   strm << "{\n";
9035   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
9036   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
9037   if (HasOptionalField(e_nonStandardData))
9038     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9039   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
9040   if (HasOptionalField(e_terminalAlias))
9041     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
9042   if (HasOptionalField(e_gatekeeperIdentifier))
9043     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
9044   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
9045   if (HasOptionalField(e_alternateGatekeeper))
9046     strm << setw(indent+22) << "alternateGatekeeper = " << setprecision(indent) << m_alternateGatekeeper << '\n';
9047   if (HasOptionalField(e_timeToLive))
9048     strm << setw(indent+13) << "timeToLive = " << setprecision(indent) << m_timeToLive << '\n';
9049   if (HasOptionalField(e_tokens))
9050     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
9051   if (HasOptionalField(e_cryptoTokens))
9052     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
9053   if (HasOptionalField(e_integrityCheckValue))
9054     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
9055   if (HasOptionalField(e_willRespondToIRR))
9056     strm << setw(indent+19) << "willRespondToIRR = " << setprecision(indent) << m_willRespondToIRR << '\n';
9057   if (HasOptionalField(e_preGrantedARQ))
9058     strm << setw(indent+16) << "preGrantedARQ = " << setprecision(indent) << m_preGrantedARQ << '\n';
9059   if (HasOptionalField(e_maintainConnection))
9060     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
9061   if (HasOptionalField(e_serviceControl))
9062     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
9063   if (HasOptionalField(e_supportsAdditiveRegistration))
9064     strm << setw(indent+31) << "supportsAdditiveRegistration = " << setprecision(indent) << m_supportsAdditiveRegistration << '\n';
9065   if (HasOptionalField(e_terminalAliasPattern))
9066     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
9067   if (HasOptionalField(e_supportedPrefixes))
9068     strm << setw(indent+20) << "supportedPrefixes = " << setprecision(indent) << m_supportedPrefixes << '\n';
9069   if (HasOptionalField(e_usageSpec))
9070     strm << setw(indent+12) << "usageSpec = " << setprecision(indent) << m_usageSpec << '\n';
9071   if (HasOptionalField(e_featureServerAlias))
9072     strm << setw(indent+21) << "featureServerAlias = " << setprecision(indent) << m_featureServerAlias << '\n';
9073   if (HasOptionalField(e_capacityReportingSpec))
9074     strm << setw(indent+24) << "capacityReportingSpec = " << setprecision(indent) << m_capacityReportingSpec << '\n';
9075   if (HasOptionalField(e_featureSet))
9076     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
9077   if (HasOptionalField(e_genericData))
9078     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
9079   if (HasOptionalField(e_assignedGatekeeper))
9080     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
9081   if (HasOptionalField(e_rehomingModel))
9082     strm << setw(indent+16) << "rehomingModel = " << setprecision(indent) << m_rehomingModel << '\n';
9083   if (HasOptionalField(e_transportQOS))
9084     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
9085   strm << setw(indent-1) << setprecision(indent-2) << "}";
9086 }
9087 #endif
9088
9089
9090 PObject::Comparison H225_RegistrationConfirm::Compare(const PObject & obj) const
9091 {
9092 #ifndef PASN_LEANANDMEAN
9093   PAssert(PIsDescendant(&obj, H225_RegistrationConfirm), PInvalidCast);
9094 #endif
9095   const H225_RegistrationConfirm & other = (const H225_RegistrationConfirm &)obj;
9096
9097   Comparison result;
9098
9099   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
9100     return result;
9101   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
9102     return result;
9103   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
9104     return result;
9105   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
9106     return result;
9107   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
9108     return result;
9109   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
9110     return result;
9111   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
9112     return result;
9113
9114   return PASN_Sequence::Compare(other);
9115 }
9116
9117
9118 PINDEX H225_RegistrationConfirm::GetDataLength() const
9119 {
9120   PINDEX length = 0;
9121   length += m_requestSeqNum.GetObjectLength();
9122   length += m_protocolIdentifier.GetObjectLength();
9123   if (HasOptionalField(e_nonStandardData))
9124     length += m_nonStandardData.GetObjectLength();
9125   length += m_callSignalAddress.GetObjectLength();
9126   if (HasOptionalField(e_terminalAlias))
9127     length += m_terminalAlias.GetObjectLength();
9128   if (HasOptionalField(e_gatekeeperIdentifier))
9129     length += m_gatekeeperIdentifier.GetObjectLength();
9130   length += m_endpointIdentifier.GetObjectLength();
9131   return length;
9132 }
9133
9134
9135 BOOL H225_RegistrationConfirm::Decode(PASN_Stream & strm)
9136 {
9137   if (!PreambleDecode(strm))
9138     return FALSE;
9139
9140   if (!m_requestSeqNum.Decode(strm))
9141     return FALSE;
9142   if (!m_protocolIdentifier.Decode(strm))
9143     return FALSE;
9144   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
9145     return FALSE;
9146   if (!m_callSignalAddress.Decode(strm))
9147     return FALSE;
9148   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
9149     return FALSE;
9150   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
9151     return FALSE;
9152   if (!m_endpointIdentifier.Decode(strm))
9153     return FALSE;
9154   if (!KnownExtensionDecode(strm, e_alternateGatekeeper, m_alternateGatekeeper))
9155     return FALSE;
9156   if (!KnownExtensionDecode(strm, e_timeToLive, m_timeToLive))
9157     return FALSE;
9158   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
9159     return FALSE;
9160   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
9161     return FALSE;
9162   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
9163     return FALSE;
9164   if (!KnownExtensionDecode(strm, e_willRespondToIRR, m_willRespondToIRR))
9165     return FALSE;
9166   if (!KnownExtensionDecode(strm, e_preGrantedARQ, m_preGrantedARQ))
9167     return FALSE;
9168   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
9169     return FALSE;
9170   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
9171     return FALSE;
9172   if (!KnownExtensionDecode(strm, e_supportsAdditiveRegistration, m_supportsAdditiveRegistration))
9173     return FALSE;
9174   if (!KnownExtensionDecode(strm, e_terminalAliasPattern, m_terminalAliasPattern))
9175     return FALSE;
9176   if (!KnownExtensionDecode(strm, e_supportedPrefixes, m_supportedPrefixes))
9177     return FALSE;
9178   if (!KnownExtensionDecode(strm, e_usageSpec, m_usageSpec))
9179     return FALSE;
9180   if (!KnownExtensionDecode(strm, e_featureServerAlias, m_featureServerAlias))
9181     return FALSE;
9182   if (!KnownExtensionDecode(strm, e_capacityReportingSpec, m_capacityReportingSpec))
9183     return FALSE;
9184   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
9185     return FALSE;
9186   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
9187     return FALSE;
9188   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
9189     return FALSE;
9190   if (!KnownExtensionDecode(strm, e_rehomingModel, m_rehomingModel))
9191     return FALSE;
9192   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
9193     return FALSE;
9194
9195   return UnknownExtensionsDecode(strm);
9196 }
9197
9198
9199 void H225_RegistrationConfirm::Encode(PASN_Stream & strm) const
9200 {
9201   PreambleEncode(strm);
9202
9203   m_requestSeqNum.Encode(strm);
9204   m_protocolIdentifier.Encode(strm);
9205   if (HasOptionalField(e_nonStandardData))
9206     m_nonStandardData.Encode(strm);
9207   m_callSignalAddress.Encode(strm);
9208   if (HasOptionalField(e_terminalAlias))
9209     m_terminalAlias.Encode(strm);
9210   if (HasOptionalField(e_gatekeeperIdentifier))
9211     m_gatekeeperIdentifier.Encode(strm);
9212   m_endpointIdentifier.Encode(strm);
9213   KnownExtensionEncode(strm, e_alternateGatekeeper, m_alternateGatekeeper);
9214   KnownExtensionEncode(strm, e_timeToLive, m_timeToLive);
9215   KnownExtensionEncode(strm, e_tokens, m_tokens);
9216   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
9217   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
9218   KnownExtensionEncode(strm, e_willRespondToIRR, m_willRespondToIRR);
9219   KnownExtensionEncode(strm, e_preGrantedARQ, m_preGrantedARQ);
9220   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
9221   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
9222   KnownExtensionEncode(strm, e_supportsAdditiveRegistration, m_supportsAdditiveRegistration);
9223   KnownExtensionEncode(strm, e_terminalAliasPattern, m_terminalAliasPattern);
9224   KnownExtensionEncode(strm, e_supportedPrefixes, m_supportedPrefixes);
9225   KnownExtensionEncode(strm, e_usageSpec, m_usageSpec);
9226   KnownExtensionEncode(strm, e_featureServerAlias, m_featureServerAlias);
9227   KnownExtensionEncode(strm, e_capacityReportingSpec, m_capacityReportingSpec);
9228   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
9229   KnownExtensionEncode(strm, e_genericData, m_genericData);
9230   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
9231   KnownExtensionEncode(strm, e_rehomingModel, m_rehomingModel);
9232   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
9233
9234   UnknownExtensionsEncode(strm);
9235 }
9236
9237
9238 PObject * H225_RegistrationConfirm::Clone() const
9239 {
9240 #ifndef PASN_LEANANDMEAN
9241   PAssert(IsClass(H225_RegistrationConfirm::Class()), PInvalidCast);
9242 #endif
9243   return new H225_RegistrationConfirm(*this);
9244 }
9245
9246
9247 //
9248 // BandwidthRequest
9249 //
9250
9251 H225_BandwidthRequest::H225_BandwidthRequest(unsigned tag, PASN_Object::TagClass tagClass)
9252   : PASN_Sequence(tag, tagClass, 2, TRUE, 12)
9253 {
9254   IncludeOptionalField(e_callIdentifier);
9255   IncludeOptionalField(e_answeredCall);
9256 }
9257
9258
9259 #ifndef PASN_NOPRINTON
9260 void H225_BandwidthRequest::PrintOn(ostream & strm) const
9261 {
9262   int indent = strm.precision() + 2;
9263   strm << "{\n";
9264   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
9265   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
9266   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
9267   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
9268   if (HasOptionalField(e_callType))
9269     strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
9270   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
9271   if (HasOptionalField(e_nonStandardData))
9272     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9273   if (HasOptionalField(e_callIdentifier))
9274     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
9275   if (HasOptionalField(e_gatekeeperIdentifier))
9276     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
9277   if (HasOptionalField(e_tokens))
9278     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
9279   if (HasOptionalField(e_cryptoTokens))
9280     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
9281   if (HasOptionalField(e_integrityCheckValue))
9282     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
9283   if (HasOptionalField(e_answeredCall))
9284     strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
9285   if (HasOptionalField(e_callLinkage))
9286     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
9287   if (HasOptionalField(e_capacity))
9288     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
9289   if (HasOptionalField(e_usageInformation))
9290     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
9291   if (HasOptionalField(e_bandwidthDetails))
9292     strm << setw(indent+19) << "bandwidthDetails = " << setprecision(indent) << m_bandwidthDetails << '\n';
9293   if (HasOptionalField(e_genericData))
9294     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
9295   if (HasOptionalField(e_transportQOS))
9296     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
9297   strm << setw(indent-1) << setprecision(indent-2) << "}";
9298 }
9299 #endif
9300
9301
9302 PObject::Comparison H225_BandwidthRequest::Compare(const PObject & obj) const
9303 {
9304 #ifndef PASN_LEANANDMEAN
9305   PAssert(PIsDescendant(&obj, H225_BandwidthRequest), PInvalidCast);
9306 #endif
9307   const H225_BandwidthRequest & other = (const H225_BandwidthRequest &)obj;
9308
9309   Comparison result;
9310
9311   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
9312     return result;
9313   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
9314     return result;
9315   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
9316     return result;
9317   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
9318     return result;
9319   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
9320     return result;
9321   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
9322     return result;
9323   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
9324     return result;
9325
9326   return PASN_Sequence::Compare(other);
9327 }
9328
9329
9330 PINDEX H225_BandwidthRequest::GetDataLength() const
9331 {
9332   PINDEX length = 0;
9333   length += m_requestSeqNum.GetObjectLength();
9334   length += m_endpointIdentifier.GetObjectLength();
9335   length += m_conferenceID.GetObjectLength();
9336   length += m_callReferenceValue.GetObjectLength();
9337   if (HasOptionalField(e_callType))
9338     length += m_callType.GetObjectLength();
9339   length += m_bandWidth.GetObjectLength();
9340   if (HasOptionalField(e_nonStandardData))
9341     length += m_nonStandardData.GetObjectLength();
9342   return length;
9343 }
9344
9345
9346 BOOL H225_BandwidthRequest::Decode(PASN_Stream & strm)
9347 {
9348   if (!PreambleDecode(strm))
9349     return FALSE;
9350
9351   if (!m_requestSeqNum.Decode(strm))
9352     return FALSE;
9353   if (!m_endpointIdentifier.Decode(strm))
9354     return FALSE;
9355   if (!m_conferenceID.Decode(strm))
9356     return FALSE;
9357   if (!m_callReferenceValue.Decode(strm))
9358     return FALSE;
9359   if (HasOptionalField(e_callType) && !m_callType.Decode(strm))
9360     return FALSE;
9361   if (!m_bandWidth.Decode(strm))
9362     return FALSE;
9363   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
9364     return FALSE;
9365   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
9366     return FALSE;
9367   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
9368     return FALSE;
9369   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
9370     return FALSE;
9371   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
9372     return FALSE;
9373   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
9374     return FALSE;
9375   if (!KnownExtensionDecode(strm, e_answeredCall, m_answeredCall))
9376     return FALSE;
9377   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
9378     return FALSE;
9379   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
9380     return FALSE;
9381   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
9382     return FALSE;
9383   if (!KnownExtensionDecode(strm, e_bandwidthDetails, m_bandwidthDetails))
9384     return FALSE;
9385   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
9386     return FALSE;
9387   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
9388     return FALSE;
9389
9390   return UnknownExtensionsDecode(strm);
9391 }
9392
9393
9394 void H225_BandwidthRequest::Encode(PASN_Stream & strm) const
9395 {
9396   PreambleEncode(strm);
9397
9398   m_requestSeqNum.Encode(strm);
9399   m_endpointIdentifier.Encode(strm);
9400   m_conferenceID.Encode(strm);
9401   m_callReferenceValue.Encode(strm);
9402   if (HasOptionalField(e_callType))
9403     m_callType.Encode(strm);
9404   m_bandWidth.Encode(strm);
9405   if (HasOptionalField(e_nonStandardData))
9406     m_nonStandardData.Encode(strm);
9407   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
9408   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
9409   KnownExtensionEncode(strm, e_tokens, m_tokens);
9410   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
9411   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
9412   KnownExtensionEncode(strm, e_answeredCall, m_answeredCall);
9413   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
9414   KnownExtensionEncode(strm, e_capacity, m_capacity);
9415   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
9416   KnownExtensionEncode(strm, e_bandwidthDetails, m_bandwidthDetails);
9417   KnownExtensionEncode(strm, e_genericData, m_genericData);
9418   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
9419
9420   UnknownExtensionsEncode(strm);
9421 }
9422
9423
9424 PObject * H225_BandwidthRequest::Clone() const
9425 {
9426 #ifndef PASN_LEANANDMEAN
9427   PAssert(IsClass(H225_BandwidthRequest::Class()), PInvalidCast);
9428 #endif
9429   return new H225_BandwidthRequest(*this);
9430 }
9431
9432
9433 //
9434 // BandwidthConfirm
9435 //
9436
9437 H225_BandwidthConfirm::H225_BandwidthConfirm(unsigned tag, PASN_Object::TagClass tagClass)
9438   : PASN_Sequence(tag, tagClass, 1, TRUE, 6)
9439 {
9440 }
9441
9442
9443 #ifndef PASN_NOPRINTON
9444 void H225_BandwidthConfirm::PrintOn(ostream & strm) const
9445 {
9446   int indent = strm.precision() + 2;
9447   strm << "{\n";
9448   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
9449   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
9450   if (HasOptionalField(e_nonStandardData))
9451     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9452   if (HasOptionalField(e_tokens))
9453     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
9454   if (HasOptionalField(e_cryptoTokens))
9455     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
9456   if (HasOptionalField(e_integrityCheckValue))
9457     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
9458   if (HasOptionalField(e_capacity))
9459     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
9460   if (HasOptionalField(e_genericData))
9461     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
9462   if (HasOptionalField(e_transportQOS))
9463     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
9464   strm << setw(indent-1) << setprecision(indent-2) << "}";
9465 }
9466 #endif
9467
9468
9469 PObject::Comparison H225_BandwidthConfirm::Compare(const PObject & obj) const
9470 {
9471 #ifndef PASN_LEANANDMEAN
9472   PAssert(PIsDescendant(&obj, H225_BandwidthConfirm), PInvalidCast);
9473 #endif
9474   const H225_BandwidthConfirm & other = (const H225_BandwidthConfirm &)obj;
9475
9476   Comparison result;
9477
9478   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
9479     return result;
9480   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
9481     return result;
9482   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
9483     return result;
9484
9485   return PASN_Sequence::Compare(other);
9486 }
9487
9488
9489 PINDEX H225_BandwidthConfirm::GetDataLength() const
9490 {
9491   PINDEX length = 0;
9492   length += m_requestSeqNum.GetObjectLength();
9493   length += m_bandWidth.GetObjectLength();
9494   if (HasOptionalField(e_nonStandardData))
9495     length += m_nonStandardData.GetObjectLength();
9496   return length;
9497 }
9498
9499
9500 BOOL H225_BandwidthConfirm::Decode(PASN_Stream & strm)
9501 {
9502   if (!PreambleDecode(strm))
9503     return FALSE;
9504
9505   if (!m_requestSeqNum.Decode(strm))
9506     return FALSE;
9507   if (!m_bandWidth.Decode(strm))
9508     return FALSE;
9509   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
9510     return FALSE;
9511   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
9512     return FALSE;
9513   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
9514     return FALSE;
9515   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
9516     return FALSE;
9517   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
9518     return FALSE;
9519   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
9520     return FALSE;
9521   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
9522     return FALSE;
9523
9524   return UnknownExtensionsDecode(strm);
9525 }
9526
9527
9528 void H225_BandwidthConfirm::Encode(PASN_Stream & strm) const
9529 {
9530   PreambleEncode(strm);
9531
9532   m_requestSeqNum.Encode(strm);
9533   m_bandWidth.Encode(strm);
9534   if (HasOptionalField(e_nonStandardData))
9535     m_nonStandardData.Encode(strm);
9536   KnownExtensionEncode(strm, e_tokens, m_tokens);
9537   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
9538   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
9539   KnownExtensionEncode(strm, e_capacity, m_capacity);
9540   KnownExtensionEncode(strm, e_genericData, m_genericData);
9541   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
9542
9543   UnknownExtensionsEncode(strm);
9544 }
9545
9546
9547 PObject * H225_BandwidthConfirm::Clone() const
9548 {
9549 #ifndef PASN_LEANANDMEAN
9550   PAssert(IsClass(H225_BandwidthConfirm::Class()), PInvalidCast);
9551 #endif
9552   return new H225_BandwidthConfirm(*this);
9553 }
9554
9555
9556 //
9557 // ResourcesAvailableIndicate
9558 //
9559
9560 H225_ResourcesAvailableIndicate::H225_ResourcesAvailableIndicate(unsigned tag, PASN_Object::TagClass tagClass)
9561   : PASN_Sequence(tag, tagClass, 4, TRUE, 2)
9562 {
9563 }
9564
9565
9566 #ifndef PASN_NOPRINTON
9567 void H225_ResourcesAvailableIndicate::PrintOn(ostream & strm) const
9568 {
9569   int indent = strm.precision() + 2;
9570   strm << "{\n";
9571   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
9572   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
9573   if (HasOptionalField(e_nonStandardData))
9574     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9575   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
9576   strm << setw(indent+12) << "protocols = " << setprecision(indent) << m_protocols << '\n';
9577   strm << setw(indent+23) << "almostOutOfResources = " << setprecision(indent) << m_almostOutOfResources << '\n';
9578   if (HasOptionalField(e_tokens))
9579     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
9580   if (HasOptionalField(e_cryptoTokens))
9581     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
9582   if (HasOptionalField(e_integrityCheckValue))
9583     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
9584   if (HasOptionalField(e_capacity))
9585     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
9586   if (HasOptionalField(e_genericData))
9587     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
9588   strm << setw(indent-1) << setprecision(indent-2) << "}";
9589 }
9590 #endif
9591
9592
9593 PObject::Comparison H225_ResourcesAvailableIndicate::Compare(const PObject & obj) const
9594 {
9595 #ifndef PASN_LEANANDMEAN
9596   PAssert(PIsDescendant(&obj, H225_ResourcesAvailableIndicate), PInvalidCast);
9597 #endif
9598   const H225_ResourcesAvailableIndicate & other = (const H225_ResourcesAvailableIndicate &)obj;
9599
9600   Comparison result;
9601
9602   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
9603     return result;
9604   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
9605     return result;
9606   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
9607     return result;
9608   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
9609     return result;
9610   if ((result = m_protocols.Compare(other.m_protocols)) != EqualTo)
9611     return result;
9612   if ((result = m_almostOutOfResources.Compare(other.m_almostOutOfResources)) != EqualTo)
9613     return result;
9614   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
9615     return result;
9616   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
9617     return result;
9618   if ((result = m_integrityCheckValue.Compare(other.m_integrityCheckValue)) != EqualTo)
9619     return result;
9620
9621   return PASN_Sequence::Compare(other);
9622 }
9623
9624
9625 PINDEX H225_ResourcesAvailableIndicate::GetDataLength() const
9626 {
9627   PINDEX length = 0;
9628   length += m_requestSeqNum.GetObjectLength();
9629   length += m_protocolIdentifier.GetObjectLength();
9630   if (HasOptionalField(e_nonStandardData))
9631     length += m_nonStandardData.GetObjectLength();
9632   length += m_endpointIdentifier.GetObjectLength();
9633   length += m_protocols.GetObjectLength();
9634   length += m_almostOutOfResources.GetObjectLength();
9635   if (HasOptionalField(e_tokens))
9636     length += m_tokens.GetObjectLength();
9637   if (HasOptionalField(e_cryptoTokens))
9638     length += m_cryptoTokens.GetObjectLength();
9639   if (HasOptionalField(e_integrityCheckValue))
9640     length += m_integrityCheckValue.GetObjectLength();
9641   return length;
9642 }
9643
9644
9645 BOOL H225_ResourcesAvailableIndicate::Decode(PASN_Stream & strm)
9646 {
9647   if (!PreambleDecode(strm))
9648     return FALSE;
9649
9650   if (!m_requestSeqNum.Decode(strm))
9651     return FALSE;
9652   if (!m_protocolIdentifier.Decode(strm))
9653     return FALSE;
9654   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
9655     return FALSE;
9656   if (!m_endpointIdentifier.Decode(strm))
9657     return FALSE;
9658   if (!m_protocols.Decode(strm))
9659     return FALSE;
9660   if (!m_almostOutOfResources.Decode(strm))
9661     return FALSE;
9662   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
9663     return FALSE;
9664   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
9665     return FALSE;
9666   if (HasOptionalField(e_integrityCheckValue) && !m_integrityCheckValue.Decode(strm))
9667     return FALSE;
9668   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
9669     return FALSE;
9670   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
9671     return FALSE;
9672
9673   return UnknownExtensionsDecode(strm);
9674 }
9675
9676
9677 void H225_ResourcesAvailableIndicate::Encode(PASN_Stream & strm) const
9678 {
9679   PreambleEncode(strm);
9680
9681   m_requestSeqNum.Encode(strm);
9682   m_protocolIdentifier.Encode(strm);
9683   if (HasOptionalField(e_nonStandardData))
9684     m_nonStandardData.Encode(strm);
9685   m_endpointIdentifier.Encode(strm);
9686   m_protocols.Encode(strm);
9687   m_almostOutOfResources.Encode(strm);
9688   if (HasOptionalField(e_tokens))
9689     m_tokens.Encode(strm);
9690   if (HasOptionalField(e_cryptoTokens))
9691     m_cryptoTokens.Encode(strm);
9692   if (HasOptionalField(e_integrityCheckValue))
9693     m_integrityCheckValue.Encode(strm);
9694   KnownExtensionEncode(strm, e_capacity, m_capacity);
9695   KnownExtensionEncode(strm, e_genericData, m_genericData);
9696
9697   UnknownExtensionsEncode(strm);
9698 }
9699
9700
9701 PObject * H225_ResourcesAvailableIndicate::Clone() const
9702 {
9703 #ifndef PASN_LEANANDMEAN
9704   PAssert(IsClass(H225_ResourcesAvailableIndicate::Class()), PInvalidCast);
9705 #endif
9706   return new H225_ResourcesAvailableIndicate(*this);
9707 }
9708
9709
9710 //
9711 // H323-UU-PDU
9712 //
9713
9714 H225_H323_UU_PDU::H225_H323_UU_PDU(unsigned tag, PASN_Object::TagClass tagClass)
9715   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
9716 {
9717   IncludeOptionalField(e_h245Tunneling);
9718 }
9719
9720
9721 #ifndef PASN_NOPRINTON
9722 void H225_H323_UU_PDU::PrintOn(ostream & strm) const
9723 {
9724   int indent = strm.precision() + 2;
9725   strm << "{\n";
9726   strm << setw(indent+20) << "h323_message_body = " << setprecision(indent) << m_h323_message_body << '\n';
9727   if (HasOptionalField(e_nonStandardData))
9728     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9729   if (HasOptionalField(e_h4501SupplementaryService))
9730     strm << setw(indent+28) << "h4501SupplementaryService = " << setprecision(indent) << m_h4501SupplementaryService << '\n';
9731   if (HasOptionalField(e_h245Tunneling))
9732     strm << setw(indent+16) << "h245Tunneling = " << setprecision(indent) << m_h245Tunneling << '\n';
9733   if (HasOptionalField(e_h245Control))
9734     strm << setw(indent+14) << "h245Control = " << setprecision(indent) << m_h245Control << '\n';
9735   if (HasOptionalField(e_nonStandardControl))
9736     strm << setw(indent+21) << "nonStandardControl = " << setprecision(indent) << m_nonStandardControl << '\n';
9737   if (HasOptionalField(e_callLinkage))
9738     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
9739   if (HasOptionalField(e_tunnelledSignallingMessage))
9740     strm << setw(indent+29) << "tunnelledSignallingMessage = " << setprecision(indent) << m_tunnelledSignallingMessage << '\n';
9741   if (HasOptionalField(e_provisionalRespToH245Tunneling))
9742     strm << setw(indent+33) << "provisionalRespToH245Tunneling = " << setprecision(indent) << m_provisionalRespToH245Tunneling << '\n';
9743   if (HasOptionalField(e_stimulusControl))
9744     strm << setw(indent+18) << "stimulusControl = " << setprecision(indent) << m_stimulusControl << '\n';
9745   if (HasOptionalField(e_genericData))
9746     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
9747   strm << setw(indent-1) << setprecision(indent-2) << "}";
9748 }
9749 #endif
9750
9751
9752 PObject::Comparison H225_H323_UU_PDU::Compare(const PObject & obj) const
9753 {
9754 #ifndef PASN_LEANANDMEAN
9755   PAssert(PIsDescendant(&obj, H225_H323_UU_PDU), PInvalidCast);
9756 #endif
9757   const H225_H323_UU_PDU & other = (const H225_H323_UU_PDU &)obj;
9758
9759   Comparison result;
9760
9761   if ((result = m_h323_message_body.Compare(other.m_h323_message_body)) != EqualTo)
9762     return result;
9763   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
9764     return result;
9765
9766   return PASN_Sequence::Compare(other);
9767 }
9768
9769
9770 PINDEX H225_H323_UU_PDU::GetDataLength() const
9771 {
9772   PINDEX length = 0;
9773   length += m_h323_message_body.GetObjectLength();
9774   if (HasOptionalField(e_nonStandardData))
9775     length += m_nonStandardData.GetObjectLength();
9776   return length;
9777 }
9778
9779
9780 BOOL H225_H323_UU_PDU::Decode(PASN_Stream & strm)
9781 {
9782   if (!PreambleDecode(strm))
9783     return FALSE;
9784
9785   if (!m_h323_message_body.Decode(strm))
9786     return FALSE;
9787   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
9788     return FALSE;
9789   if (!KnownExtensionDecode(strm, e_h4501SupplementaryService, m_h4501SupplementaryService))
9790     return FALSE;
9791   if (!KnownExtensionDecode(strm, e_h245Tunneling, m_h245Tunneling))
9792     return FALSE;
9793   if (!KnownExtensionDecode(strm, e_h245Control, m_h245Control))
9794     return FALSE;
9795   if (!KnownExtensionDecode(strm, e_nonStandardControl, m_nonStandardControl))
9796     return FALSE;
9797   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
9798     return FALSE;
9799   if (!KnownExtensionDecode(strm, e_tunnelledSignallingMessage, m_tunnelledSignallingMessage))
9800     return FALSE;
9801   if (!KnownExtensionDecode(strm, e_provisionalRespToH245Tunneling, m_provisionalRespToH245Tunneling))
9802     return FALSE;
9803   if (!KnownExtensionDecode(strm, e_stimulusControl, m_stimulusControl))
9804     return FALSE;
9805   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
9806     return FALSE;
9807
9808   return UnknownExtensionsDecode(strm);
9809 }
9810
9811
9812 void H225_H323_UU_PDU::Encode(PASN_Stream & strm) const
9813 {
9814   PreambleEncode(strm);
9815
9816   m_h323_message_body.Encode(strm);
9817   if (HasOptionalField(e_nonStandardData))
9818     m_nonStandardData.Encode(strm);
9819   KnownExtensionEncode(strm, e_h4501SupplementaryService, m_h4501SupplementaryService);
9820   KnownExtensionEncode(strm, e_h245Tunneling, m_h245Tunneling);
9821   KnownExtensionEncode(strm, e_h245Control, m_h245Control);
9822   KnownExtensionEncode(strm, e_nonStandardControl, m_nonStandardControl);
9823   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
9824   KnownExtensionEncode(strm, e_tunnelledSignallingMessage, m_tunnelledSignallingMessage);
9825   KnownExtensionEncode(strm, e_provisionalRespToH245Tunneling, m_provisionalRespToH245Tunneling);
9826   KnownExtensionEncode(strm, e_stimulusControl, m_stimulusControl);
9827   KnownExtensionEncode(strm, e_genericData, m_genericData);
9828
9829   UnknownExtensionsEncode(strm);
9830 }
9831
9832
9833 PObject * H225_H323_UU_PDU::Clone() const
9834 {
9835 #ifndef PASN_LEANANDMEAN
9836   PAssert(IsClass(H225_H323_UU_PDU::Class()), PInvalidCast);
9837 #endif
9838   return new H225_H323_UU_PDU(*this);
9839 }
9840
9841
9842 //
9843 // ReleaseComplete-UUIE
9844 //
9845
9846 H225_ReleaseComplete_UUIE::H225_ReleaseComplete_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
9847   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
9848 {
9849   IncludeOptionalField(e_callIdentifier);
9850 }
9851
9852
9853 #ifndef PASN_NOPRINTON
9854 void H225_ReleaseComplete_UUIE::PrintOn(ostream & strm) const
9855 {
9856   int indent = strm.precision() + 2;
9857   strm << "{\n";
9858   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
9859   if (HasOptionalField(e_reason))
9860     strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
9861   if (HasOptionalField(e_callIdentifier))
9862     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
9863   if (HasOptionalField(e_tokens))
9864     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
9865   if (HasOptionalField(e_cryptoTokens))
9866     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
9867   if (HasOptionalField(e_busyAddress))
9868     strm << setw(indent+14) << "busyAddress = " << setprecision(indent) << m_busyAddress << '\n';
9869   if (HasOptionalField(e_presentationIndicator))
9870     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
9871   if (HasOptionalField(e_screeningIndicator))
9872     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
9873   if (HasOptionalField(e_capacity))
9874     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
9875   if (HasOptionalField(e_serviceControl))
9876     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
9877   if (HasOptionalField(e_featureSet))
9878     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
9879   strm << setw(indent-1) << setprecision(indent-2) << "}";
9880 }
9881 #endif
9882
9883
9884 PObject::Comparison H225_ReleaseComplete_UUIE::Compare(const PObject & obj) const
9885 {
9886 #ifndef PASN_LEANANDMEAN
9887   PAssert(PIsDescendant(&obj, H225_ReleaseComplete_UUIE), PInvalidCast);
9888 #endif
9889   const H225_ReleaseComplete_UUIE & other = (const H225_ReleaseComplete_UUIE &)obj;
9890
9891   Comparison result;
9892
9893   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
9894     return result;
9895   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
9896     return result;
9897
9898   return PASN_Sequence::Compare(other);
9899 }
9900
9901
9902 PINDEX H225_ReleaseComplete_UUIE::GetDataLength() const
9903 {
9904   PINDEX length = 0;
9905   length += m_protocolIdentifier.GetObjectLength();
9906   if (HasOptionalField(e_reason))
9907     length += m_reason.GetObjectLength();
9908   return length;
9909 }
9910
9911
9912 BOOL H225_ReleaseComplete_UUIE::Decode(PASN_Stream & strm)
9913 {
9914   if (!PreambleDecode(strm))
9915     return FALSE;
9916
9917   if (!m_protocolIdentifier.Decode(strm))
9918     return FALSE;
9919   if (HasOptionalField(e_reason) && !m_reason.Decode(strm))
9920     return FALSE;
9921   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
9922     return FALSE;
9923   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
9924     return FALSE;
9925   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
9926     return FALSE;
9927   if (!KnownExtensionDecode(strm, e_busyAddress, m_busyAddress))
9928     return FALSE;
9929   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
9930     return FALSE;
9931   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
9932     return FALSE;
9933   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
9934     return FALSE;
9935   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
9936     return FALSE;
9937   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
9938     return FALSE;
9939
9940   return UnknownExtensionsDecode(strm);
9941 }
9942
9943
9944 void H225_ReleaseComplete_UUIE::Encode(PASN_Stream & strm) const
9945 {
9946   PreambleEncode(strm);
9947
9948   m_protocolIdentifier.Encode(strm);
9949   if (HasOptionalField(e_reason))
9950     m_reason.Encode(strm);
9951   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
9952   KnownExtensionEncode(strm, e_tokens, m_tokens);
9953   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
9954   KnownExtensionEncode(strm, e_busyAddress, m_busyAddress);
9955   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
9956   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
9957   KnownExtensionEncode(strm, e_capacity, m_capacity);
9958   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
9959   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
9960
9961   UnknownExtensionsEncode(strm);
9962 }
9963
9964
9965 PObject * H225_ReleaseComplete_UUIE::Clone() const
9966 {
9967 #ifndef PASN_LEANANDMEAN
9968   PAssert(IsClass(H225_ReleaseComplete_UUIE::Class()), PInvalidCast);
9969 #endif
9970   return new H225_ReleaseComplete_UUIE(*this);
9971 }
9972
9973
9974 //
9975 // EndpointType
9976 //
9977
9978 H225_EndpointType::H225_EndpointType(unsigned tag, PASN_Object::TagClass tagClass)
9979   : PASN_Sequence(tag, tagClass, 6, TRUE, 2)
9980 {
9981   m_set.SetConstraints(PASN_Object::FixedConstraint, 32);
9982 }
9983
9984
9985 #ifndef PASN_NOPRINTON
9986 void H225_EndpointType::PrintOn(ostream & strm) const
9987 {
9988   int indent = strm.precision() + 2;
9989   strm << "{\n";
9990   if (HasOptionalField(e_nonStandardData))
9991     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
9992   if (HasOptionalField(e_vendor))
9993     strm << setw(indent+9) << "vendor = " << setprecision(indent) << m_vendor << '\n';
9994   if (HasOptionalField(e_gatekeeper))
9995     strm << setw(indent+13) << "gatekeeper = " << setprecision(indent) << m_gatekeeper << '\n';
9996   if (HasOptionalField(e_gateway))
9997     strm << setw(indent+10) << "gateway = " << setprecision(indent) << m_gateway << '\n';
9998   if (HasOptionalField(e_mcu))
9999     strm << setw(indent+6) << "mcu = " << setprecision(indent) << m_mcu << '\n';
10000   if (HasOptionalField(e_terminal))
10001     strm << setw(indent+11) << "terminal = " << setprecision(indent) << m_terminal << '\n';
10002   strm << setw(indent+5) << "mc = " << setprecision(indent) << m_mc << '\n';
10003   strm << setw(indent+16) << "undefinedNode = " << setprecision(indent) << m_undefinedNode << '\n';
10004   if (HasOptionalField(e_set))
10005     strm << setw(indent+6) << "set = " << setprecision(indent) << m_set << '\n';
10006   if (HasOptionalField(e_supportedTunnelledProtocols))
10007     strm << setw(indent+30) << "supportedTunnelledProtocols = " << setprecision(indent) << m_supportedTunnelledProtocols << '\n';
10008   strm << setw(indent-1) << setprecision(indent-2) << "}";
10009 }
10010 #endif
10011
10012
10013 PObject::Comparison H225_EndpointType::Compare(const PObject & obj) const
10014 {
10015 #ifndef PASN_LEANANDMEAN
10016   PAssert(PIsDescendant(&obj, H225_EndpointType), PInvalidCast);
10017 #endif
10018   const H225_EndpointType & other = (const H225_EndpointType &)obj;
10019
10020   Comparison result;
10021
10022   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
10023     return result;
10024   if ((result = m_vendor.Compare(other.m_vendor)) != EqualTo)
10025     return result;
10026   if ((result = m_gatekeeper.Compare(other.m_gatekeeper)) != EqualTo)
10027     return result;
10028   if ((result = m_gateway.Compare(other.m_gateway)) != EqualTo)
10029     return result;
10030   if ((result = m_mcu.Compare(other.m_mcu)) != EqualTo)
10031     return result;
10032   if ((result = m_terminal.Compare(other.m_terminal)) != EqualTo)
10033     return result;
10034   if ((result = m_mc.Compare(other.m_mc)) != EqualTo)
10035     return result;
10036   if ((result = m_undefinedNode.Compare(other.m_undefinedNode)) != EqualTo)
10037     return result;
10038
10039   return PASN_Sequence::Compare(other);
10040 }
10041
10042
10043 PINDEX H225_EndpointType::GetDataLength() const
10044 {
10045   PINDEX length = 0;
10046   if (HasOptionalField(e_nonStandardData))
10047     length += m_nonStandardData.GetObjectLength();
10048   if (HasOptionalField(e_vendor))
10049     length += m_vendor.GetObjectLength();
10050   if (HasOptionalField(e_gatekeeper))
10051     length += m_gatekeeper.GetObjectLength();
10052   if (HasOptionalField(e_gateway))
10053     length += m_gateway.GetObjectLength();
10054   if (HasOptionalField(e_mcu))
10055     length += m_mcu.GetObjectLength();
10056   if (HasOptionalField(e_terminal))
10057     length += m_terminal.GetObjectLength();
10058   length += m_mc.GetObjectLength();
10059   length += m_undefinedNode.GetObjectLength();
10060   return length;
10061 }
10062
10063
10064 BOOL H225_EndpointType::Decode(PASN_Stream & strm)
10065 {
10066   if (!PreambleDecode(strm))
10067     return FALSE;
10068
10069   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
10070     return FALSE;
10071   if (HasOptionalField(e_vendor) && !m_vendor.Decode(strm))
10072     return FALSE;
10073   if (HasOptionalField(e_gatekeeper) && !m_gatekeeper.Decode(strm))
10074     return FALSE;
10075   if (HasOptionalField(e_gateway) && !m_gateway.Decode(strm))
10076     return FALSE;
10077   if (HasOptionalField(e_mcu) && !m_mcu.Decode(strm))
10078     return FALSE;
10079   if (HasOptionalField(e_terminal) && !m_terminal.Decode(strm))
10080     return FALSE;
10081   if (!m_mc.Decode(strm))
10082     return FALSE;
10083   if (!m_undefinedNode.Decode(strm))
10084     return FALSE;
10085   if (!KnownExtensionDecode(strm, e_set, m_set))
10086     return FALSE;
10087   if (!KnownExtensionDecode(strm, e_supportedTunnelledProtocols, m_supportedTunnelledProtocols))
10088     return FALSE;
10089
10090   return UnknownExtensionsDecode(strm);
10091 }
10092
10093
10094 void H225_EndpointType::Encode(PASN_Stream & strm) const
10095 {
10096   PreambleEncode(strm);
10097
10098   if (HasOptionalField(e_nonStandardData))
10099     m_nonStandardData.Encode(strm);
10100   if (HasOptionalField(e_vendor))
10101     m_vendor.Encode(strm);
10102   if (HasOptionalField(e_gatekeeper))
10103     m_gatekeeper.Encode(strm);
10104   if (HasOptionalField(e_gateway))
10105     m_gateway.Encode(strm);
10106   if (HasOptionalField(e_mcu))
10107     m_mcu.Encode(strm);
10108   if (HasOptionalField(e_terminal))
10109     m_terminal.Encode(strm);
10110   m_mc.Encode(strm);
10111   m_undefinedNode.Encode(strm);
10112   KnownExtensionEncode(strm, e_set, m_set);
10113   KnownExtensionEncode(strm, e_supportedTunnelledProtocols, m_supportedTunnelledProtocols);
10114
10115   UnknownExtensionsEncode(strm);
10116 }
10117
10118
10119 PObject * H225_EndpointType::Clone() const
10120 {
10121 #ifndef PASN_LEANANDMEAN
10122   PAssert(IsClass(H225_EndpointType::Class()), PInvalidCast);
10123 #endif
10124   return new H225_EndpointType(*this);
10125 }
10126
10127
10128 //
10129 // CircuitInfo
10130 //
10131
10132 H225_CircuitInfo::H225_CircuitInfo(unsigned tag, PASN_Object::TagClass tagClass)
10133   : PASN_Sequence(tag, tagClass, 3, TRUE, 0)
10134 {
10135 }
10136
10137
10138 #ifndef PASN_NOPRINTON
10139 void H225_CircuitInfo::PrintOn(ostream & strm) const
10140 {
10141   int indent = strm.precision() + 2;
10142   strm << "{\n";
10143   if (HasOptionalField(e_sourceCircuitID))
10144     strm << setw(indent+18) << "sourceCircuitID = " << setprecision(indent) << m_sourceCircuitID << '\n';
10145   if (HasOptionalField(e_destinationCircuitID))
10146     strm << setw(indent+23) << "destinationCircuitID = " << setprecision(indent) << m_destinationCircuitID << '\n';
10147   if (HasOptionalField(e_genericData))
10148     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
10149   strm << setw(indent-1) << setprecision(indent-2) << "}";
10150 }
10151 #endif
10152
10153
10154 PObject::Comparison H225_CircuitInfo::Compare(const PObject & obj) const
10155 {
10156 #ifndef PASN_LEANANDMEAN
10157   PAssert(PIsDescendant(&obj, H225_CircuitInfo), PInvalidCast);
10158 #endif
10159   const H225_CircuitInfo & other = (const H225_CircuitInfo &)obj;
10160
10161   Comparison result;
10162
10163   if ((result = m_sourceCircuitID.Compare(other.m_sourceCircuitID)) != EqualTo)
10164     return result;
10165   if ((result = m_destinationCircuitID.Compare(other.m_destinationCircuitID)) != EqualTo)
10166     return result;
10167   if ((result = m_genericData.Compare(other.m_genericData)) != EqualTo)
10168     return result;
10169
10170   return PASN_Sequence::Compare(other);
10171 }
10172
10173
10174 PINDEX H225_CircuitInfo::GetDataLength() const
10175 {
10176   PINDEX length = 0;
10177   if (HasOptionalField(e_sourceCircuitID))
10178     length += m_sourceCircuitID.GetObjectLength();
10179   if (HasOptionalField(e_destinationCircuitID))
10180     length += m_destinationCircuitID.GetObjectLength();
10181   if (HasOptionalField(e_genericData))
10182     length += m_genericData.GetObjectLength();
10183   return length;
10184 }
10185
10186
10187 BOOL H225_CircuitInfo::Decode(PASN_Stream & strm)
10188 {
10189   if (!PreambleDecode(strm))
10190     return FALSE;
10191
10192   if (HasOptionalField(e_sourceCircuitID) && !m_sourceCircuitID.Decode(strm))
10193     return FALSE;
10194   if (HasOptionalField(e_destinationCircuitID) && !m_destinationCircuitID.Decode(strm))
10195     return FALSE;
10196   if (HasOptionalField(e_genericData) && !m_genericData.Decode(strm))
10197     return FALSE;
10198
10199   return UnknownExtensionsDecode(strm);
10200 }
10201
10202
10203 void H225_CircuitInfo::Encode(PASN_Stream & strm) const
10204 {
10205   PreambleEncode(strm);
10206
10207   if (HasOptionalField(e_sourceCircuitID))
10208     m_sourceCircuitID.Encode(strm);
10209   if (HasOptionalField(e_destinationCircuitID))
10210     m_destinationCircuitID.Encode(strm);
10211   if (HasOptionalField(e_genericData))
10212     m_genericData.Encode(strm);
10213
10214   UnknownExtensionsEncode(strm);
10215 }
10216
10217
10218 PObject * H225_CircuitInfo::Clone() const
10219 {
10220 #ifndef PASN_LEANANDMEAN
10221   PAssert(IsClass(H225_CircuitInfo::Class()), PInvalidCast);
10222 #endif
10223   return new H225_CircuitInfo(*this);
10224 }
10225
10226
10227 //
10228 // GatekeeperRequest
10229 //
10230
10231 H225_GatekeeperRequest::H225_GatekeeperRequest(unsigned tag, PASN_Object::TagClass tagClass)
10232   : PASN_Sequence(tag, tagClass, 4, TRUE, 12)
10233 {
10234 //  IncludeOptionalField(e_supportsAssignedGK);
10235 }
10236
10237
10238 #ifndef PASN_NOPRINTON
10239 void H225_GatekeeperRequest::PrintOn(ostream & strm) const
10240 {
10241   int indent = strm.precision() + 2;
10242   strm << "{\n";
10243   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
10244   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
10245   if (HasOptionalField(e_nonStandardData))
10246     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
10247   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
10248   strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
10249   if (HasOptionalField(e_gatekeeperIdentifier))
10250     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
10251   if (HasOptionalField(e_callServices))
10252     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
10253   if (HasOptionalField(e_endpointAlias))
10254     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
10255   if (HasOptionalField(e_alternateEndpoints))
10256     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
10257   if (HasOptionalField(e_tokens))
10258     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
10259   if (HasOptionalField(e_cryptoTokens))
10260     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
10261   if (HasOptionalField(e_authenticationCapability))
10262     strm << setw(indent+27) << "authenticationCapability = " << setprecision(indent) << m_authenticationCapability << '\n';
10263   if (HasOptionalField(e_algorithmOIDs))
10264     strm << setw(indent+16) << "algorithmOIDs = " << setprecision(indent) << m_algorithmOIDs << '\n';
10265   if (HasOptionalField(e_integrity))
10266     strm << setw(indent+12) << "integrity = " << setprecision(indent) << m_integrity << '\n';
10267   if (HasOptionalField(e_integrityCheckValue))
10268     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
10269   if (HasOptionalField(e_supportsAltGK))
10270     strm << setw(indent+16) << "supportsAltGK = " << setprecision(indent) << m_supportsAltGK << '\n';
10271   if (HasOptionalField(e_featureSet))
10272     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
10273   if (HasOptionalField(e_genericData))
10274     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
10275   if (HasOptionalField(e_supportsAssignedGK))
10276     strm << setw(indent+21) << "supportsAssignedGK = " << setprecision(indent) << m_supportsAssignedGK << '\n';
10277   if (HasOptionalField(e_assignedGatekeeper))
10278     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
10279   strm << setw(indent-1) << setprecision(indent-2) << "}";
10280 }
10281 #endif
10282
10283
10284 PObject::Comparison H225_GatekeeperRequest::Compare(const PObject & obj) const
10285 {
10286 #ifndef PASN_LEANANDMEAN
10287   PAssert(PIsDescendant(&obj, H225_GatekeeperRequest), PInvalidCast);
10288 #endif
10289   const H225_GatekeeperRequest & other = (const H225_GatekeeperRequest &)obj;
10290
10291   Comparison result;
10292
10293   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
10294     return result;
10295   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
10296     return result;
10297   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
10298     return result;
10299   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
10300     return result;
10301   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
10302     return result;
10303   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
10304     return result;
10305   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
10306     return result;
10307   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
10308     return result;
10309
10310   return PASN_Sequence::Compare(other);
10311 }
10312
10313
10314 PINDEX H225_GatekeeperRequest::GetDataLength() const
10315 {
10316   PINDEX length = 0;
10317   length += m_requestSeqNum.GetObjectLength();
10318   length += m_protocolIdentifier.GetObjectLength();
10319   if (HasOptionalField(e_nonStandardData))
10320     length += m_nonStandardData.GetObjectLength();
10321   length += m_rasAddress.GetObjectLength();
10322   length += m_endpointType.GetObjectLength();
10323   if (HasOptionalField(e_gatekeeperIdentifier))
10324     length += m_gatekeeperIdentifier.GetObjectLength();
10325   if (HasOptionalField(e_callServices))
10326     length += m_callServices.GetObjectLength();
10327   if (HasOptionalField(e_endpointAlias))
10328     length += m_endpointAlias.GetObjectLength();
10329   return length;
10330 }
10331
10332
10333 BOOL H225_GatekeeperRequest::Decode(PASN_Stream & strm)
10334 {
10335   if (!PreambleDecode(strm))
10336     return FALSE;
10337
10338   if (!m_requestSeqNum.Decode(strm))
10339     return FALSE;
10340   if (!m_protocolIdentifier.Decode(strm))
10341     return FALSE;
10342   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
10343     return FALSE;
10344   if (!m_rasAddress.Decode(strm))
10345     return FALSE;
10346   if (!m_endpointType.Decode(strm))
10347     return FALSE;
10348   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
10349     return FALSE;
10350   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
10351     return FALSE;
10352   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
10353     return FALSE;
10354   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
10355     return FALSE;
10356   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
10357     return FALSE;
10358   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
10359     return FALSE;
10360   if (!KnownExtensionDecode(strm, e_authenticationCapability, m_authenticationCapability))
10361     return FALSE;
10362   if (!KnownExtensionDecode(strm, e_algorithmOIDs, m_algorithmOIDs))
10363     return FALSE;
10364   if (!KnownExtensionDecode(strm, e_integrity, m_integrity))
10365     return FALSE;
10366   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
10367     return FALSE;
10368   if (!KnownExtensionDecode(strm, e_supportsAltGK, m_supportsAltGK))
10369     return FALSE;
10370   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
10371     return FALSE;
10372   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
10373     return FALSE;
10374   if (!KnownExtensionDecode(strm, e_supportsAssignedGK, m_supportsAssignedGK))
10375     return FALSE;
10376   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
10377     return FALSE;
10378
10379   return UnknownExtensionsDecode(strm);
10380 }
10381
10382
10383 void H225_GatekeeperRequest::Encode(PASN_Stream & strm) const
10384 {
10385   PreambleEncode(strm);
10386
10387   m_requestSeqNum.Encode(strm);
10388   m_protocolIdentifier.Encode(strm);
10389   if (HasOptionalField(e_nonStandardData))
10390     m_nonStandardData.Encode(strm);
10391   m_rasAddress.Encode(strm);
10392   m_endpointType.Encode(strm);
10393   if (HasOptionalField(e_gatekeeperIdentifier))
10394     m_gatekeeperIdentifier.Encode(strm);
10395   if (HasOptionalField(e_callServices))
10396     m_callServices.Encode(strm);
10397   if (HasOptionalField(e_endpointAlias))
10398     m_endpointAlias.Encode(strm);
10399   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
10400   KnownExtensionEncode(strm, e_tokens, m_tokens);
10401   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
10402   KnownExtensionEncode(strm, e_authenticationCapability, m_authenticationCapability);
10403   KnownExtensionEncode(strm, e_algorithmOIDs, m_algorithmOIDs);
10404   KnownExtensionEncode(strm, e_integrity, m_integrity);
10405   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
10406   KnownExtensionEncode(strm, e_supportsAltGK, m_supportsAltGK);
10407   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
10408   KnownExtensionEncode(strm, e_genericData, m_genericData);
10409   KnownExtensionEncode(strm, e_supportsAssignedGK, m_supportsAssignedGK);
10410   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
10411
10412   UnknownExtensionsEncode(strm);
10413 }
10414
10415
10416 PObject * H225_GatekeeperRequest::Clone() const
10417 {
10418 #ifndef PASN_LEANANDMEAN
10419   PAssert(IsClass(H225_GatekeeperRequest::Class()), PInvalidCast);
10420 #endif
10421   return new H225_GatekeeperRequest(*this);
10422 }
10423
10424
10425 //
10426 // RegistrationRequest
10427 //
10428
10429 H225_RegistrationRequest::H225_RegistrationRequest(unsigned tag, PASN_Object::TagClass tagClass)
10430   : PASN_Sequence(tag, tagClass, 3, TRUE, 27)
10431 {
10432   IncludeOptionalField(e_keepAlive);
10433   IncludeOptionalField(e_willSupplyUUIEs);
10434   IncludeOptionalField(e_maintainConnection);
10435 //  Removed for backwards interoperabililty. Problems with the messages being parsed on previous versions
10436 //  IncludeOptionalField(e_supportsAssignedGK);
10437 }
10438
10439
10440 #ifndef PASN_NOPRINTON
10441 void H225_RegistrationRequest::PrintOn(ostream & strm) const
10442 {
10443   int indent = strm.precision() + 2;
10444   strm << "{\n";
10445   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
10446   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
10447   if (HasOptionalField(e_nonStandardData))
10448     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
10449   strm << setw(indent+20) << "discoveryComplete = " << setprecision(indent) << m_discoveryComplete << '\n';
10450   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
10451   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
10452   strm << setw(indent+15) << "terminalType = " << setprecision(indent) << m_terminalType << '\n';
10453   if (HasOptionalField(e_terminalAlias))
10454     strm << setw(indent+16) << "terminalAlias = " << setprecision(indent) << m_terminalAlias << '\n';
10455   if (HasOptionalField(e_gatekeeperIdentifier))
10456     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
10457   strm << setw(indent+17) << "endpointVendor = " << setprecision(indent) << m_endpointVendor << '\n';
10458   if (HasOptionalField(e_alternateEndpoints))
10459     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
10460   if (HasOptionalField(e_timeToLive))
10461     strm << setw(indent+13) << "timeToLive = " << setprecision(indent) << m_timeToLive << '\n';
10462   if (HasOptionalField(e_tokens))
10463     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
10464   if (HasOptionalField(e_cryptoTokens))
10465     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
10466   if (HasOptionalField(e_integrityCheckValue))
10467     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
10468   if (HasOptionalField(e_keepAlive))
10469     strm << setw(indent+12) << "keepAlive = " << setprecision(indent) << m_keepAlive << '\n';
10470   if (HasOptionalField(e_endpointIdentifier))
10471     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
10472   if (HasOptionalField(e_willSupplyUUIEs))
10473     strm << setw(indent+18) << "willSupplyUUIEs = " << setprecision(indent) << m_willSupplyUUIEs << '\n';
10474   if (HasOptionalField(e_maintainConnection))
10475     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
10476   if (HasOptionalField(e_alternateTransportAddresses))
10477     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
10478   if (HasOptionalField(e_additiveRegistration))
10479     strm << setw(indent+23) << "additiveRegistration = " << setprecision(indent) << m_additiveRegistration << '\n';
10480   if (HasOptionalField(e_terminalAliasPattern))
10481     strm << setw(indent+23) << "terminalAliasPattern = " << setprecision(indent) << m_terminalAliasPattern << '\n';
10482   if (HasOptionalField(e_supportsAltGK))
10483     strm << setw(indent+16) << "supportsAltGK = " << setprecision(indent) << m_supportsAltGK << '\n';
10484   if (HasOptionalField(e_usageReportingCapability))
10485     strm << setw(indent+27) << "usageReportingCapability = " << setprecision(indent) << m_usageReportingCapability << '\n';
10486   if (HasOptionalField(e_multipleCalls))
10487     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
10488   if (HasOptionalField(e_supportedH248Packages))
10489     strm << setw(indent+24) << "supportedH248Packages = " << setprecision(indent) << m_supportedH248Packages << '\n';
10490   if (HasOptionalField(e_callCreditCapability))
10491     strm << setw(indent+23) << "callCreditCapability = " << setprecision(indent) << m_callCreditCapability << '\n';
10492   if (HasOptionalField(e_capacityReportingCapability))
10493     strm << setw(indent+30) << "capacityReportingCapability = " << setprecision(indent) << m_capacityReportingCapability << '\n';
10494   if (HasOptionalField(e_capacity))
10495     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
10496   if (HasOptionalField(e_featureSet))
10497     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
10498   if (HasOptionalField(e_genericData))
10499     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
10500   if (HasOptionalField(e_restart))
10501     strm << setw(indent+10) << "restart = " << setprecision(indent) << m_restart << '\n';
10502   if (HasOptionalField(e_supportsACFSequences))
10503     strm << setw(indent+23) << "supportsACFSequences = " << setprecision(indent) << m_supportsACFSequences << '\n';
10504   if (HasOptionalField(e_supportsAssignedGK))
10505     strm << setw(indent+21) << "supportsAssignedGK = " << setprecision(indent) << m_supportsAssignedGK << '\n';
10506   if (HasOptionalField(e_assignedGatekeeper))
10507     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
10508   if (HasOptionalField(e_transportQOS))
10509     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
10510   if (HasOptionalField(e_language))
10511     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
10512   strm << setw(indent-1) << setprecision(indent-2) << "}";
10513 }
10514 #endif
10515
10516
10517 PObject::Comparison H225_RegistrationRequest::Compare(const PObject & obj) const
10518 {
10519 #ifndef PASN_LEANANDMEAN
10520   PAssert(PIsDescendant(&obj, H225_RegistrationRequest), PInvalidCast);
10521 #endif
10522   const H225_RegistrationRequest & other = (const H225_RegistrationRequest &)obj;
10523
10524   Comparison result;
10525
10526   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
10527     return result;
10528   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
10529     return result;
10530   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
10531     return result;
10532   if ((result = m_discoveryComplete.Compare(other.m_discoveryComplete)) != EqualTo)
10533     return result;
10534   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
10535     return result;
10536   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
10537     return result;
10538   if ((result = m_terminalType.Compare(other.m_terminalType)) != EqualTo)
10539     return result;
10540   if ((result = m_terminalAlias.Compare(other.m_terminalAlias)) != EqualTo)
10541     return result;
10542   if ((result = m_gatekeeperIdentifier.Compare(other.m_gatekeeperIdentifier)) != EqualTo)
10543     return result;
10544   if ((result = m_endpointVendor.Compare(other.m_endpointVendor)) != EqualTo)
10545     return result;
10546
10547   return PASN_Sequence::Compare(other);
10548 }
10549
10550
10551 PINDEX H225_RegistrationRequest::GetDataLength() const
10552 {
10553   PINDEX length = 0;
10554   length += m_requestSeqNum.GetObjectLength();
10555   length += m_protocolIdentifier.GetObjectLength();
10556   if (HasOptionalField(e_nonStandardData))
10557     length += m_nonStandardData.GetObjectLength();
10558   length += m_discoveryComplete.GetObjectLength();
10559   length += m_callSignalAddress.GetObjectLength();
10560   length += m_rasAddress.GetObjectLength();
10561   length += m_terminalType.GetObjectLength();
10562   if (HasOptionalField(e_terminalAlias))
10563     length += m_terminalAlias.GetObjectLength();
10564   if (HasOptionalField(e_gatekeeperIdentifier))
10565     length += m_gatekeeperIdentifier.GetObjectLength();
10566   length += m_endpointVendor.GetObjectLength();
10567   return length;
10568 }
10569
10570
10571 BOOL H225_RegistrationRequest::Decode(PASN_Stream & strm)
10572 {
10573   if (!PreambleDecode(strm))
10574     return FALSE;
10575
10576   if (!m_requestSeqNum.Decode(strm))
10577     return FALSE;
10578   if (!m_protocolIdentifier.Decode(strm))
10579     return FALSE;
10580   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
10581     return FALSE;
10582   if (!m_discoveryComplete.Decode(strm))
10583     return FALSE;
10584   if (!m_callSignalAddress.Decode(strm))
10585     return FALSE;
10586   if (!m_rasAddress.Decode(strm))
10587     return FALSE;
10588   if (!m_terminalType.Decode(strm))
10589     return FALSE;
10590   if (HasOptionalField(e_terminalAlias) && !m_terminalAlias.Decode(strm))
10591     return FALSE;
10592   if (HasOptionalField(e_gatekeeperIdentifier) && !m_gatekeeperIdentifier.Decode(strm))
10593     return FALSE;
10594   if (!m_endpointVendor.Decode(strm))
10595     return FALSE;
10596   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
10597     return FALSE;
10598   if (!KnownExtensionDecode(strm, e_timeToLive, m_timeToLive))
10599     return FALSE;
10600   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
10601     return FALSE;
10602   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
10603     return FALSE;
10604   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
10605     return FALSE;
10606   if (!KnownExtensionDecode(strm, e_keepAlive, m_keepAlive))
10607     return FALSE;
10608   if (!KnownExtensionDecode(strm, e_endpointIdentifier, m_endpointIdentifier))
10609     return FALSE;
10610   if (!KnownExtensionDecode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs))
10611     return FALSE;
10612   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
10613     return FALSE;
10614   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
10615     return FALSE;
10616   if (!KnownExtensionDecode(strm, e_additiveRegistration, m_additiveRegistration))
10617     return FALSE;
10618   if (!KnownExtensionDecode(strm, e_terminalAliasPattern, m_terminalAliasPattern))
10619     return FALSE;
10620   if (!KnownExtensionDecode(strm, e_supportsAltGK, m_supportsAltGK))
10621     return FALSE;
10622   if (!KnownExtensionDecode(strm, e_usageReportingCapability, m_usageReportingCapability))
10623     return FALSE;
10624   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
10625     return FALSE;
10626   if (!KnownExtensionDecode(strm, e_supportedH248Packages, m_supportedH248Packages))
10627     return FALSE;
10628   if (!KnownExtensionDecode(strm, e_callCreditCapability, m_callCreditCapability))
10629     return FALSE;
10630   if (!KnownExtensionDecode(strm, e_capacityReportingCapability, m_capacityReportingCapability))
10631     return FALSE;
10632   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
10633     return FALSE;
10634   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
10635     return FALSE;
10636   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
10637     return FALSE;
10638   if (!KnownExtensionDecode(strm, e_restart, m_restart))
10639     return FALSE;
10640   if (!KnownExtensionDecode(strm, e_supportsACFSequences, m_supportsACFSequences))
10641     return FALSE;
10642   if (!KnownExtensionDecode(strm, e_supportsAssignedGK, m_supportsAssignedGK))
10643     return FALSE;
10644   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
10645     return FALSE;
10646   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
10647     return FALSE;
10648   if (!KnownExtensionDecode(strm, e_language, m_language))
10649     return FALSE;
10650
10651   return UnknownExtensionsDecode(strm);
10652 }
10653
10654
10655 void H225_RegistrationRequest::Encode(PASN_Stream & strm) const
10656 {
10657   PreambleEncode(strm);
10658
10659   m_requestSeqNum.Encode(strm);
10660   m_protocolIdentifier.Encode(strm);
10661   if (HasOptionalField(e_nonStandardData))
10662     m_nonStandardData.Encode(strm);
10663   m_discoveryComplete.Encode(strm);
10664   m_callSignalAddress.Encode(strm);
10665   m_rasAddress.Encode(strm);
10666   m_terminalType.Encode(strm);
10667   if (HasOptionalField(e_terminalAlias))
10668     m_terminalAlias.Encode(strm);
10669   if (HasOptionalField(e_gatekeeperIdentifier))
10670     m_gatekeeperIdentifier.Encode(strm);
10671   m_endpointVendor.Encode(strm);
10672   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
10673   KnownExtensionEncode(strm, e_timeToLive, m_timeToLive);
10674   KnownExtensionEncode(strm, e_tokens, m_tokens);
10675   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
10676   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
10677   KnownExtensionEncode(strm, e_keepAlive, m_keepAlive);
10678   KnownExtensionEncode(strm, e_endpointIdentifier, m_endpointIdentifier);
10679   KnownExtensionEncode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs);
10680   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
10681   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
10682   KnownExtensionEncode(strm, e_additiveRegistration, m_additiveRegistration);
10683   KnownExtensionEncode(strm, e_terminalAliasPattern, m_terminalAliasPattern);
10684   KnownExtensionEncode(strm, e_supportsAltGK, m_supportsAltGK);
10685   KnownExtensionEncode(strm, e_usageReportingCapability, m_usageReportingCapability);
10686   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
10687   KnownExtensionEncode(strm, e_supportedH248Packages, m_supportedH248Packages);
10688   KnownExtensionEncode(strm, e_callCreditCapability, m_callCreditCapability);
10689   KnownExtensionEncode(strm, e_capacityReportingCapability, m_capacityReportingCapability);
10690   KnownExtensionEncode(strm, e_capacity, m_capacity);
10691   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
10692   KnownExtensionEncode(strm, e_genericData, m_genericData);
10693   KnownExtensionEncode(strm, e_restart, m_restart);
10694   KnownExtensionEncode(strm, e_supportsACFSequences, m_supportsACFSequences);
10695   KnownExtensionEncode(strm, e_supportsAssignedGK, m_supportsAssignedGK);
10696   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
10697   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
10698   KnownExtensionEncode(strm, e_language, m_language);
10699
10700   UnknownExtensionsEncode(strm);
10701 }
10702
10703
10704 PObject * H225_RegistrationRequest::Clone() const
10705 {
10706 #ifndef PASN_LEANANDMEAN
10707   PAssert(IsClass(H225_RegistrationRequest::Class()), PInvalidCast);
10708 #endif
10709   return new H225_RegistrationRequest(*this);
10710 }
10711
10712
10713 //
10714 // AdmissionRequest
10715 //
10716
10717 H225_AdmissionRequest::H225_AdmissionRequest(unsigned tag, PASN_Object::TagClass tagClass)
10718   : PASN_Sequence(tag, tagClass, 7, TRUE, 19)
10719 {
10720   IncludeOptionalField(e_canMapAlias);
10721   IncludeOptionalField(e_callIdentifier);
10722   IncludeOptionalField(e_willSupplyUUIEs);
10723   IncludeOptionalField(e_canMapSrcAlias);
10724 }
10725
10726
10727 #ifndef PASN_NOPRINTON
10728 void H225_AdmissionRequest::PrintOn(ostream & strm) const
10729 {
10730   int indent = strm.precision() + 2;
10731   strm << "{\n";
10732   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
10733   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
10734   if (HasOptionalField(e_callModel))
10735     strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
10736   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
10737   if (HasOptionalField(e_destinationInfo))
10738     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
10739   if (HasOptionalField(e_destCallSignalAddress))
10740     strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
10741   if (HasOptionalField(e_destExtraCallInfo))
10742     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
10743   strm << setw(indent+10) << "srcInfo = " << setprecision(indent) << m_srcInfo << '\n';
10744   if (HasOptionalField(e_srcCallSignalAddress))
10745     strm << setw(indent+23) << "srcCallSignalAddress = " << setprecision(indent) << m_srcCallSignalAddress << '\n';
10746   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
10747   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
10748   if (HasOptionalField(e_nonStandardData))
10749     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
10750   if (HasOptionalField(e_callServices))
10751     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
10752   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
10753   strm << setw(indent+11) << "activeMC = " << setprecision(indent) << m_activeMC << '\n';
10754   strm << setw(indent+13) << "answerCall = " << setprecision(indent) << m_answerCall << '\n';
10755   if (HasOptionalField(e_canMapAlias))
10756     strm << setw(indent+14) << "canMapAlias = " << setprecision(indent) << m_canMapAlias << '\n';
10757   if (HasOptionalField(e_callIdentifier))
10758     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
10759   if (HasOptionalField(e_srcAlternatives))
10760     strm << setw(indent+18) << "srcAlternatives = " << setprecision(indent) << m_srcAlternatives << '\n';
10761   if (HasOptionalField(e_destAlternatives))
10762     strm << setw(indent+19) << "destAlternatives = " << setprecision(indent) << m_destAlternatives << '\n';
10763   if (HasOptionalField(e_gatekeeperIdentifier))
10764     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
10765   if (HasOptionalField(e_tokens))
10766     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
10767   if (HasOptionalField(e_cryptoTokens))
10768     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
10769   if (HasOptionalField(e_integrityCheckValue))
10770     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
10771   if (HasOptionalField(e_transportQOS))
10772     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
10773   if (HasOptionalField(e_willSupplyUUIEs))
10774     strm << setw(indent+18) << "willSupplyUUIEs = " << setprecision(indent) << m_willSupplyUUIEs << '\n';
10775   if (HasOptionalField(e_callLinkage))
10776     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
10777   if (HasOptionalField(e_gatewayDataRate))
10778     strm << setw(indent+18) << "gatewayDataRate = " << setprecision(indent) << m_gatewayDataRate << '\n';
10779   if (HasOptionalField(e_capacity))
10780     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
10781   if (HasOptionalField(e_circuitInfo))
10782     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
10783   if (HasOptionalField(e_desiredProtocols))
10784     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
10785   if (HasOptionalField(e_desiredTunnelledProtocol))
10786     strm << setw(indent+27) << "desiredTunnelledProtocol = " << setprecision(indent) << m_desiredTunnelledProtocol << '\n';
10787   if (HasOptionalField(e_featureSet))
10788     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
10789   if (HasOptionalField(e_genericData))
10790     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
10791   if (HasOptionalField(e_canMapSrcAlias))
10792     strm << setw(indent+17) << "canMapSrcAlias = " << setprecision(indent) << m_canMapSrcAlias << '\n';
10793   strm << setw(indent-1) << setprecision(indent-2) << "}";
10794 }
10795 #endif
10796
10797
10798 PObject::Comparison H225_AdmissionRequest::Compare(const PObject & obj) const
10799 {
10800 #ifndef PASN_LEANANDMEAN
10801   PAssert(PIsDescendant(&obj, H225_AdmissionRequest), PInvalidCast);
10802 #endif
10803   const H225_AdmissionRequest & other = (const H225_AdmissionRequest &)obj;
10804
10805   Comparison result;
10806
10807   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
10808     return result;
10809   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
10810     return result;
10811   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
10812     return result;
10813   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
10814     return result;
10815   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
10816     return result;
10817   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
10818     return result;
10819   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
10820     return result;
10821   if ((result = m_srcInfo.Compare(other.m_srcInfo)) != EqualTo)
10822     return result;
10823   if ((result = m_srcCallSignalAddress.Compare(other.m_srcCallSignalAddress)) != EqualTo)
10824     return result;
10825   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
10826     return result;
10827   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
10828     return result;
10829   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
10830     return result;
10831   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
10832     return result;
10833   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
10834     return result;
10835   if ((result = m_activeMC.Compare(other.m_activeMC)) != EqualTo)
10836     return result;
10837   if ((result = m_answerCall.Compare(other.m_answerCall)) != EqualTo)
10838     return result;
10839
10840   return PASN_Sequence::Compare(other);
10841 }
10842
10843
10844 PINDEX H225_AdmissionRequest::GetDataLength() const
10845 {
10846   PINDEX length = 0;
10847   length += m_requestSeqNum.GetObjectLength();
10848   length += m_callType.GetObjectLength();
10849   if (HasOptionalField(e_callModel))
10850     length += m_callModel.GetObjectLength();
10851   length += m_endpointIdentifier.GetObjectLength();
10852   if (HasOptionalField(e_destinationInfo))
10853     length += m_destinationInfo.GetObjectLength();
10854   if (HasOptionalField(e_destCallSignalAddress))
10855     length += m_destCallSignalAddress.GetObjectLength();
10856   if (HasOptionalField(e_destExtraCallInfo))
10857     length += m_destExtraCallInfo.GetObjectLength();
10858   length += m_srcInfo.GetObjectLength();
10859   if (HasOptionalField(e_srcCallSignalAddress))
10860     length += m_srcCallSignalAddress.GetObjectLength();
10861   length += m_bandWidth.GetObjectLength();
10862   length += m_callReferenceValue.GetObjectLength();
10863   if (HasOptionalField(e_nonStandardData))
10864     length += m_nonStandardData.GetObjectLength();
10865   if (HasOptionalField(e_callServices))
10866     length += m_callServices.GetObjectLength();
10867   length += m_conferenceID.GetObjectLength();
10868   length += m_activeMC.GetObjectLength();
10869   length += m_answerCall.GetObjectLength();
10870   return length;
10871 }
10872
10873
10874 BOOL H225_AdmissionRequest::Decode(PASN_Stream & strm)
10875 {
10876   if (!PreambleDecode(strm))
10877     return FALSE;
10878
10879   if (!m_requestSeqNum.Decode(strm))
10880     return FALSE;
10881   if (!m_callType.Decode(strm))
10882     return FALSE;
10883   if (HasOptionalField(e_callModel) && !m_callModel.Decode(strm))
10884     return FALSE;
10885   if (!m_endpointIdentifier.Decode(strm))
10886     return FALSE;
10887   if (HasOptionalField(e_destinationInfo) && !m_destinationInfo.Decode(strm))
10888     return FALSE;
10889   if (HasOptionalField(e_destCallSignalAddress) && !m_destCallSignalAddress.Decode(strm))
10890     return FALSE;
10891   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
10892     return FALSE;
10893   if (!m_srcInfo.Decode(strm))
10894     return FALSE;
10895   if (HasOptionalField(e_srcCallSignalAddress) && !m_srcCallSignalAddress.Decode(strm))
10896     return FALSE;
10897   if (!m_bandWidth.Decode(strm))
10898     return FALSE;
10899   if (!m_callReferenceValue.Decode(strm))
10900     return FALSE;
10901   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
10902     return FALSE;
10903   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
10904     return FALSE;
10905   if (!m_conferenceID.Decode(strm))
10906     return FALSE;
10907   if (!m_activeMC.Decode(strm))
10908     return FALSE;
10909   if (!m_answerCall.Decode(strm))
10910     return FALSE;
10911   if (!KnownExtensionDecode(strm, e_canMapAlias, m_canMapAlias))
10912     return FALSE;
10913   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
10914     return FALSE;
10915   if (!KnownExtensionDecode(strm, e_srcAlternatives, m_srcAlternatives))
10916     return FALSE;
10917   if (!KnownExtensionDecode(strm, e_destAlternatives, m_destAlternatives))
10918     return FALSE;
10919   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
10920     return FALSE;
10921   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
10922     return FALSE;
10923   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
10924     return FALSE;
10925   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
10926     return FALSE;
10927   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
10928     return FALSE;
10929   if (!KnownExtensionDecode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs))
10930     return FALSE;
10931   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
10932     return FALSE;
10933   if (!KnownExtensionDecode(strm, e_gatewayDataRate, m_gatewayDataRate))
10934     return FALSE;
10935   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
10936     return FALSE;
10937   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
10938     return FALSE;
10939   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
10940     return FALSE;
10941   if (!KnownExtensionDecode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol))
10942     return FALSE;
10943   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
10944     return FALSE;
10945   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
10946     return FALSE;
10947   if (!KnownExtensionDecode(strm, e_canMapSrcAlias, m_canMapSrcAlias))
10948     return FALSE;
10949
10950   return UnknownExtensionsDecode(strm);
10951 }
10952
10953
10954 void H225_AdmissionRequest::Encode(PASN_Stream & strm) const
10955 {
10956   PreambleEncode(strm);
10957
10958   m_requestSeqNum.Encode(strm);
10959   m_callType.Encode(strm);
10960   if (HasOptionalField(e_callModel))
10961     m_callModel.Encode(strm);
10962   m_endpointIdentifier.Encode(strm);
10963   if (HasOptionalField(e_destinationInfo))
10964     m_destinationInfo.Encode(strm);
10965   if (HasOptionalField(e_destCallSignalAddress))
10966     m_destCallSignalAddress.Encode(strm);
10967   if (HasOptionalField(e_destExtraCallInfo))
10968     m_destExtraCallInfo.Encode(strm);
10969   m_srcInfo.Encode(strm);
10970   if (HasOptionalField(e_srcCallSignalAddress))
10971     m_srcCallSignalAddress.Encode(strm);
10972   m_bandWidth.Encode(strm);
10973   m_callReferenceValue.Encode(strm);
10974   if (HasOptionalField(e_nonStandardData))
10975     m_nonStandardData.Encode(strm);
10976   if (HasOptionalField(e_callServices))
10977     m_callServices.Encode(strm);
10978   m_conferenceID.Encode(strm);
10979   m_activeMC.Encode(strm);
10980   m_answerCall.Encode(strm);
10981   KnownExtensionEncode(strm, e_canMapAlias, m_canMapAlias);
10982   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
10983   KnownExtensionEncode(strm, e_srcAlternatives, m_srcAlternatives);
10984   KnownExtensionEncode(strm, e_destAlternatives, m_destAlternatives);
10985   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
10986   KnownExtensionEncode(strm, e_tokens, m_tokens);
10987   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
10988   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
10989   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
10990   KnownExtensionEncode(strm, e_willSupplyUUIEs, m_willSupplyUUIEs);
10991   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
10992   KnownExtensionEncode(strm, e_gatewayDataRate, m_gatewayDataRate);
10993   KnownExtensionEncode(strm, e_capacity, m_capacity);
10994   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
10995   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
10996   KnownExtensionEncode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol);
10997   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
10998   KnownExtensionEncode(strm, e_genericData, m_genericData);
10999   KnownExtensionEncode(strm, e_canMapSrcAlias, m_canMapSrcAlias);
11000
11001   UnknownExtensionsEncode(strm);
11002 }
11003
11004
11005 PObject * H225_AdmissionRequest::Clone() const
11006 {
11007 #ifndef PASN_LEANANDMEAN
11008   PAssert(IsClass(H225_AdmissionRequest::Class()), PInvalidCast);
11009 #endif
11010   return new H225_AdmissionRequest(*this);
11011 }
11012
11013
11014 //
11015 // AdmissionConfirm
11016 //
11017
11018 H225_AdmissionConfirm::H225_AdmissionConfirm(unsigned tag, PASN_Object::TagClass tagClass)
11019   : PASN_Sequence(tag, tagClass, 2, TRUE, 23)
11020 {
11021   m_irrFrequency.SetConstraints(PASN_Object::FixedConstraint, 1, 65535);
11022   IncludeOptionalField(e_willRespondToIRR);
11023   IncludeOptionalField(e_uuiesRequested);
11024 }
11025
11026
11027 #ifndef PASN_NOPRINTON
11028 void H225_AdmissionConfirm::PrintOn(ostream & strm) const
11029 {
11030   int indent = strm.precision() + 2;
11031   strm << "{\n";
11032   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11033   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
11034   strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
11035   strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
11036   if (HasOptionalField(e_irrFrequency))
11037     strm << setw(indent+15) << "irrFrequency = " << setprecision(indent) << m_irrFrequency << '\n';
11038   if (HasOptionalField(e_nonStandardData))
11039     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11040   if (HasOptionalField(e_destinationInfo))
11041     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
11042   if (HasOptionalField(e_destExtraCallInfo))
11043     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
11044   if (HasOptionalField(e_destinationType))
11045     strm << setw(indent+18) << "destinationType = " << setprecision(indent) << m_destinationType << '\n';
11046   if (HasOptionalField(e_remoteExtensionAddress))
11047     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
11048   if (HasOptionalField(e_alternateEndpoints))
11049     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
11050   if (HasOptionalField(e_tokens))
11051     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11052   if (HasOptionalField(e_cryptoTokens))
11053     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11054   if (HasOptionalField(e_integrityCheckValue))
11055     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11056   if (HasOptionalField(e_transportQOS))
11057     strm << setw(indent+15) << "transportQOS = " << setprecision(indent) << m_transportQOS << '\n';
11058   if (HasOptionalField(e_willRespondToIRR))
11059     strm << setw(indent+19) << "willRespondToIRR = " << setprecision(indent) << m_willRespondToIRR << '\n';
11060   if (HasOptionalField(e_uuiesRequested))
11061     strm << setw(indent+17) << "uuiesRequested = " << setprecision(indent) << m_uuiesRequested << '\n';
11062   if (HasOptionalField(e_language))
11063     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
11064   if (HasOptionalField(e_alternateTransportAddresses))
11065     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
11066   if (HasOptionalField(e_useSpecifiedTransport))
11067     strm << setw(indent+24) << "useSpecifiedTransport = " << setprecision(indent) << m_useSpecifiedTransport << '\n';
11068   if (HasOptionalField(e_circuitInfo))
11069     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
11070   if (HasOptionalField(e_usageSpec))
11071     strm << setw(indent+12) << "usageSpec = " << setprecision(indent) << m_usageSpec << '\n';
11072   if (HasOptionalField(e_supportedProtocols))
11073     strm << setw(indent+21) << "supportedProtocols = " << setprecision(indent) << m_supportedProtocols << '\n';
11074   if (HasOptionalField(e_serviceControl))
11075     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
11076   if (HasOptionalField(e_multipleCalls))
11077     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
11078   if (HasOptionalField(e_featureSet))
11079     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
11080   if (HasOptionalField(e_genericData))
11081     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11082   if (HasOptionalField(e_modifiedSrcInfo))
11083     strm << setw(indent+18) << "modifiedSrcInfo = " << setprecision(indent) << m_modifiedSrcInfo << '\n';
11084   if (HasOptionalField(e_assignedGatekeeper))
11085     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
11086   strm << setw(indent-1) << setprecision(indent-2) << "}";
11087 }
11088 #endif
11089
11090
11091 PObject::Comparison H225_AdmissionConfirm::Compare(const PObject & obj) const
11092 {
11093 #ifndef PASN_LEANANDMEAN
11094   PAssert(PIsDescendant(&obj, H225_AdmissionConfirm), PInvalidCast);
11095 #endif
11096   const H225_AdmissionConfirm & other = (const H225_AdmissionConfirm &)obj;
11097
11098   Comparison result;
11099
11100   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
11101     return result;
11102   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
11103     return result;
11104   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
11105     return result;
11106   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
11107     return result;
11108   if ((result = m_irrFrequency.Compare(other.m_irrFrequency)) != EqualTo)
11109     return result;
11110   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11111     return result;
11112
11113   return PASN_Sequence::Compare(other);
11114 }
11115
11116
11117 PINDEX H225_AdmissionConfirm::GetDataLength() const
11118 {
11119   PINDEX length = 0;
11120   length += m_requestSeqNum.GetObjectLength();
11121   length += m_bandWidth.GetObjectLength();
11122   length += m_callModel.GetObjectLength();
11123   length += m_destCallSignalAddress.GetObjectLength();
11124   if (HasOptionalField(e_irrFrequency))
11125     length += m_irrFrequency.GetObjectLength();
11126   if (HasOptionalField(e_nonStandardData))
11127     length += m_nonStandardData.GetObjectLength();
11128   return length;
11129 }
11130
11131
11132 BOOL H225_AdmissionConfirm::Decode(PASN_Stream & strm)
11133 {
11134   if (!PreambleDecode(strm))
11135     return FALSE;
11136
11137   if (!m_requestSeqNum.Decode(strm))
11138     return FALSE;
11139   if (!m_bandWidth.Decode(strm))
11140     return FALSE;
11141   if (!m_callModel.Decode(strm))
11142     return FALSE;
11143   if (!m_destCallSignalAddress.Decode(strm))
11144     return FALSE;
11145   if (HasOptionalField(e_irrFrequency) && !m_irrFrequency.Decode(strm))
11146     return FALSE;
11147   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11148     return FALSE;
11149   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
11150     return FALSE;
11151   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
11152     return FALSE;
11153   if (!KnownExtensionDecode(strm, e_destinationType, m_destinationType))
11154     return FALSE;
11155   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
11156     return FALSE;
11157   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
11158     return FALSE;
11159   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
11160     return FALSE;
11161   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
11162     return FALSE;
11163   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
11164     return FALSE;
11165   if (!KnownExtensionDecode(strm, e_transportQOS, m_transportQOS))
11166     return FALSE;
11167   if (!KnownExtensionDecode(strm, e_willRespondToIRR, m_willRespondToIRR))
11168     return FALSE;
11169   if (!KnownExtensionDecode(strm, e_uuiesRequested, m_uuiesRequested))
11170     return FALSE;
11171   if (!KnownExtensionDecode(strm, e_language, m_language))
11172     return FALSE;
11173   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
11174     return FALSE;
11175   if (!KnownExtensionDecode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport))
11176     return FALSE;
11177   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
11178     return FALSE;
11179   if (!KnownExtensionDecode(strm, e_usageSpec, m_usageSpec))
11180     return FALSE;
11181   if (!KnownExtensionDecode(strm, e_supportedProtocols, m_supportedProtocols))
11182     return FALSE;
11183   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
11184     return FALSE;
11185   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
11186     return FALSE;
11187   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
11188     return FALSE;
11189   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
11190     return FALSE;
11191   if (!KnownExtensionDecode(strm, e_modifiedSrcInfo, m_modifiedSrcInfo))
11192     return FALSE;
11193   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
11194     return FALSE;
11195
11196   return UnknownExtensionsDecode(strm);
11197 }
11198
11199
11200 void H225_AdmissionConfirm::Encode(PASN_Stream & strm) const
11201 {
11202   PreambleEncode(strm);
11203
11204   m_requestSeqNum.Encode(strm);
11205   m_bandWidth.Encode(strm);
11206   m_callModel.Encode(strm);
11207   m_destCallSignalAddress.Encode(strm);
11208   if (HasOptionalField(e_irrFrequency))
11209     m_irrFrequency.Encode(strm);
11210   if (HasOptionalField(e_nonStandardData))
11211     m_nonStandardData.Encode(strm);
11212   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
11213   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
11214   KnownExtensionEncode(strm, e_destinationType, m_destinationType);
11215   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
11216   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
11217   KnownExtensionEncode(strm, e_tokens, m_tokens);
11218   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
11219   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
11220   KnownExtensionEncode(strm, e_transportQOS, m_transportQOS);
11221   KnownExtensionEncode(strm, e_willRespondToIRR, m_willRespondToIRR);
11222   KnownExtensionEncode(strm, e_uuiesRequested, m_uuiesRequested);
11223   KnownExtensionEncode(strm, e_language, m_language);
11224   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
11225   KnownExtensionEncode(strm, e_useSpecifiedTransport, m_useSpecifiedTransport);
11226   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
11227   KnownExtensionEncode(strm, e_usageSpec, m_usageSpec);
11228   KnownExtensionEncode(strm, e_supportedProtocols, m_supportedProtocols);
11229   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
11230   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
11231   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
11232   KnownExtensionEncode(strm, e_genericData, m_genericData);
11233   KnownExtensionEncode(strm, e_modifiedSrcInfo, m_modifiedSrcInfo);
11234   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
11235
11236   UnknownExtensionsEncode(strm);
11237 }
11238
11239
11240 PObject * H225_AdmissionConfirm::Clone() const
11241 {
11242 #ifndef PASN_LEANANDMEAN
11243   PAssert(IsClass(H225_AdmissionConfirm::Class()), PInvalidCast);
11244 #endif
11245   return new H225_AdmissionConfirm(*this);
11246 }
11247
11248
11249 //
11250 // LocationRequest
11251 //
11252
11253 H225_LocationRequest::H225_LocationRequest(unsigned tag, PASN_Object::TagClass tagClass)
11254   : PASN_Sequence(tag, tagClass, 2, TRUE, 17)
11255 {
11256   IncludeOptionalField(e_canMapAlias);
11257   m_hopCount.SetConstraints(PASN_Object::FixedConstraint, 1, 255);
11258   IncludeOptionalField(e_canMapSrcAlias);
11259 }
11260
11261
11262 #ifndef PASN_NOPRINTON
11263 void H225_LocationRequest::PrintOn(ostream & strm) const
11264 {
11265   int indent = strm.precision() + 2;
11266   strm << "{\n";
11267   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11268   if (HasOptionalField(e_endpointIdentifier))
11269     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
11270   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
11271   if (HasOptionalField(e_nonStandardData))
11272     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11273   strm << setw(indent+15) << "replyAddress = " << setprecision(indent) << m_replyAddress << '\n';
11274   if (HasOptionalField(e_sourceInfo))
11275     strm << setw(indent+13) << "sourceInfo = " << setprecision(indent) << m_sourceInfo << '\n';
11276   if (HasOptionalField(e_canMapAlias))
11277     strm << setw(indent+14) << "canMapAlias = " << setprecision(indent) << m_canMapAlias << '\n';
11278   if (HasOptionalField(e_gatekeeperIdentifier))
11279     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
11280   if (HasOptionalField(e_tokens))
11281     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11282   if (HasOptionalField(e_cryptoTokens))
11283     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11284   if (HasOptionalField(e_integrityCheckValue))
11285     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11286   if (HasOptionalField(e_desiredProtocols))
11287     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
11288   if (HasOptionalField(e_desiredTunnelledProtocol))
11289     strm << setw(indent+27) << "desiredTunnelledProtocol = " << setprecision(indent) << m_desiredTunnelledProtocol << '\n';
11290   if (HasOptionalField(e_featureSet))
11291     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
11292   if (HasOptionalField(e_genericData))
11293     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11294   if (HasOptionalField(e_hopCount))
11295     strm << setw(indent+11) << "hopCount = " << setprecision(indent) << m_hopCount << '\n';
11296   if (HasOptionalField(e_circuitInfo))
11297     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
11298   if (HasOptionalField(e_callIdentifier))
11299     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
11300   if (HasOptionalField(e_bandWidth))
11301     strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
11302   if (HasOptionalField(e_sourceEndpointInfo))
11303     strm << setw(indent+21) << "sourceEndpointInfo = " << setprecision(indent) << m_sourceEndpointInfo << '\n';
11304   if (HasOptionalField(e_canMapSrcAlias))
11305     strm << setw(indent+17) << "canMapSrcAlias = " << setprecision(indent) << m_canMapSrcAlias << '\n';
11306   if (HasOptionalField(e_language))
11307     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
11308   strm << setw(indent-1) << setprecision(indent-2) << "}";
11309 }
11310 #endif
11311
11312
11313 PObject::Comparison H225_LocationRequest::Compare(const PObject & obj) const
11314 {
11315 #ifndef PASN_LEANANDMEAN
11316   PAssert(PIsDescendant(&obj, H225_LocationRequest), PInvalidCast);
11317 #endif
11318   const H225_LocationRequest & other = (const H225_LocationRequest &)obj;
11319
11320   Comparison result;
11321
11322   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
11323     return result;
11324   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
11325     return result;
11326   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
11327     return result;
11328   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11329     return result;
11330   if ((result = m_replyAddress.Compare(other.m_replyAddress)) != EqualTo)
11331     return result;
11332
11333   return PASN_Sequence::Compare(other);
11334 }
11335
11336
11337 PINDEX H225_LocationRequest::GetDataLength() const
11338 {
11339   PINDEX length = 0;
11340   length += m_requestSeqNum.GetObjectLength();
11341   if (HasOptionalField(e_endpointIdentifier))
11342     length += m_endpointIdentifier.GetObjectLength();
11343   length += m_destinationInfo.GetObjectLength();
11344   if (HasOptionalField(e_nonStandardData))
11345     length += m_nonStandardData.GetObjectLength();
11346   length += m_replyAddress.GetObjectLength();
11347   return length;
11348 }
11349
11350
11351 BOOL H225_LocationRequest::Decode(PASN_Stream & strm)
11352 {
11353   if (!PreambleDecode(strm))
11354     return FALSE;
11355
11356   if (!m_requestSeqNum.Decode(strm))
11357     return FALSE;
11358   if (HasOptionalField(e_endpointIdentifier) && !m_endpointIdentifier.Decode(strm))
11359     return FALSE;
11360   if (!m_destinationInfo.Decode(strm))
11361     return FALSE;
11362   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11363     return FALSE;
11364   if (!m_replyAddress.Decode(strm))
11365     return FALSE;
11366   if (!KnownExtensionDecode(strm, e_sourceInfo, m_sourceInfo))
11367     return FALSE;
11368   if (!KnownExtensionDecode(strm, e_canMapAlias, m_canMapAlias))
11369     return FALSE;
11370   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
11371     return FALSE;
11372   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
11373     return FALSE;
11374   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
11375     return FALSE;
11376   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
11377     return FALSE;
11378   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
11379     return FALSE;
11380   if (!KnownExtensionDecode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol))
11381     return FALSE;
11382   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
11383     return FALSE;
11384   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
11385     return FALSE;
11386   if (!KnownExtensionDecode(strm, e_hopCount, m_hopCount))
11387     return FALSE;
11388   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
11389     return FALSE;
11390   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
11391     return FALSE;
11392   if (!KnownExtensionDecode(strm, e_bandWidth, m_bandWidth))
11393     return FALSE;
11394   if (!KnownExtensionDecode(strm, e_sourceEndpointInfo, m_sourceEndpointInfo))
11395     return FALSE;
11396   if (!KnownExtensionDecode(strm, e_canMapSrcAlias, m_canMapSrcAlias))
11397     return FALSE;
11398   if (!KnownExtensionDecode(strm, e_language, m_language))
11399     return FALSE;
11400
11401   return UnknownExtensionsDecode(strm);
11402 }
11403
11404
11405 void H225_LocationRequest::Encode(PASN_Stream & strm) const
11406 {
11407   PreambleEncode(strm);
11408
11409   m_requestSeqNum.Encode(strm);
11410   if (HasOptionalField(e_endpointIdentifier))
11411     m_endpointIdentifier.Encode(strm);
11412   m_destinationInfo.Encode(strm);
11413   if (HasOptionalField(e_nonStandardData))
11414     m_nonStandardData.Encode(strm);
11415   m_replyAddress.Encode(strm);
11416   KnownExtensionEncode(strm, e_sourceInfo, m_sourceInfo);
11417   KnownExtensionEncode(strm, e_canMapAlias, m_canMapAlias);
11418   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
11419   KnownExtensionEncode(strm, e_tokens, m_tokens);
11420   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
11421   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
11422   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
11423   KnownExtensionEncode(strm, e_desiredTunnelledProtocol, m_desiredTunnelledProtocol);
11424   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
11425   KnownExtensionEncode(strm, e_genericData, m_genericData);
11426   KnownExtensionEncode(strm, e_hopCount, m_hopCount);
11427   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
11428   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
11429   KnownExtensionEncode(strm, e_bandWidth, m_bandWidth);
11430   KnownExtensionEncode(strm, e_sourceEndpointInfo, m_sourceEndpointInfo);
11431   KnownExtensionEncode(strm, e_canMapSrcAlias, m_canMapSrcAlias);
11432   KnownExtensionEncode(strm, e_language, m_language);
11433
11434   UnknownExtensionsEncode(strm);
11435 }
11436
11437
11438 PObject * H225_LocationRequest::Clone() const
11439 {
11440 #ifndef PASN_LEANANDMEAN
11441   PAssert(IsClass(H225_LocationRequest::Class()), PInvalidCast);
11442 #endif
11443   return new H225_LocationRequest(*this);
11444 }
11445
11446
11447 //
11448 // LocationConfirm
11449 //
11450
11451 H225_LocationConfirm::H225_LocationConfirm(unsigned tag, PASN_Object::TagClass tagClass)
11452   : PASN_Sequence(tag, tagClass, 1, TRUE, 17)
11453 {
11454 }
11455
11456
11457 #ifndef PASN_NOPRINTON
11458 void H225_LocationConfirm::PrintOn(ostream & strm) const
11459 {
11460   int indent = strm.precision() + 2;
11461   strm << "{\n";
11462   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11463   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
11464   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
11465   if (HasOptionalField(e_nonStandardData))
11466     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11467   if (HasOptionalField(e_destinationInfo))
11468     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
11469   if (HasOptionalField(e_destExtraCallInfo))
11470     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
11471   if (HasOptionalField(e_destinationType))
11472     strm << setw(indent+18) << "destinationType = " << setprecision(indent) << m_destinationType << '\n';
11473   if (HasOptionalField(e_remoteExtensionAddress))
11474     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
11475   if (HasOptionalField(e_alternateEndpoints))
11476     strm << setw(indent+21) << "alternateEndpoints = " << setprecision(indent) << m_alternateEndpoints << '\n';
11477   if (HasOptionalField(e_tokens))
11478     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11479   if (HasOptionalField(e_cryptoTokens))
11480     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11481   if (HasOptionalField(e_integrityCheckValue))
11482     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11483   if (HasOptionalField(e_alternateTransportAddresses))
11484     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
11485   if (HasOptionalField(e_supportedProtocols))
11486     strm << setw(indent+21) << "supportedProtocols = " << setprecision(indent) << m_supportedProtocols << '\n';
11487   if (HasOptionalField(e_multipleCalls))
11488     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
11489   if (HasOptionalField(e_featureSet))
11490     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
11491   if (HasOptionalField(e_genericData))
11492     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11493   if (HasOptionalField(e_circuitInfo))
11494     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
11495   if (HasOptionalField(e_serviceControl))
11496     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
11497   if (HasOptionalField(e_modifiedSrcInfo))
11498     strm << setw(indent+18) << "modifiedSrcInfo = " << setprecision(indent) << m_modifiedSrcInfo << '\n';
11499   if (HasOptionalField(e_bandWidth))
11500     strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
11501   strm << setw(indent-1) << setprecision(indent-2) << "}";
11502 }
11503 #endif
11504
11505
11506 PObject::Comparison H225_LocationConfirm::Compare(const PObject & obj) const
11507 {
11508 #ifndef PASN_LEANANDMEAN
11509   PAssert(PIsDescendant(&obj, H225_LocationConfirm), PInvalidCast);
11510 #endif
11511   const H225_LocationConfirm & other = (const H225_LocationConfirm &)obj;
11512
11513   Comparison result;
11514
11515   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
11516     return result;
11517   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
11518     return result;
11519   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
11520     return result;
11521   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11522     return result;
11523
11524   return PASN_Sequence::Compare(other);
11525 }
11526
11527
11528 PINDEX H225_LocationConfirm::GetDataLength() const
11529 {
11530   PINDEX length = 0;
11531   length += m_requestSeqNum.GetObjectLength();
11532   length += m_callSignalAddress.GetObjectLength();
11533   length += m_rasAddress.GetObjectLength();
11534   if (HasOptionalField(e_nonStandardData))
11535     length += m_nonStandardData.GetObjectLength();
11536   return length;
11537 }
11538
11539
11540 BOOL H225_LocationConfirm::Decode(PASN_Stream & strm)
11541 {
11542   if (!PreambleDecode(strm))
11543     return FALSE;
11544
11545   if (!m_requestSeqNum.Decode(strm))
11546     return FALSE;
11547   if (!m_callSignalAddress.Decode(strm))
11548     return FALSE;
11549   if (!m_rasAddress.Decode(strm))
11550     return FALSE;
11551   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11552     return FALSE;
11553   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
11554     return FALSE;
11555   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
11556     return FALSE;
11557   if (!KnownExtensionDecode(strm, e_destinationType, m_destinationType))
11558     return FALSE;
11559   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
11560     return FALSE;
11561   if (!KnownExtensionDecode(strm, e_alternateEndpoints, m_alternateEndpoints))
11562     return FALSE;
11563   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
11564     return FALSE;
11565   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
11566     return FALSE;
11567   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
11568     return FALSE;
11569   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
11570     return FALSE;
11571   if (!KnownExtensionDecode(strm, e_supportedProtocols, m_supportedProtocols))
11572     return FALSE;
11573   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
11574     return FALSE;
11575   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
11576     return FALSE;
11577   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
11578     return FALSE;
11579   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
11580     return FALSE;
11581   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
11582     return FALSE;
11583   if (!KnownExtensionDecode(strm, e_modifiedSrcInfo, m_modifiedSrcInfo))
11584     return FALSE;
11585   if (!KnownExtensionDecode(strm, e_bandWidth, m_bandWidth))
11586     return FALSE;
11587
11588   return UnknownExtensionsDecode(strm);
11589 }
11590
11591
11592 void H225_LocationConfirm::Encode(PASN_Stream & strm) const
11593 {
11594   PreambleEncode(strm);
11595
11596   m_requestSeqNum.Encode(strm);
11597   m_callSignalAddress.Encode(strm);
11598   m_rasAddress.Encode(strm);
11599   if (HasOptionalField(e_nonStandardData))
11600     m_nonStandardData.Encode(strm);
11601   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
11602   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
11603   KnownExtensionEncode(strm, e_destinationType, m_destinationType);
11604   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
11605   KnownExtensionEncode(strm, e_alternateEndpoints, m_alternateEndpoints);
11606   KnownExtensionEncode(strm, e_tokens, m_tokens);
11607   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
11608   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
11609   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
11610   KnownExtensionEncode(strm, e_supportedProtocols, m_supportedProtocols);
11611   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
11612   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
11613   KnownExtensionEncode(strm, e_genericData, m_genericData);
11614   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
11615   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
11616   KnownExtensionEncode(strm, e_modifiedSrcInfo, m_modifiedSrcInfo);
11617   KnownExtensionEncode(strm, e_bandWidth, m_bandWidth);
11618
11619   UnknownExtensionsEncode(strm);
11620 }
11621
11622
11623 PObject * H225_LocationConfirm::Clone() const
11624 {
11625 #ifndef PASN_LEANANDMEAN
11626   PAssert(IsClass(H225_LocationConfirm::Class()), PInvalidCast);
11627 #endif
11628   return new H225_LocationConfirm(*this);
11629 }
11630
11631
11632 //
11633 // DisengageRequest
11634 //
11635
11636 H225_DisengageRequest::H225_DisengageRequest(unsigned tag, PASN_Object::TagClass tagClass)
11637   : PASN_Sequence(tag, tagClass, 1, TRUE, 13)
11638 {
11639   IncludeOptionalField(e_callIdentifier);
11640   IncludeOptionalField(e_answeredCall);
11641 }
11642
11643
11644 #ifndef PASN_NOPRINTON
11645 void H225_DisengageRequest::PrintOn(ostream & strm) const
11646 {
11647   int indent = strm.precision() + 2;
11648   strm << "{\n";
11649   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11650   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
11651   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
11652   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
11653   strm << setw(indent+18) << "disengageReason = " << setprecision(indent) << m_disengageReason << '\n';
11654   if (HasOptionalField(e_nonStandardData))
11655     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11656   if (HasOptionalField(e_callIdentifier))
11657     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
11658   if (HasOptionalField(e_gatekeeperIdentifier))
11659     strm << setw(indent+23) << "gatekeeperIdentifier = " << setprecision(indent) << m_gatekeeperIdentifier << '\n';
11660   if (HasOptionalField(e_tokens))
11661     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11662   if (HasOptionalField(e_cryptoTokens))
11663     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11664   if (HasOptionalField(e_integrityCheckValue))
11665     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11666   if (HasOptionalField(e_answeredCall))
11667     strm << setw(indent+15) << "answeredCall = " << setprecision(indent) << m_answeredCall << '\n';
11668   if (HasOptionalField(e_callLinkage))
11669     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
11670   if (HasOptionalField(e_capacity))
11671     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
11672   if (HasOptionalField(e_circuitInfo))
11673     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
11674   if (HasOptionalField(e_usageInformation))
11675     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
11676   if (HasOptionalField(e_terminationCause))
11677     strm << setw(indent+19) << "terminationCause = " << setprecision(indent) << m_terminationCause << '\n';
11678   if (HasOptionalField(e_serviceControl))
11679     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
11680   if (HasOptionalField(e_genericData))
11681     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11682   strm << setw(indent-1) << setprecision(indent-2) << "}";
11683 }
11684 #endif
11685
11686
11687 PObject::Comparison H225_DisengageRequest::Compare(const PObject & obj) const
11688 {
11689 #ifndef PASN_LEANANDMEAN
11690   PAssert(PIsDescendant(&obj, H225_DisengageRequest), PInvalidCast);
11691 #endif
11692   const H225_DisengageRequest & other = (const H225_DisengageRequest &)obj;
11693
11694   Comparison result;
11695
11696   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
11697     return result;
11698   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
11699     return result;
11700   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
11701     return result;
11702   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
11703     return result;
11704   if ((result = m_disengageReason.Compare(other.m_disengageReason)) != EqualTo)
11705     return result;
11706   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11707     return result;
11708
11709   return PASN_Sequence::Compare(other);
11710 }
11711
11712
11713 PINDEX H225_DisengageRequest::GetDataLength() const
11714 {
11715   PINDEX length = 0;
11716   length += m_requestSeqNum.GetObjectLength();
11717   length += m_endpointIdentifier.GetObjectLength();
11718   length += m_conferenceID.GetObjectLength();
11719   length += m_callReferenceValue.GetObjectLength();
11720   length += m_disengageReason.GetObjectLength();
11721   if (HasOptionalField(e_nonStandardData))
11722     length += m_nonStandardData.GetObjectLength();
11723   return length;
11724 }
11725
11726
11727 BOOL H225_DisengageRequest::Decode(PASN_Stream & strm)
11728 {
11729   if (!PreambleDecode(strm))
11730     return FALSE;
11731
11732   if (!m_requestSeqNum.Decode(strm))
11733     return FALSE;
11734   if (!m_endpointIdentifier.Decode(strm))
11735     return FALSE;
11736   if (!m_conferenceID.Decode(strm))
11737     return FALSE;
11738   if (!m_callReferenceValue.Decode(strm))
11739     return FALSE;
11740   if (!m_disengageReason.Decode(strm))
11741     return FALSE;
11742   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11743     return FALSE;
11744   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
11745     return FALSE;
11746   if (!KnownExtensionDecode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier))
11747     return FALSE;
11748   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
11749     return FALSE;
11750   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
11751     return FALSE;
11752   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
11753     return FALSE;
11754   if (!KnownExtensionDecode(strm, e_answeredCall, m_answeredCall))
11755     return FALSE;
11756   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
11757     return FALSE;
11758   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
11759     return FALSE;
11760   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
11761     return FALSE;
11762   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
11763     return FALSE;
11764   if (!KnownExtensionDecode(strm, e_terminationCause, m_terminationCause))
11765     return FALSE;
11766   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
11767     return FALSE;
11768   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
11769     return FALSE;
11770
11771   return UnknownExtensionsDecode(strm);
11772 }
11773
11774
11775 void H225_DisengageRequest::Encode(PASN_Stream & strm) const
11776 {
11777   PreambleEncode(strm);
11778
11779   m_requestSeqNum.Encode(strm);
11780   m_endpointIdentifier.Encode(strm);
11781   m_conferenceID.Encode(strm);
11782   m_callReferenceValue.Encode(strm);
11783   m_disengageReason.Encode(strm);
11784   if (HasOptionalField(e_nonStandardData))
11785     m_nonStandardData.Encode(strm);
11786   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
11787   KnownExtensionEncode(strm, e_gatekeeperIdentifier, m_gatekeeperIdentifier);
11788   KnownExtensionEncode(strm, e_tokens, m_tokens);
11789   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
11790   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
11791   KnownExtensionEncode(strm, e_answeredCall, m_answeredCall);
11792   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
11793   KnownExtensionEncode(strm, e_capacity, m_capacity);
11794   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
11795   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
11796   KnownExtensionEncode(strm, e_terminationCause, m_terminationCause);
11797   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
11798   KnownExtensionEncode(strm, e_genericData, m_genericData);
11799
11800   UnknownExtensionsEncode(strm);
11801 }
11802
11803
11804 PObject * H225_DisengageRequest::Clone() const
11805 {
11806 #ifndef PASN_LEANANDMEAN
11807   PAssert(IsClass(H225_DisengageRequest::Class()), PInvalidCast);
11808 #endif
11809   return new H225_DisengageRequest(*this);
11810 }
11811
11812
11813 //
11814 // DisengageConfirm
11815 //
11816
11817 H225_DisengageConfirm::H225_DisengageConfirm(unsigned tag, PASN_Object::TagClass tagClass)
11818   : PASN_Sequence(tag, tagClass, 1, TRUE, 8)
11819 {
11820 }
11821
11822
11823 #ifndef PASN_NOPRINTON
11824 void H225_DisengageConfirm::PrintOn(ostream & strm) const
11825 {
11826   int indent = strm.precision() + 2;
11827   strm << "{\n";
11828   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11829   if (HasOptionalField(e_nonStandardData))
11830     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11831   if (HasOptionalField(e_tokens))
11832     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11833   if (HasOptionalField(e_cryptoTokens))
11834     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11835   if (HasOptionalField(e_integrityCheckValue))
11836     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11837   if (HasOptionalField(e_capacity))
11838     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
11839   if (HasOptionalField(e_circuitInfo))
11840     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
11841   if (HasOptionalField(e_usageInformation))
11842     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
11843   if (HasOptionalField(e_genericData))
11844     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11845   if (HasOptionalField(e_assignedGatekeeper))
11846     strm << setw(indent+21) << "assignedGatekeeper = " << setprecision(indent) << m_assignedGatekeeper << '\n';
11847   strm << setw(indent-1) << setprecision(indent-2) << "}";
11848 }
11849 #endif
11850
11851
11852 PObject::Comparison H225_DisengageConfirm::Compare(const PObject & obj) const
11853 {
11854 #ifndef PASN_LEANANDMEAN
11855   PAssert(PIsDescendant(&obj, H225_DisengageConfirm), PInvalidCast);
11856 #endif
11857   const H225_DisengageConfirm & other = (const H225_DisengageConfirm &)obj;
11858
11859   Comparison result;
11860
11861   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
11862     return result;
11863   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11864     return result;
11865
11866   return PASN_Sequence::Compare(other);
11867 }
11868
11869
11870 PINDEX H225_DisengageConfirm::GetDataLength() const
11871 {
11872   PINDEX length = 0;
11873   length += m_requestSeqNum.GetObjectLength();
11874   if (HasOptionalField(e_nonStandardData))
11875     length += m_nonStandardData.GetObjectLength();
11876   return length;
11877 }
11878
11879
11880 BOOL H225_DisengageConfirm::Decode(PASN_Stream & strm)
11881 {
11882   if (!PreambleDecode(strm))
11883     return FALSE;
11884
11885   if (!m_requestSeqNum.Decode(strm))
11886     return FALSE;
11887   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
11888     return FALSE;
11889   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
11890     return FALSE;
11891   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
11892     return FALSE;
11893   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
11894     return FALSE;
11895   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
11896     return FALSE;
11897   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
11898     return FALSE;
11899   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
11900     return FALSE;
11901   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
11902     return FALSE;
11903   if (!KnownExtensionDecode(strm, e_assignedGatekeeper, m_assignedGatekeeper))
11904     return FALSE;
11905
11906   return UnknownExtensionsDecode(strm);
11907 }
11908
11909
11910 void H225_DisengageConfirm::Encode(PASN_Stream & strm) const
11911 {
11912   PreambleEncode(strm);
11913
11914   m_requestSeqNum.Encode(strm);
11915   if (HasOptionalField(e_nonStandardData))
11916     m_nonStandardData.Encode(strm);
11917   KnownExtensionEncode(strm, e_tokens, m_tokens);
11918   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
11919   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
11920   KnownExtensionEncode(strm, e_capacity, m_capacity);
11921   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
11922   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
11923   KnownExtensionEncode(strm, e_genericData, m_genericData);
11924   KnownExtensionEncode(strm, e_assignedGatekeeper, m_assignedGatekeeper);
11925
11926   UnknownExtensionsEncode(strm);
11927 }
11928
11929
11930 PObject * H225_DisengageConfirm::Clone() const
11931 {
11932 #ifndef PASN_LEANANDMEAN
11933   PAssert(IsClass(H225_DisengageConfirm::Class()), PInvalidCast);
11934 #endif
11935   return new H225_DisengageConfirm(*this);
11936 }
11937
11938
11939 //
11940 // InfoRequestResponse
11941 //
11942
11943 H225_InfoRequestResponse::H225_InfoRequestResponse(unsigned tag, PASN_Object::TagClass tagClass)
11944   : PASN_Sequence(tag, tagClass, 3, TRUE, 8)
11945 {
11946   IncludeOptionalField(e_needResponse);
11947   IncludeOptionalField(e_unsolicited);
11948 }
11949
11950
11951 #ifndef PASN_NOPRINTON
11952 void H225_InfoRequestResponse::PrintOn(ostream & strm) const
11953 {
11954   int indent = strm.precision() + 2;
11955   strm << "{\n";
11956   if (HasOptionalField(e_nonStandardData))
11957     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
11958   strm << setw(indent+16) << "requestSeqNum = " << setprecision(indent) << m_requestSeqNum << '\n';
11959   strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
11960   strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
11961   strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
11962   strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
11963   if (HasOptionalField(e_endpointAlias))
11964     strm << setw(indent+16) << "endpointAlias = " << setprecision(indent) << m_endpointAlias << '\n';
11965   if (HasOptionalField(e_perCallInfo))
11966     strm << setw(indent+14) << "perCallInfo = " << setprecision(indent) << m_perCallInfo << '\n';
11967   if (HasOptionalField(e_tokens))
11968     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
11969   if (HasOptionalField(e_cryptoTokens))
11970     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
11971   if (HasOptionalField(e_integrityCheckValue))
11972     strm << setw(indent+22) << "integrityCheckValue = " << setprecision(indent) << m_integrityCheckValue << '\n';
11973   if (HasOptionalField(e_needResponse))
11974     strm << setw(indent+15) << "needResponse = " << setprecision(indent) << m_needResponse << '\n';
11975   if (HasOptionalField(e_capacity))
11976     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
11977   if (HasOptionalField(e_irrStatus))
11978     strm << setw(indent+12) << "irrStatus = " << setprecision(indent) << m_irrStatus << '\n';
11979   if (HasOptionalField(e_unsolicited))
11980     strm << setw(indent+14) << "unsolicited = " << setprecision(indent) << m_unsolicited << '\n';
11981   if (HasOptionalField(e_genericData))
11982     strm << setw(indent+14) << "genericData = " << setprecision(indent) << m_genericData << '\n';
11983   strm << setw(indent-1) << setprecision(indent-2) << "}";
11984 }
11985 #endif
11986
11987
11988 PObject::Comparison H225_InfoRequestResponse::Compare(const PObject & obj) const
11989 {
11990 #ifndef PASN_LEANANDMEAN
11991   PAssert(PIsDescendant(&obj, H225_InfoRequestResponse), PInvalidCast);
11992 #endif
11993   const H225_InfoRequestResponse & other = (const H225_InfoRequestResponse &)obj;
11994
11995   Comparison result;
11996
11997   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
11998     return result;
11999   if ((result = m_requestSeqNum.Compare(other.m_requestSeqNum)) != EqualTo)
12000     return result;
12001   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
12002     return result;
12003   if ((result = m_endpointIdentifier.Compare(other.m_endpointIdentifier)) != EqualTo)
12004     return result;
12005   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
12006     return result;
12007   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
12008     return result;
12009   if ((result = m_endpointAlias.Compare(other.m_endpointAlias)) != EqualTo)
12010     return result;
12011   if ((result = m_perCallInfo.Compare(other.m_perCallInfo)) != EqualTo)
12012     return result;
12013
12014   return PASN_Sequence::Compare(other);
12015 }
12016
12017
12018 PINDEX H225_InfoRequestResponse::GetDataLength() const
12019 {
12020   PINDEX length = 0;
12021   if (HasOptionalField(e_nonStandardData))
12022     length += m_nonStandardData.GetObjectLength();
12023   length += m_requestSeqNum.GetObjectLength();
12024   length += m_endpointType.GetObjectLength();
12025   length += m_endpointIdentifier.GetObjectLength();
12026   length += m_rasAddress.GetObjectLength();
12027   length += m_callSignalAddress.GetObjectLength();
12028   if (HasOptionalField(e_endpointAlias))
12029     length += m_endpointAlias.GetObjectLength();
12030   if (HasOptionalField(e_perCallInfo))
12031     length += m_perCallInfo.GetObjectLength();
12032   return length;
12033 }
12034
12035
12036 BOOL H225_InfoRequestResponse::Decode(PASN_Stream & strm)
12037 {
12038   if (!PreambleDecode(strm))
12039     return FALSE;
12040
12041   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
12042     return FALSE;
12043   if (!m_requestSeqNum.Decode(strm))
12044     return FALSE;
12045   if (!m_endpointType.Decode(strm))
12046     return FALSE;
12047   if (!m_endpointIdentifier.Decode(strm))
12048     return FALSE;
12049   if (!m_rasAddress.Decode(strm))
12050     return FALSE;
12051   if (!m_callSignalAddress.Decode(strm))
12052     return FALSE;
12053   if (HasOptionalField(e_endpointAlias) && !m_endpointAlias.Decode(strm))
12054     return FALSE;
12055   if (HasOptionalField(e_perCallInfo) && !m_perCallInfo.Decode(strm))
12056     return FALSE;
12057   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
12058     return FALSE;
12059   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
12060     return FALSE;
12061   if (!KnownExtensionDecode(strm, e_integrityCheckValue, m_integrityCheckValue))
12062     return FALSE;
12063   if (!KnownExtensionDecode(strm, e_needResponse, m_needResponse))
12064     return FALSE;
12065   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
12066     return FALSE;
12067   if (!KnownExtensionDecode(strm, e_irrStatus, m_irrStatus))
12068     return FALSE;
12069   if (!KnownExtensionDecode(strm, e_unsolicited, m_unsolicited))
12070     return FALSE;
12071   if (!KnownExtensionDecode(strm, e_genericData, m_genericData))
12072     return FALSE;
12073
12074   return UnknownExtensionsDecode(strm);
12075 }
12076
12077
12078 void H225_InfoRequestResponse::Encode(PASN_Stream & strm) const
12079 {
12080   PreambleEncode(strm);
12081
12082   if (HasOptionalField(e_nonStandardData))
12083     m_nonStandardData.Encode(strm);
12084   m_requestSeqNum.Encode(strm);
12085   m_endpointType.Encode(strm);
12086   m_endpointIdentifier.Encode(strm);
12087   m_rasAddress.Encode(strm);
12088   m_callSignalAddress.Encode(strm);
12089   if (HasOptionalField(e_endpointAlias))
12090     m_endpointAlias.Encode(strm);
12091   if (HasOptionalField(e_perCallInfo))
12092     m_perCallInfo.Encode(strm);
12093   KnownExtensionEncode(strm, e_tokens, m_tokens);
12094   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
12095   KnownExtensionEncode(strm, e_integrityCheckValue, m_integrityCheckValue);
12096   KnownExtensionEncode(strm, e_needResponse, m_needResponse);
12097   KnownExtensionEncode(strm, e_capacity, m_capacity);
12098   KnownExtensionEncode(strm, e_irrStatus, m_irrStatus);
12099   KnownExtensionEncode(strm, e_unsolicited, m_unsolicited);
12100   KnownExtensionEncode(strm, e_genericData, m_genericData);
12101
12102   UnknownExtensionsEncode(strm);
12103 }
12104
12105
12106 PObject * H225_InfoRequestResponse::Clone() const
12107 {
12108 #ifndef PASN_LEANANDMEAN
12109   PAssert(IsClass(H225_InfoRequestResponse::Class()), PInvalidCast);
12110 #endif
12111   return new H225_InfoRequestResponse(*this);
12112 }
12113
12114
12115 //
12116 // InfoRequestResponse_perCallInfo_subtype
12117 //
12118
12119 H225_InfoRequestResponse_perCallInfo_subtype::H225_InfoRequestResponse_perCallInfo_subtype(unsigned tag, PASN_Object::TagClass tagClass)
12120   : PASN_Sequence(tag, tagClass, 5, TRUE, 8)
12121 {
12122   IncludeOptionalField(e_callIdentifier);
12123   IncludeOptionalField(e_substituteConfIDs);
12124 }
12125
12126
12127 #ifndef PASN_NOPRINTON
12128 void H225_InfoRequestResponse_perCallInfo_subtype::PrintOn(ostream & strm) const
12129 {
12130   int indent = strm.precision() + 2;
12131   strm << "{\n";
12132   if (HasOptionalField(e_nonStandardData))
12133     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
12134   strm << setw(indent+21) << "callReferenceValue = " << setprecision(indent) << m_callReferenceValue << '\n';
12135   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
12136   if (HasOptionalField(e_originator))
12137     strm << setw(indent+13) << "originator = " << setprecision(indent) << m_originator << '\n';
12138   if (HasOptionalField(e_audio))
12139     strm << setw(indent+8) << "audio = " << setprecision(indent) << m_audio << '\n';
12140   if (HasOptionalField(e_video))
12141     strm << setw(indent+8) << "video = " << setprecision(indent) << m_video << '\n';
12142   if (HasOptionalField(e_data))
12143     strm << setw(indent+7) << "data = " << setprecision(indent) << m_data << '\n';
12144   strm << setw(indent+7) << "h245 = " << setprecision(indent) << m_h245 << '\n';
12145   strm << setw(indent+16) << "callSignaling = " << setprecision(indent) << m_callSignaling << '\n';
12146   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
12147   strm << setw(indent+12) << "bandWidth = " << setprecision(indent) << m_bandWidth << '\n';
12148   strm << setw(indent+12) << "callModel = " << setprecision(indent) << m_callModel << '\n';
12149   if (HasOptionalField(e_callIdentifier))
12150     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
12151   if (HasOptionalField(e_tokens))
12152     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
12153   if (HasOptionalField(e_cryptoTokens))
12154     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
12155   if (HasOptionalField(e_substituteConfIDs))
12156     strm << setw(indent+20) << "substituteConfIDs = " << setprecision(indent) << m_substituteConfIDs << '\n';
12157   if (HasOptionalField(e_pdu))
12158     strm << setw(indent+6) << "pdu = " << setprecision(indent) << m_pdu << '\n';
12159   if (HasOptionalField(e_callLinkage))
12160     strm << setw(indent+14) << "callLinkage = " << setprecision(indent) << m_callLinkage << '\n';
12161   if (HasOptionalField(e_usageInformation))
12162     strm << setw(indent+19) << "usageInformation = " << setprecision(indent) << m_usageInformation << '\n';
12163   if (HasOptionalField(e_circuitInfo))
12164     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
12165   strm << setw(indent-1) << setprecision(indent-2) << "}";
12166 }
12167 #endif
12168
12169
12170 PObject::Comparison H225_InfoRequestResponse_perCallInfo_subtype::Compare(const PObject & obj) const
12171 {
12172 #ifndef PASN_LEANANDMEAN
12173   PAssert(PIsDescendant(&obj, H225_InfoRequestResponse_perCallInfo_subtype), PInvalidCast);
12174 #endif
12175   const H225_InfoRequestResponse_perCallInfo_subtype & other = (const H225_InfoRequestResponse_perCallInfo_subtype &)obj;
12176
12177   Comparison result;
12178
12179   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
12180     return result;
12181   if ((result = m_callReferenceValue.Compare(other.m_callReferenceValue)) != EqualTo)
12182     return result;
12183   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
12184     return result;
12185   if ((result = m_originator.Compare(other.m_originator)) != EqualTo)
12186     return result;
12187   if ((result = m_audio.Compare(other.m_audio)) != EqualTo)
12188     return result;
12189   if ((result = m_video.Compare(other.m_video)) != EqualTo)
12190     return result;
12191   if ((result = m_data.Compare(other.m_data)) != EqualTo)
12192     return result;
12193   if ((result = m_h245.Compare(other.m_h245)) != EqualTo)
12194     return result;
12195   if ((result = m_callSignaling.Compare(other.m_callSignaling)) != EqualTo)
12196     return result;
12197   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
12198     return result;
12199   if ((result = m_bandWidth.Compare(other.m_bandWidth)) != EqualTo)
12200     return result;
12201   if ((result = m_callModel.Compare(other.m_callModel)) != EqualTo)
12202     return result;
12203
12204   return PASN_Sequence::Compare(other);
12205 }
12206
12207
12208 PINDEX H225_InfoRequestResponse_perCallInfo_subtype::GetDataLength() const
12209 {
12210   PINDEX length = 0;
12211   if (HasOptionalField(e_nonStandardData))
12212     length += m_nonStandardData.GetObjectLength();
12213   length += m_callReferenceValue.GetObjectLength();
12214   length += m_conferenceID.GetObjectLength();
12215   if (HasOptionalField(e_originator))
12216     length += m_originator.GetObjectLength();
12217   if (HasOptionalField(e_audio))
12218     length += m_audio.GetObjectLength();
12219   if (HasOptionalField(e_video))
12220     length += m_video.GetObjectLength();
12221   if (HasOptionalField(e_data))
12222     length += m_data.GetObjectLength();
12223   length += m_h245.GetObjectLength();
12224   length += m_callSignaling.GetObjectLength();
12225   length += m_callType.GetObjectLength();
12226   length += m_bandWidth.GetObjectLength();
12227   length += m_callModel.GetObjectLength();
12228   return length;
12229 }
12230
12231
12232 BOOL H225_InfoRequestResponse_perCallInfo_subtype::Decode(PASN_Stream & strm)
12233 {
12234   if (!PreambleDecode(strm))
12235     return FALSE;
12236
12237   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
12238     return FALSE;
12239   if (!m_callReferenceValue.Decode(strm))
12240     return FALSE;
12241   if (!m_conferenceID.Decode(strm))
12242     return FALSE;
12243   if (HasOptionalField(e_originator) && !m_originator.Decode(strm))
12244     return FALSE;
12245   if (HasOptionalField(e_audio) && !m_audio.Decode(strm))
12246     return FALSE;
12247   if (HasOptionalField(e_video) && !m_video.Decode(strm))
12248     return FALSE;
12249   if (HasOptionalField(e_data) && !m_data.Decode(strm))
12250     return FALSE;
12251   if (!m_h245.Decode(strm))
12252     return FALSE;
12253   if (!m_callSignaling.Decode(strm))
12254     return FALSE;
12255   if (!m_callType.Decode(strm))
12256     return FALSE;
12257   if (!m_bandWidth.Decode(strm))
12258     return FALSE;
12259   if (!m_callModel.Decode(strm))
12260     return FALSE;
12261   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
12262     return FALSE;
12263   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
12264     return FALSE;
12265   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
12266     return FALSE;
12267   if (!KnownExtensionDecode(strm, e_substituteConfIDs, m_substituteConfIDs))
12268     return FALSE;
12269   if (!KnownExtensionDecode(strm, e_pdu, m_pdu))
12270     return FALSE;
12271   if (!KnownExtensionDecode(strm, e_callLinkage, m_callLinkage))
12272     return FALSE;
12273   if (!KnownExtensionDecode(strm, e_usageInformation, m_usageInformation))
12274     return FALSE;
12275   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
12276     return FALSE;
12277
12278   return UnknownExtensionsDecode(strm);
12279 }
12280
12281
12282 void H225_InfoRequestResponse_perCallInfo_subtype::Encode(PASN_Stream & strm) const
12283 {
12284   PreambleEncode(strm);
12285
12286   if (HasOptionalField(e_nonStandardData))
12287     m_nonStandardData.Encode(strm);
12288   m_callReferenceValue.Encode(strm);
12289   m_conferenceID.Encode(strm);
12290   if (HasOptionalField(e_originator))
12291     m_originator.Encode(strm);
12292   if (HasOptionalField(e_audio))
12293     m_audio.Encode(strm);
12294   if (HasOptionalField(e_video))
12295     m_video.Encode(strm);
12296   if (HasOptionalField(e_data))
12297     m_data.Encode(strm);
12298   m_h245.Encode(strm);
12299   m_callSignaling.Encode(strm);
12300   m_callType.Encode(strm);
12301   m_bandWidth.Encode(strm);
12302   m_callModel.Encode(strm);
12303   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
12304   KnownExtensionEncode(strm, e_tokens, m_tokens);
12305   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
12306   KnownExtensionEncode(strm, e_substituteConfIDs, m_substituteConfIDs);
12307   KnownExtensionEncode(strm, e_pdu, m_pdu);
12308   KnownExtensionEncode(strm, e_callLinkage, m_callLinkage);
12309   KnownExtensionEncode(strm, e_usageInformation, m_usageInformation);
12310   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
12311
12312   UnknownExtensionsEncode(strm);
12313 }
12314
12315
12316 PObject * H225_InfoRequestResponse_perCallInfo_subtype::Clone() const
12317 {
12318 #ifndef PASN_LEANANDMEAN
12319   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype::Class()), PInvalidCast);
12320 #endif
12321   return new H225_InfoRequestResponse_perCallInfo_subtype(*this);
12322 }
12323
12324
12325 //
12326 // InfoRequestResponse_perCallInfo_subtype_pdu_subtype
12327 //
12328
12329 H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype(unsigned tag, PASN_Object::TagClass tagClass)
12330   : PASN_Sequence(tag, tagClass, 0, FALSE, 0)
12331 {
12332 }
12333
12334
12335 #ifndef PASN_NOPRINTON
12336 void H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::PrintOn(ostream & strm) const
12337 {
12338   int indent = strm.precision() + 2;
12339   strm << "{\n";
12340   strm << setw(indent+10) << "h323pdu = " << setprecision(indent) << m_h323pdu << '\n';
12341   strm << setw(indent+7) << "sent = " << setprecision(indent) << m_sent << '\n';
12342   strm << setw(indent-1) << setprecision(indent-2) << "}";
12343 }
12344 #endif
12345
12346
12347 PObject::Comparison H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Compare(const PObject & obj) const
12348 {
12349 #ifndef PASN_LEANANDMEAN
12350   PAssert(PIsDescendant(&obj, H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype), PInvalidCast);
12351 #endif
12352   const H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype & other = (const H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype &)obj;
12353
12354   Comparison result;
12355
12356   if ((result = m_h323pdu.Compare(other.m_h323pdu)) != EqualTo)
12357     return result;
12358   if ((result = m_sent.Compare(other.m_sent)) != EqualTo)
12359     return result;
12360
12361   return PASN_Sequence::Compare(other);
12362 }
12363
12364
12365 PINDEX H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::GetDataLength() const
12366 {
12367   PINDEX length = 0;
12368   length += m_h323pdu.GetObjectLength();
12369   length += m_sent.GetObjectLength();
12370   return length;
12371 }
12372
12373
12374 BOOL H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Decode(PASN_Stream & strm)
12375 {
12376   if (!PreambleDecode(strm))
12377     return FALSE;
12378
12379   if (!m_h323pdu.Decode(strm))
12380     return FALSE;
12381   if (!m_sent.Decode(strm))
12382     return FALSE;
12383
12384   return UnknownExtensionsDecode(strm);
12385 }
12386
12387
12388 void H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Encode(PASN_Stream & strm) const
12389 {
12390   PreambleEncode(strm);
12391
12392   m_h323pdu.Encode(strm);
12393   m_sent.Encode(strm);
12394
12395   UnknownExtensionsEncode(strm);
12396 }
12397
12398
12399 PObject * H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Clone() const
12400 {
12401 #ifndef PASN_LEANANDMEAN
12402   PAssert(IsClass(H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype::Class()), PInvalidCast);
12403 #endif
12404   return new H225_InfoRequestResponse_perCallInfo_subtype_pdu_subtype(*this);
12405 }
12406
12407
12408 //
12409 // H323-UserInformation
12410 //
12411
12412 H225_H323_UserInformation::H225_H323_UserInformation(unsigned tag, PASN_Object::TagClass tagClass)
12413   : PASN_Sequence(tag, tagClass, 1, TRUE, 0)
12414 {
12415 }
12416
12417
12418 #ifndef PASN_NOPRINTON
12419 void H225_H323_UserInformation::PrintOn(ostream & strm) const
12420 {
12421   int indent = strm.precision() + 2;
12422   strm << "{\n";
12423   strm << setw(indent+14) << "h323_uu_pdu = " << setprecision(indent) << m_h323_uu_pdu << '\n';
12424   if (HasOptionalField(e_user_data))
12425     strm << setw(indent+12) << "user_data = " << setprecision(indent) << m_user_data << '\n';
12426   strm << setw(indent-1) << setprecision(indent-2) << "}";
12427 }
12428 #endif
12429
12430
12431 PObject::Comparison H225_H323_UserInformation::Compare(const PObject & obj) const
12432 {
12433 #ifndef PASN_LEANANDMEAN
12434   PAssert(PIsDescendant(&obj, H225_H323_UserInformation), PInvalidCast);
12435 #endif
12436   const H225_H323_UserInformation & other = (const H225_H323_UserInformation &)obj;
12437
12438   Comparison result;
12439
12440   if ((result = m_h323_uu_pdu.Compare(other.m_h323_uu_pdu)) != EqualTo)
12441     return result;
12442   if ((result = m_user_data.Compare(other.m_user_data)) != EqualTo)
12443     return result;
12444
12445   return PASN_Sequence::Compare(other);
12446 }
12447
12448
12449 PINDEX H225_H323_UserInformation::GetDataLength() const
12450 {
12451   PINDEX length = 0;
12452   length += m_h323_uu_pdu.GetObjectLength();
12453   if (HasOptionalField(e_user_data))
12454     length += m_user_data.GetObjectLength();
12455   return length;
12456 }
12457
12458
12459 BOOL H225_H323_UserInformation::Decode(PASN_Stream & strm)
12460 {
12461   if (!PreambleDecode(strm))
12462     return FALSE;
12463
12464   if (!m_h323_uu_pdu.Decode(strm))
12465     return FALSE;
12466   if (HasOptionalField(e_user_data) && !m_user_data.Decode(strm))
12467     return FALSE;
12468
12469   return UnknownExtensionsDecode(strm);
12470 }
12471
12472
12473 void H225_H323_UserInformation::Encode(PASN_Stream & strm) const
12474 {
12475   PreambleEncode(strm);
12476
12477   m_h323_uu_pdu.Encode(strm);
12478   if (HasOptionalField(e_user_data))
12479     m_user_data.Encode(strm);
12480
12481   UnknownExtensionsEncode(strm);
12482 }
12483
12484
12485 PObject * H225_H323_UserInformation::Clone() const
12486 {
12487 #ifndef PASN_LEANANDMEAN
12488   PAssert(IsClass(H225_H323_UserInformation::Class()), PInvalidCast);
12489 #endif
12490   return new H225_H323_UserInformation(*this);
12491 }
12492
12493
12494 //
12495 // Alerting-UUIE
12496 //
12497
12498 H225_Alerting_UUIE::H225_Alerting_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
12499   : PASN_Sequence(tag, tagClass, 1, TRUE, 14)
12500 {
12501   IncludeOptionalField(e_callIdentifier);
12502   IncludeOptionalField(e_multipleCalls);
12503   IncludeOptionalField(e_maintainConnection);
12504 }
12505
12506
12507 #ifndef PASN_NOPRINTON
12508 void H225_Alerting_UUIE::PrintOn(ostream & strm) const
12509 {
12510   int indent = strm.precision() + 2;
12511   strm << "{\n";
12512   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
12513   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
12514   if (HasOptionalField(e_h245Address))
12515     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
12516   if (HasOptionalField(e_callIdentifier))
12517     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
12518   if (HasOptionalField(e_h245SecurityMode))
12519     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
12520   if (HasOptionalField(e_tokens))
12521     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
12522   if (HasOptionalField(e_cryptoTokens))
12523     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
12524   if (HasOptionalField(e_fastStart))
12525     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
12526   if (HasOptionalField(e_multipleCalls))
12527     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
12528   if (HasOptionalField(e_maintainConnection))
12529     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
12530   if (HasOptionalField(e_alertingAddress))
12531     strm << setw(indent+18) << "alertingAddress = " << setprecision(indent) << m_alertingAddress << '\n';
12532   if (HasOptionalField(e_presentationIndicator))
12533     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
12534   if (HasOptionalField(e_screeningIndicator))
12535     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
12536   if (HasOptionalField(e_fastConnectRefused))
12537     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
12538   if (HasOptionalField(e_serviceControl))
12539     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
12540   if (HasOptionalField(e_capacity))
12541     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
12542   if (HasOptionalField(e_featureSet))
12543     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
12544   strm << setw(indent-1) << setprecision(indent-2) << "}";
12545 }
12546 #endif
12547
12548
12549 PObject::Comparison H225_Alerting_UUIE::Compare(const PObject & obj) const
12550 {
12551 #ifndef PASN_LEANANDMEAN
12552   PAssert(PIsDescendant(&obj, H225_Alerting_UUIE), PInvalidCast);
12553 #endif
12554   const H225_Alerting_UUIE & other = (const H225_Alerting_UUIE &)obj;
12555
12556   Comparison result;
12557
12558   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
12559     return result;
12560   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
12561     return result;
12562   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
12563     return result;
12564
12565   return PASN_Sequence::Compare(other);
12566 }
12567
12568
12569 PINDEX H225_Alerting_UUIE::GetDataLength() const
12570 {
12571   PINDEX length = 0;
12572   length += m_protocolIdentifier.GetObjectLength();
12573   length += m_destinationInfo.GetObjectLength();
12574   if (HasOptionalField(e_h245Address))
12575     length += m_h245Address.GetObjectLength();
12576   return length;
12577 }
12578
12579
12580 BOOL H225_Alerting_UUIE::Decode(PASN_Stream & strm)
12581 {
12582   if (!PreambleDecode(strm))
12583     return FALSE;
12584
12585   if (!m_protocolIdentifier.Decode(strm))
12586     return FALSE;
12587   if (!m_destinationInfo.Decode(strm))
12588     return FALSE;
12589   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
12590     return FALSE;
12591   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
12592     return FALSE;
12593   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
12594     return FALSE;
12595   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
12596     return FALSE;
12597   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
12598     return FALSE;
12599   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
12600     return FALSE;
12601   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
12602     return FALSE;
12603   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
12604     return FALSE;
12605   if (!KnownExtensionDecode(strm, e_alertingAddress, m_alertingAddress))
12606     return FALSE;
12607   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
12608     return FALSE;
12609   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
12610     return FALSE;
12611   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
12612     return FALSE;
12613   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
12614     return FALSE;
12615   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
12616     return FALSE;
12617   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
12618     return FALSE;
12619
12620   return UnknownExtensionsDecode(strm);
12621 }
12622
12623
12624 void H225_Alerting_UUIE::Encode(PASN_Stream & strm) const
12625 {
12626   PreambleEncode(strm);
12627
12628   m_protocolIdentifier.Encode(strm);
12629   m_destinationInfo.Encode(strm);
12630   if (HasOptionalField(e_h245Address))
12631     m_h245Address.Encode(strm);
12632   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
12633   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
12634   KnownExtensionEncode(strm, e_tokens, m_tokens);
12635   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
12636   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
12637   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
12638   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
12639   KnownExtensionEncode(strm, e_alertingAddress, m_alertingAddress);
12640   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
12641   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
12642   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
12643   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
12644   KnownExtensionEncode(strm, e_capacity, m_capacity);
12645   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
12646
12647   UnknownExtensionsEncode(strm);
12648 }
12649
12650
12651 PObject * H225_Alerting_UUIE::Clone() const
12652 {
12653 #ifndef PASN_LEANANDMEAN
12654   PAssert(IsClass(H225_Alerting_UUIE::Class()), PInvalidCast);
12655 #endif
12656   return new H225_Alerting_UUIE(*this);
12657 }
12658
12659
12660 //
12661 // CallProceeding-UUIE
12662 //
12663
12664 H225_CallProceeding_UUIE::H225_CallProceeding_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
12665   : PASN_Sequence(tag, tagClass, 1, TRUE, 9)
12666 {
12667   IncludeOptionalField(e_callIdentifier);
12668   IncludeOptionalField(e_multipleCalls);
12669   IncludeOptionalField(e_maintainConnection);
12670 }
12671
12672
12673 #ifndef PASN_NOPRINTON
12674 void H225_CallProceeding_UUIE::PrintOn(ostream & strm) const
12675 {
12676   int indent = strm.precision() + 2;
12677   strm << "{\n";
12678   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
12679   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
12680   if (HasOptionalField(e_h245Address))
12681     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
12682   if (HasOptionalField(e_callIdentifier))
12683     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
12684   if (HasOptionalField(e_h245SecurityMode))
12685     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
12686   if (HasOptionalField(e_tokens))
12687     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
12688   if (HasOptionalField(e_cryptoTokens))
12689     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
12690   if (HasOptionalField(e_fastStart))
12691     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
12692   if (HasOptionalField(e_multipleCalls))
12693     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
12694   if (HasOptionalField(e_maintainConnection))
12695     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
12696   if (HasOptionalField(e_fastConnectRefused))
12697     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
12698   if (HasOptionalField(e_featureSet))
12699     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
12700   strm << setw(indent-1) << setprecision(indent-2) << "}";
12701 }
12702 #endif
12703
12704
12705 PObject::Comparison H225_CallProceeding_UUIE::Compare(const PObject & obj) const
12706 {
12707 #ifndef PASN_LEANANDMEAN
12708   PAssert(PIsDescendant(&obj, H225_CallProceeding_UUIE), PInvalidCast);
12709 #endif
12710   const H225_CallProceeding_UUIE & other = (const H225_CallProceeding_UUIE &)obj;
12711
12712   Comparison result;
12713
12714   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
12715     return result;
12716   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
12717     return result;
12718   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
12719     return result;
12720
12721   return PASN_Sequence::Compare(other);
12722 }
12723
12724
12725 PINDEX H225_CallProceeding_UUIE::GetDataLength() const
12726 {
12727   PINDEX length = 0;
12728   length += m_protocolIdentifier.GetObjectLength();
12729   length += m_destinationInfo.GetObjectLength();
12730   if (HasOptionalField(e_h245Address))
12731     length += m_h245Address.GetObjectLength();
12732   return length;
12733 }
12734
12735
12736 BOOL H225_CallProceeding_UUIE::Decode(PASN_Stream & strm)
12737 {
12738   if (!PreambleDecode(strm))
12739     return FALSE;
12740
12741   if (!m_protocolIdentifier.Decode(strm))
12742     return FALSE;
12743   if (!m_destinationInfo.Decode(strm))
12744     return FALSE;
12745   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
12746     return FALSE;
12747   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
12748     return FALSE;
12749   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
12750     return FALSE;
12751   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
12752     return FALSE;
12753   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
12754     return FALSE;
12755   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
12756     return FALSE;
12757   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
12758     return FALSE;
12759   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
12760     return FALSE;
12761   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
12762     return FALSE;
12763   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
12764     return FALSE;
12765
12766   return UnknownExtensionsDecode(strm);
12767 }
12768
12769
12770 void H225_CallProceeding_UUIE::Encode(PASN_Stream & strm) const
12771 {
12772   PreambleEncode(strm);
12773
12774   m_protocolIdentifier.Encode(strm);
12775   m_destinationInfo.Encode(strm);
12776   if (HasOptionalField(e_h245Address))
12777     m_h245Address.Encode(strm);
12778   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
12779   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
12780   KnownExtensionEncode(strm, e_tokens, m_tokens);
12781   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
12782   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
12783   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
12784   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
12785   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
12786   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
12787
12788   UnknownExtensionsEncode(strm);
12789 }
12790
12791
12792 PObject * H225_CallProceeding_UUIE::Clone() const
12793 {
12794 #ifndef PASN_LEANANDMEAN
12795   PAssert(IsClass(H225_CallProceeding_UUIE::Class()), PInvalidCast);
12796 #endif
12797   return new H225_CallProceeding_UUIE(*this);
12798 }
12799
12800
12801 //
12802 // Connect-UUIE
12803 //
12804
12805 H225_Connect_UUIE::H225_Connect_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
12806   : PASN_Sequence(tag, tagClass, 1, TRUE, 15)
12807 {
12808   IncludeOptionalField(e_callIdentifier);
12809   IncludeOptionalField(e_multipleCalls);
12810   IncludeOptionalField(e_maintainConnection);
12811 }
12812
12813
12814 #ifndef PASN_NOPRINTON
12815 void H225_Connect_UUIE::PrintOn(ostream & strm) const
12816 {
12817   int indent = strm.precision() + 2;
12818   strm << "{\n";
12819   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
12820   if (HasOptionalField(e_h245Address))
12821     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
12822   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
12823   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
12824   if (HasOptionalField(e_callIdentifier))
12825     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
12826   if (HasOptionalField(e_h245SecurityMode))
12827     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
12828   if (HasOptionalField(e_tokens))
12829     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
12830   if (HasOptionalField(e_cryptoTokens))
12831     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
12832   if (HasOptionalField(e_fastStart))
12833     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
12834   if (HasOptionalField(e_multipleCalls))
12835     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
12836   if (HasOptionalField(e_maintainConnection))
12837     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
12838   if (HasOptionalField(e_language))
12839     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
12840   if (HasOptionalField(e_connectedAddress))
12841     strm << setw(indent+19) << "connectedAddress = " << setprecision(indent) << m_connectedAddress << '\n';
12842   if (HasOptionalField(e_presentationIndicator))
12843     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
12844   if (HasOptionalField(e_screeningIndicator))
12845     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
12846   if (HasOptionalField(e_fastConnectRefused))
12847     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
12848   if (HasOptionalField(e_serviceControl))
12849     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
12850   if (HasOptionalField(e_capacity))
12851     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
12852   if (HasOptionalField(e_featureSet))
12853     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
12854   strm << setw(indent-1) << setprecision(indent-2) << "}";
12855 }
12856 #endif
12857
12858
12859 PObject::Comparison H225_Connect_UUIE::Compare(const PObject & obj) const
12860 {
12861 #ifndef PASN_LEANANDMEAN
12862   PAssert(PIsDescendant(&obj, H225_Connect_UUIE), PInvalidCast);
12863 #endif
12864   const H225_Connect_UUIE & other = (const H225_Connect_UUIE &)obj;
12865
12866   Comparison result;
12867
12868   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
12869     return result;
12870   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
12871     return result;
12872   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
12873     return result;
12874   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
12875     return result;
12876
12877   return PASN_Sequence::Compare(other);
12878 }
12879
12880
12881 PINDEX H225_Connect_UUIE::GetDataLength() const
12882 {
12883   PINDEX length = 0;
12884   length += m_protocolIdentifier.GetObjectLength();
12885   if (HasOptionalField(e_h245Address))
12886     length += m_h245Address.GetObjectLength();
12887   length += m_destinationInfo.GetObjectLength();
12888   length += m_conferenceID.GetObjectLength();
12889   return length;
12890 }
12891
12892
12893 BOOL H225_Connect_UUIE::Decode(PASN_Stream & strm)
12894 {
12895   if (!PreambleDecode(strm))
12896     return FALSE;
12897
12898   if (!m_protocolIdentifier.Decode(strm))
12899     return FALSE;
12900   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
12901     return FALSE;
12902   if (!m_destinationInfo.Decode(strm))
12903     return FALSE;
12904   if (!m_conferenceID.Decode(strm))
12905     return FALSE;
12906   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
12907     return FALSE;
12908   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
12909     return FALSE;
12910   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
12911     return FALSE;
12912   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
12913     return FALSE;
12914   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
12915     return FALSE;
12916   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
12917     return FALSE;
12918   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
12919     return FALSE;
12920   if (!KnownExtensionDecode(strm, e_language, m_language))
12921     return FALSE;
12922   if (!KnownExtensionDecode(strm, e_connectedAddress, m_connectedAddress))
12923     return FALSE;
12924   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
12925     return FALSE;
12926   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
12927     return FALSE;
12928   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
12929     return FALSE;
12930   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
12931     return FALSE;
12932   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
12933     return FALSE;
12934   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
12935     return FALSE;
12936
12937   return UnknownExtensionsDecode(strm);
12938 }
12939
12940
12941 void H225_Connect_UUIE::Encode(PASN_Stream & strm) const
12942 {
12943   PreambleEncode(strm);
12944
12945   m_protocolIdentifier.Encode(strm);
12946   if (HasOptionalField(e_h245Address))
12947     m_h245Address.Encode(strm);
12948   m_destinationInfo.Encode(strm);
12949   m_conferenceID.Encode(strm);
12950   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
12951   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
12952   KnownExtensionEncode(strm, e_tokens, m_tokens);
12953   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
12954   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
12955   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
12956   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
12957   KnownExtensionEncode(strm, e_language, m_language);
12958   KnownExtensionEncode(strm, e_connectedAddress, m_connectedAddress);
12959   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
12960   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
12961   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
12962   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
12963   KnownExtensionEncode(strm, e_capacity, m_capacity);
12964   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
12965
12966   UnknownExtensionsEncode(strm);
12967 }
12968
12969
12970 PObject * H225_Connect_UUIE::Clone() const
12971 {
12972 #ifndef PASN_LEANANDMEAN
12973   PAssert(IsClass(H225_Connect_UUIE::Class()), PInvalidCast);
12974 #endif
12975   return new H225_Connect_UUIE(*this);
12976 }
12977
12978
12979 //
12980 // Information-UUIE
12981 //
12982
12983 H225_Information_UUIE::H225_Information_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
12984   : PASN_Sequence(tag, tagClass, 0, TRUE, 6)
12985 {
12986   IncludeOptionalField(e_callIdentifier);
12987 }
12988
12989
12990 #ifndef PASN_NOPRINTON
12991 void H225_Information_UUIE::PrintOn(ostream & strm) const
12992 {
12993   int indent = strm.precision() + 2;
12994   strm << "{\n";
12995   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
12996   if (HasOptionalField(e_callIdentifier))
12997     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
12998   if (HasOptionalField(e_tokens))
12999     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
13000   if (HasOptionalField(e_cryptoTokens))
13001     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
13002   if (HasOptionalField(e_fastStart))
13003     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
13004   if (HasOptionalField(e_fastConnectRefused))
13005     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
13006   if (HasOptionalField(e_circuitInfo))
13007     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
13008   strm << setw(indent-1) << setprecision(indent-2) << "}";
13009 }
13010 #endif
13011
13012
13013 PObject::Comparison H225_Information_UUIE::Compare(const PObject & obj) const
13014 {
13015 #ifndef PASN_LEANANDMEAN
13016   PAssert(PIsDescendant(&obj, H225_Information_UUIE), PInvalidCast);
13017 #endif
13018   const H225_Information_UUIE & other = (const H225_Information_UUIE &)obj;
13019
13020   Comparison result;
13021
13022   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
13023     return result;
13024
13025   return PASN_Sequence::Compare(other);
13026 }
13027
13028
13029 PINDEX H225_Information_UUIE::GetDataLength() const
13030 {
13031   PINDEX length = 0;
13032   length += m_protocolIdentifier.GetObjectLength();
13033   return length;
13034 }
13035
13036
13037 BOOL H225_Information_UUIE::Decode(PASN_Stream & strm)
13038 {
13039   if (!PreambleDecode(strm))
13040     return FALSE;
13041
13042   if (!m_protocolIdentifier.Decode(strm))
13043     return FALSE;
13044   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
13045     return FALSE;
13046   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
13047     return FALSE;
13048   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
13049     return FALSE;
13050   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
13051     return FALSE;
13052   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
13053     return FALSE;
13054   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
13055     return FALSE;
13056
13057   return UnknownExtensionsDecode(strm);
13058 }
13059
13060
13061 void H225_Information_UUIE::Encode(PASN_Stream & strm) const
13062 {
13063   PreambleEncode(strm);
13064
13065   m_protocolIdentifier.Encode(strm);
13066   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
13067   KnownExtensionEncode(strm, e_tokens, m_tokens);
13068   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
13069   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
13070   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
13071   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
13072
13073   UnknownExtensionsEncode(strm);
13074 }
13075
13076
13077 PObject * H225_Information_UUIE::Clone() const
13078 {
13079 #ifndef PASN_LEANANDMEAN
13080   PAssert(IsClass(H225_Information_UUIE::Class()), PInvalidCast);
13081 #endif
13082   return new H225_Information_UUIE(*this);
13083 }
13084
13085
13086 //
13087 // Setup-UUIE
13088 //
13089
13090 H225_Setup_UUIE::H225_Setup_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
13091   : PASN_Sequence(tag, tagClass, 7, TRUE, 27)
13092 {
13093   IncludeOptionalField(e_callIdentifier);
13094   IncludeOptionalField(e_mediaWaitForConnect);
13095   IncludeOptionalField(e_canOverlapSend);
13096   IncludeOptionalField(e_multipleCalls);
13097   IncludeOptionalField(e_maintainConnection);
13098   m_hopCount.SetConstraints(PASN_Object::FixedConstraint, 1, 31);
13099 }
13100
13101
13102 #ifndef PASN_NOPRINTON
13103 void H225_Setup_UUIE::PrintOn(ostream & strm) const
13104 {
13105   int indent = strm.precision() + 2;
13106   strm << "{\n";
13107   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
13108   if (HasOptionalField(e_h245Address))
13109     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
13110   if (HasOptionalField(e_sourceAddress))
13111     strm << setw(indent+16) << "sourceAddress = " << setprecision(indent) << m_sourceAddress << '\n';
13112   strm << setw(indent+13) << "sourceInfo = " << setprecision(indent) << m_sourceInfo << '\n';
13113   if (HasOptionalField(e_destinationAddress))
13114     strm << setw(indent+21) << "destinationAddress = " << setprecision(indent) << m_destinationAddress << '\n';
13115   if (HasOptionalField(e_destCallSignalAddress))
13116     strm << setw(indent+24) << "destCallSignalAddress = " << setprecision(indent) << m_destCallSignalAddress << '\n';
13117   if (HasOptionalField(e_destExtraCallInfo))
13118     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
13119   if (HasOptionalField(e_destExtraCRV))
13120     strm << setw(indent+15) << "destExtraCRV = " << setprecision(indent) << m_destExtraCRV << '\n';
13121   strm << setw(indent+11) << "activeMC = " << setprecision(indent) << m_activeMC << '\n';
13122   strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
13123   strm << setw(indent+17) << "conferenceGoal = " << setprecision(indent) << m_conferenceGoal << '\n';
13124   if (HasOptionalField(e_callServices))
13125     strm << setw(indent+15) << "callServices = " << setprecision(indent) << m_callServices << '\n';
13126   strm << setw(indent+11) << "callType = " << setprecision(indent) << m_callType << '\n';
13127   if (HasOptionalField(e_sourceCallSignalAddress))
13128     strm << setw(indent+26) << "sourceCallSignalAddress = " << setprecision(indent) << m_sourceCallSignalAddress << '\n';
13129   if (HasOptionalField(e_remoteExtensionAddress))
13130     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
13131   if (HasOptionalField(e_callIdentifier))
13132     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
13133   if (HasOptionalField(e_h245SecurityCapability))
13134     strm << setw(indent+25) << "h245SecurityCapability = " << setprecision(indent) << m_h245SecurityCapability << '\n';
13135   if (HasOptionalField(e_tokens))
13136     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
13137   if (HasOptionalField(e_cryptoTokens))
13138     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
13139   if (HasOptionalField(e_fastStart))
13140     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
13141   if (HasOptionalField(e_mediaWaitForConnect))
13142     strm << setw(indent+22) << "mediaWaitForConnect = " << setprecision(indent) << m_mediaWaitForConnect << '\n';
13143   if (HasOptionalField(e_canOverlapSend))
13144     strm << setw(indent+17) << "canOverlapSend = " << setprecision(indent) << m_canOverlapSend << '\n';
13145   if (HasOptionalField(e_endpointIdentifier))
13146     strm << setw(indent+21) << "endpointIdentifier = " << setprecision(indent) << m_endpointIdentifier << '\n';
13147   if (HasOptionalField(e_multipleCalls))
13148     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
13149   if (HasOptionalField(e_maintainConnection))
13150     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
13151   if (HasOptionalField(e_connectionParameters))
13152     strm << setw(indent+23) << "connectionParameters = " << setprecision(indent) << m_connectionParameters << '\n';
13153   if (HasOptionalField(e_language))
13154     strm << setw(indent+11) << "language = " << setprecision(indent) << m_language << '\n';
13155   if (HasOptionalField(e_presentationIndicator))
13156     strm << setw(indent+24) << "presentationIndicator = " << setprecision(indent) << m_presentationIndicator << '\n';
13157   if (HasOptionalField(e_screeningIndicator))
13158     strm << setw(indent+21) << "screeningIndicator = " << setprecision(indent) << m_screeningIndicator << '\n';
13159   if (HasOptionalField(e_serviceControl))
13160     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
13161   if (HasOptionalField(e_symmetricOperationRequired))
13162     strm << setw(indent+29) << "symmetricOperationRequired = " << setprecision(indent) << m_symmetricOperationRequired << '\n';
13163   if (HasOptionalField(e_capacity))
13164     strm << setw(indent+11) << "capacity = " << setprecision(indent) << m_capacity << '\n';
13165   if (HasOptionalField(e_circuitInfo))
13166     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
13167   if (HasOptionalField(e_desiredProtocols))
13168     strm << setw(indent+19) << "desiredProtocols = " << setprecision(indent) << m_desiredProtocols << '\n';
13169   if (HasOptionalField(e_neededFeatures))
13170     strm << setw(indent+17) << "neededFeatures = " << setprecision(indent) << m_neededFeatures << '\n';
13171   if (HasOptionalField(e_desiredFeatures))
13172     strm << setw(indent+18) << "desiredFeatures = " << setprecision(indent) << m_desiredFeatures << '\n';
13173   if (HasOptionalField(e_supportedFeatures))
13174     strm << setw(indent+20) << "supportedFeatures = " << setprecision(indent) << m_supportedFeatures << '\n';
13175   if (HasOptionalField(e_parallelH245Control))
13176     strm << setw(indent+22) << "parallelH245Control = " << setprecision(indent) << m_parallelH245Control << '\n';
13177   if (HasOptionalField(e_additionalSourceAddresses))
13178     strm << setw(indent+28) << "additionalSourceAddresses = " << setprecision(indent) << m_additionalSourceAddresses << '\n';
13179   if (HasOptionalField(e_hopCount))
13180     strm << setw(indent+11) << "hopCount = " << setprecision(indent) << m_hopCount << '\n';
13181   strm << setw(indent-1) << setprecision(indent-2) << "}";
13182 }
13183 #endif
13184
13185
13186 PObject::Comparison H225_Setup_UUIE::Compare(const PObject & obj) const
13187 {
13188 #ifndef PASN_LEANANDMEAN
13189   PAssert(PIsDescendant(&obj, H225_Setup_UUIE), PInvalidCast);
13190 #endif
13191   const H225_Setup_UUIE & other = (const H225_Setup_UUIE &)obj;
13192
13193   Comparison result;
13194
13195   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
13196     return result;
13197   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
13198     return result;
13199   if ((result = m_sourceAddress.Compare(other.m_sourceAddress)) != EqualTo)
13200     return result;
13201   if ((result = m_sourceInfo.Compare(other.m_sourceInfo)) != EqualTo)
13202     return result;
13203   if ((result = m_destinationAddress.Compare(other.m_destinationAddress)) != EqualTo)
13204     return result;
13205   if ((result = m_destCallSignalAddress.Compare(other.m_destCallSignalAddress)) != EqualTo)
13206     return result;
13207   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
13208     return result;
13209   if ((result = m_destExtraCRV.Compare(other.m_destExtraCRV)) != EqualTo)
13210     return result;
13211   if ((result = m_activeMC.Compare(other.m_activeMC)) != EqualTo)
13212     return result;
13213   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
13214     return result;
13215   if ((result = m_conferenceGoal.Compare(other.m_conferenceGoal)) != EqualTo)
13216     return result;
13217   if ((result = m_callServices.Compare(other.m_callServices)) != EqualTo)
13218     return result;
13219   if ((result = m_callType.Compare(other.m_callType)) != EqualTo)
13220     return result;
13221
13222   return PASN_Sequence::Compare(other);
13223 }
13224
13225
13226 PINDEX H225_Setup_UUIE::GetDataLength() const
13227 {
13228   PINDEX length = 0;
13229   length += m_protocolIdentifier.GetObjectLength();
13230   if (HasOptionalField(e_h245Address))
13231     length += m_h245Address.GetObjectLength();
13232   if (HasOptionalField(e_sourceAddress))
13233     length += m_sourceAddress.GetObjectLength();
13234   length += m_sourceInfo.GetObjectLength();
13235   if (HasOptionalField(e_destinationAddress))
13236     length += m_destinationAddress.GetObjectLength();
13237   if (HasOptionalField(e_destCallSignalAddress))
13238     length += m_destCallSignalAddress.GetObjectLength();
13239   if (HasOptionalField(e_destExtraCallInfo))
13240     length += m_destExtraCallInfo.GetObjectLength();
13241   if (HasOptionalField(e_destExtraCRV))
13242     length += m_destExtraCRV.GetObjectLength();
13243   length += m_activeMC.GetObjectLength();
13244   length += m_conferenceID.GetObjectLength();
13245   length += m_conferenceGoal.GetObjectLength();
13246   if (HasOptionalField(e_callServices))
13247     length += m_callServices.GetObjectLength();
13248   length += m_callType.GetObjectLength();
13249   return length;
13250 }
13251
13252
13253 BOOL H225_Setup_UUIE::Decode(PASN_Stream & strm)
13254 {
13255   if (!PreambleDecode(strm))
13256     return FALSE;
13257
13258   if (!m_protocolIdentifier.Decode(strm))
13259     return FALSE;
13260   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
13261     return FALSE;
13262   if (HasOptionalField(e_sourceAddress) && !m_sourceAddress.Decode(strm))
13263     return FALSE;
13264   if (!m_sourceInfo.Decode(strm))
13265     return FALSE;
13266   if (HasOptionalField(e_destinationAddress) && !m_destinationAddress.Decode(strm))
13267     return FALSE;
13268   if (HasOptionalField(e_destCallSignalAddress) && !m_destCallSignalAddress.Decode(strm))
13269     return FALSE;
13270   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
13271     return FALSE;
13272   if (HasOptionalField(e_destExtraCRV) && !m_destExtraCRV.Decode(strm))
13273     return FALSE;
13274   if (!m_activeMC.Decode(strm))
13275     return FALSE;
13276   if (!m_conferenceID.Decode(strm))
13277     return FALSE;
13278   if (!m_conferenceGoal.Decode(strm))
13279     return FALSE;
13280   if (HasOptionalField(e_callServices) && !m_callServices.Decode(strm))
13281     return FALSE;
13282   if (!m_callType.Decode(strm))
13283     return FALSE;
13284   if (!KnownExtensionDecode(strm, e_sourceCallSignalAddress, m_sourceCallSignalAddress))
13285     return FALSE;
13286   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
13287     return FALSE;
13288   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
13289     return FALSE;
13290   if (!KnownExtensionDecode(strm, e_h245SecurityCapability, m_h245SecurityCapability))
13291     return FALSE;
13292   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
13293     return FALSE;
13294   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
13295     return FALSE;
13296   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
13297     return FALSE;
13298   if (!KnownExtensionDecode(strm, e_mediaWaitForConnect, m_mediaWaitForConnect))
13299     return FALSE;
13300   if (!KnownExtensionDecode(strm, e_canOverlapSend, m_canOverlapSend))
13301     return FALSE;
13302   if (!KnownExtensionDecode(strm, e_endpointIdentifier, m_endpointIdentifier))
13303     return FALSE;
13304   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
13305     return FALSE;
13306   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
13307     return FALSE;
13308   if (!KnownExtensionDecode(strm, e_connectionParameters, m_connectionParameters))
13309     return FALSE;
13310   if (!KnownExtensionDecode(strm, e_language, m_language))
13311     return FALSE;
13312   if (!KnownExtensionDecode(strm, e_presentationIndicator, m_presentationIndicator))
13313     return FALSE;
13314   if (!KnownExtensionDecode(strm, e_screeningIndicator, m_screeningIndicator))
13315     return FALSE;
13316   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
13317     return FALSE;
13318   if (!KnownExtensionDecode(strm, e_symmetricOperationRequired, m_symmetricOperationRequired))
13319     return FALSE;
13320   if (!KnownExtensionDecode(strm, e_capacity, m_capacity))
13321     return FALSE;
13322   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
13323     return FALSE;
13324   if (!KnownExtensionDecode(strm, e_desiredProtocols, m_desiredProtocols))
13325     return FALSE;
13326   if (!KnownExtensionDecode(strm, e_neededFeatures, m_neededFeatures))
13327     return FALSE;
13328   if (!KnownExtensionDecode(strm, e_desiredFeatures, m_desiredFeatures))
13329     return FALSE;
13330   if (!KnownExtensionDecode(strm, e_supportedFeatures, m_supportedFeatures))
13331     return FALSE;
13332   if (!KnownExtensionDecode(strm, e_parallelH245Control, m_parallelH245Control))
13333     return FALSE;
13334   if (!KnownExtensionDecode(strm, e_additionalSourceAddresses, m_additionalSourceAddresses))
13335     return FALSE;
13336   if (!KnownExtensionDecode(strm, e_hopCount, m_hopCount))
13337     return FALSE;
13338
13339   return UnknownExtensionsDecode(strm);
13340 }
13341
13342
13343 void H225_Setup_UUIE::Encode(PASN_Stream & strm) const
13344 {
13345   PreambleEncode(strm);
13346
13347   m_protocolIdentifier.Encode(strm);
13348   if (HasOptionalField(e_h245Address))
13349     m_h245Address.Encode(strm);
13350   if (HasOptionalField(e_sourceAddress))
13351     m_sourceAddress.Encode(strm);
13352   m_sourceInfo.Encode(strm);
13353   if (HasOptionalField(e_destinationAddress))
13354     m_destinationAddress.Encode(strm);
13355   if (HasOptionalField(e_destCallSignalAddress))
13356     m_destCallSignalAddress.Encode(strm);
13357   if (HasOptionalField(e_destExtraCallInfo))
13358     m_destExtraCallInfo.Encode(strm);
13359   if (HasOptionalField(e_destExtraCRV))
13360     m_destExtraCRV.Encode(strm);
13361   m_activeMC.Encode(strm);
13362   m_conferenceID.Encode(strm);
13363   m_conferenceGoal.Encode(strm);
13364   if (HasOptionalField(e_callServices))
13365     m_callServices.Encode(strm);
13366   m_callType.Encode(strm);
13367   KnownExtensionEncode(strm, e_sourceCallSignalAddress, m_sourceCallSignalAddress);
13368   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
13369   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
13370   KnownExtensionEncode(strm, e_h245SecurityCapability, m_h245SecurityCapability);
13371   KnownExtensionEncode(strm, e_tokens, m_tokens);
13372   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
13373   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
13374   KnownExtensionEncode(strm, e_mediaWaitForConnect, m_mediaWaitForConnect);
13375   KnownExtensionEncode(strm, e_canOverlapSend, m_canOverlapSend);
13376   KnownExtensionEncode(strm, e_endpointIdentifier, m_endpointIdentifier);
13377   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
13378   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
13379   KnownExtensionEncode(strm, e_connectionParameters, m_connectionParameters);
13380   KnownExtensionEncode(strm, e_language, m_language);
13381   KnownExtensionEncode(strm, e_presentationIndicator, m_presentationIndicator);
13382   KnownExtensionEncode(strm, e_screeningIndicator, m_screeningIndicator);
13383   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
13384   KnownExtensionEncode(strm, e_symmetricOperationRequired, m_symmetricOperationRequired);
13385   KnownExtensionEncode(strm, e_capacity, m_capacity);
13386   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
13387   KnownExtensionEncode(strm, e_desiredProtocols, m_desiredProtocols);
13388   KnownExtensionEncode(strm, e_neededFeatures, m_neededFeatures);
13389   KnownExtensionEncode(strm, e_desiredFeatures, m_desiredFeatures);
13390   KnownExtensionEncode(strm, e_supportedFeatures, m_supportedFeatures);
13391   KnownExtensionEncode(strm, e_parallelH245Control, m_parallelH245Control);
13392   KnownExtensionEncode(strm, e_additionalSourceAddresses, m_additionalSourceAddresses);
13393   KnownExtensionEncode(strm, e_hopCount, m_hopCount);
13394
13395   UnknownExtensionsEncode(strm);
13396 }
13397
13398
13399 PObject * H225_Setup_UUIE::Clone() const
13400 {
13401 #ifndef PASN_LEANANDMEAN
13402   PAssert(IsClass(H225_Setup_UUIE::Class()), PInvalidCast);
13403 #endif
13404   return new H225_Setup_UUIE(*this);
13405 }
13406
13407
13408 //
13409 // Facility-UUIE
13410 //
13411
13412 H225_Facility_UUIE::H225_Facility_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
13413   : PASN_Sequence(tag, tagClass, 3, TRUE, 16)
13414 {
13415   IncludeOptionalField(e_callIdentifier);
13416   IncludeOptionalField(e_multipleCalls);
13417   IncludeOptionalField(e_maintainConnection);
13418 }
13419
13420
13421 #ifndef PASN_NOPRINTON
13422 void H225_Facility_UUIE::PrintOn(ostream & strm) const
13423 {
13424   int indent = strm.precision() + 2;
13425   strm << "{\n";
13426   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
13427   if (HasOptionalField(e_alternativeAddress))
13428     strm << setw(indent+21) << "alternativeAddress = " << setprecision(indent) << m_alternativeAddress << '\n';
13429   if (HasOptionalField(e_alternativeAliasAddress))
13430     strm << setw(indent+26) << "alternativeAliasAddress = " << setprecision(indent) << m_alternativeAliasAddress << '\n';
13431   if (HasOptionalField(e_conferenceID))
13432     strm << setw(indent+15) << "conferenceID = " << setprecision(indent) << m_conferenceID << '\n';
13433   strm << setw(indent+9) << "reason = " << setprecision(indent) << m_reason << '\n';
13434   if (HasOptionalField(e_callIdentifier))
13435     strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
13436   if (HasOptionalField(e_destExtraCallInfo))
13437     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
13438   if (HasOptionalField(e_remoteExtensionAddress))
13439     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
13440   if (HasOptionalField(e_tokens))
13441     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
13442   if (HasOptionalField(e_cryptoTokens))
13443     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
13444   if (HasOptionalField(e_conferences))
13445     strm << setw(indent+14) << "conferences = " << setprecision(indent) << m_conferences << '\n';
13446   if (HasOptionalField(e_h245Address))
13447     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
13448   if (HasOptionalField(e_fastStart))
13449     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
13450   if (HasOptionalField(e_multipleCalls))
13451     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
13452   if (HasOptionalField(e_maintainConnection))
13453     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
13454   if (HasOptionalField(e_fastConnectRefused))
13455     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
13456   if (HasOptionalField(e_serviceControl))
13457     strm << setw(indent+17) << "serviceControl = " << setprecision(indent) << m_serviceControl << '\n';
13458   if (HasOptionalField(e_circuitInfo))
13459     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
13460   if (HasOptionalField(e_featureSet))
13461     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
13462   if (HasOptionalField(e_destinationInfo))
13463     strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
13464   if (HasOptionalField(e_h245SecurityMode))
13465     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
13466   strm << setw(indent-1) << setprecision(indent-2) << "}";
13467 }
13468 #endif
13469
13470
13471 PObject::Comparison H225_Facility_UUIE::Compare(const PObject & obj) const
13472 {
13473 #ifndef PASN_LEANANDMEAN
13474   PAssert(PIsDescendant(&obj, H225_Facility_UUIE), PInvalidCast);
13475 #endif
13476   const H225_Facility_UUIE & other = (const H225_Facility_UUIE &)obj;
13477
13478   Comparison result;
13479
13480   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
13481     return result;
13482   if ((result = m_alternativeAddress.Compare(other.m_alternativeAddress)) != EqualTo)
13483     return result;
13484   if ((result = m_alternativeAliasAddress.Compare(other.m_alternativeAliasAddress)) != EqualTo)
13485     return result;
13486   if ((result = m_conferenceID.Compare(other.m_conferenceID)) != EqualTo)
13487     return result;
13488   if ((result = m_reason.Compare(other.m_reason)) != EqualTo)
13489     return result;
13490
13491   return PASN_Sequence::Compare(other);
13492 }
13493
13494
13495 PINDEX H225_Facility_UUIE::GetDataLength() const
13496 {
13497   PINDEX length = 0;
13498   length += m_protocolIdentifier.GetObjectLength();
13499   if (HasOptionalField(e_alternativeAddress))
13500     length += m_alternativeAddress.GetObjectLength();
13501   if (HasOptionalField(e_alternativeAliasAddress))
13502     length += m_alternativeAliasAddress.GetObjectLength();
13503   if (HasOptionalField(e_conferenceID))
13504     length += m_conferenceID.GetObjectLength();
13505   length += m_reason.GetObjectLength();
13506   return length;
13507 }
13508
13509
13510 BOOL H225_Facility_UUIE::Decode(PASN_Stream & strm)
13511 {
13512   if (!PreambleDecode(strm))
13513     return FALSE;
13514
13515   if (!m_protocolIdentifier.Decode(strm))
13516     return FALSE;
13517   if (HasOptionalField(e_alternativeAddress) && !m_alternativeAddress.Decode(strm))
13518     return FALSE;
13519   if (HasOptionalField(e_alternativeAliasAddress) && !m_alternativeAliasAddress.Decode(strm))
13520     return FALSE;
13521   if (HasOptionalField(e_conferenceID) && !m_conferenceID.Decode(strm))
13522     return FALSE;
13523   if (!m_reason.Decode(strm))
13524     return FALSE;
13525   if (!KnownExtensionDecode(strm, e_callIdentifier, m_callIdentifier))
13526     return FALSE;
13527   if (!KnownExtensionDecode(strm, e_destExtraCallInfo, m_destExtraCallInfo))
13528     return FALSE;
13529   if (!KnownExtensionDecode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress))
13530     return FALSE;
13531   if (!KnownExtensionDecode(strm, e_tokens, m_tokens))
13532     return FALSE;
13533   if (!KnownExtensionDecode(strm, e_cryptoTokens, m_cryptoTokens))
13534     return FALSE;
13535   if (!KnownExtensionDecode(strm, e_conferences, m_conferences))
13536     return FALSE;
13537   if (!KnownExtensionDecode(strm, e_h245Address, m_h245Address))
13538     return FALSE;
13539   if (!KnownExtensionDecode(strm, e_fastStart, m_fastStart))
13540     return FALSE;
13541   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
13542     return FALSE;
13543   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
13544     return FALSE;
13545   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
13546     return FALSE;
13547   if (!KnownExtensionDecode(strm, e_serviceControl, m_serviceControl))
13548     return FALSE;
13549   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
13550     return FALSE;
13551   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
13552     return FALSE;
13553   if (!KnownExtensionDecode(strm, e_destinationInfo, m_destinationInfo))
13554     return FALSE;
13555   if (!KnownExtensionDecode(strm, e_h245SecurityMode, m_h245SecurityMode))
13556     return FALSE;
13557
13558   return UnknownExtensionsDecode(strm);
13559 }
13560
13561
13562 void H225_Facility_UUIE::Encode(PASN_Stream & strm) const
13563 {
13564   PreambleEncode(strm);
13565
13566   m_protocolIdentifier.Encode(strm);
13567   if (HasOptionalField(e_alternativeAddress))
13568     m_alternativeAddress.Encode(strm);
13569   if (HasOptionalField(e_alternativeAliasAddress))
13570     m_alternativeAliasAddress.Encode(strm);
13571   if (HasOptionalField(e_conferenceID))
13572     m_conferenceID.Encode(strm);
13573   m_reason.Encode(strm);
13574   KnownExtensionEncode(strm, e_callIdentifier, m_callIdentifier);
13575   KnownExtensionEncode(strm, e_destExtraCallInfo, m_destExtraCallInfo);
13576   KnownExtensionEncode(strm, e_remoteExtensionAddress, m_remoteExtensionAddress);
13577   KnownExtensionEncode(strm, e_tokens, m_tokens);
13578   KnownExtensionEncode(strm, e_cryptoTokens, m_cryptoTokens);
13579   KnownExtensionEncode(strm, e_conferences, m_conferences);
13580   KnownExtensionEncode(strm, e_h245Address, m_h245Address);
13581   KnownExtensionEncode(strm, e_fastStart, m_fastStart);
13582   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
13583   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
13584   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
13585   KnownExtensionEncode(strm, e_serviceControl, m_serviceControl);
13586   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
13587   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
13588   KnownExtensionEncode(strm, e_destinationInfo, m_destinationInfo);
13589   KnownExtensionEncode(strm, e_h245SecurityMode, m_h245SecurityMode);
13590
13591   UnknownExtensionsEncode(strm);
13592 }
13593
13594
13595 PObject * H225_Facility_UUIE::Clone() const
13596 {
13597 #ifndef PASN_LEANANDMEAN
13598   PAssert(IsClass(H225_Facility_UUIE::Class()), PInvalidCast);
13599 #endif
13600   return new H225_Facility_UUIE(*this);
13601 }
13602
13603
13604 //
13605 // Progress-UUIE
13606 //
13607
13608 H225_Progress_UUIE::H225_Progress_UUIE(unsigned tag, PASN_Object::TagClass tagClass)
13609   : PASN_Sequence(tag, tagClass, 5, TRUE, 3)
13610 {
13611   IncludeOptionalField(e_multipleCalls);
13612   IncludeOptionalField(e_maintainConnection);
13613 }
13614
13615
13616 #ifndef PASN_NOPRINTON
13617 void H225_Progress_UUIE::PrintOn(ostream & strm) const
13618 {
13619   int indent = strm.precision() + 2;
13620   strm << "{\n";
13621   strm << setw(indent+21) << "protocolIdentifier = " << setprecision(indent) << m_protocolIdentifier << '\n';
13622   strm << setw(indent+18) << "destinationInfo = " << setprecision(indent) << m_destinationInfo << '\n';
13623   if (HasOptionalField(e_h245Address))
13624     strm << setw(indent+14) << "h245Address = " << setprecision(indent) << m_h245Address << '\n';
13625   strm << setw(indent+17) << "callIdentifier = " << setprecision(indent) << m_callIdentifier << '\n';
13626   if (HasOptionalField(e_h245SecurityMode))
13627     strm << setw(indent+19) << "h245SecurityMode = " << setprecision(indent) << m_h245SecurityMode << '\n';
13628   if (HasOptionalField(e_tokens))
13629     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
13630   if (HasOptionalField(e_cryptoTokens))
13631     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
13632   if (HasOptionalField(e_fastStart))
13633     strm << setw(indent+12) << "fastStart = " << setprecision(indent) << m_fastStart << '\n';
13634   if (HasOptionalField(e_multipleCalls))
13635     strm << setw(indent+16) << "multipleCalls = " << setprecision(indent) << m_multipleCalls << '\n';
13636   if (HasOptionalField(e_maintainConnection))
13637     strm << setw(indent+21) << "maintainConnection = " << setprecision(indent) << m_maintainConnection << '\n';
13638   if (HasOptionalField(e_fastConnectRefused))
13639     strm << setw(indent+21) << "fastConnectRefused = " << setprecision(indent) << m_fastConnectRefused << '\n';
13640   strm << setw(indent-1) << setprecision(indent-2) << "}";
13641 }
13642 #endif
13643
13644
13645 PObject::Comparison H225_Progress_UUIE::Compare(const PObject & obj) const
13646 {
13647 #ifndef PASN_LEANANDMEAN
13648   PAssert(PIsDescendant(&obj, H225_Progress_UUIE), PInvalidCast);
13649 #endif
13650   const H225_Progress_UUIE & other = (const H225_Progress_UUIE &)obj;
13651
13652   Comparison result;
13653
13654   if ((result = m_protocolIdentifier.Compare(other.m_protocolIdentifier)) != EqualTo)
13655     return result;
13656   if ((result = m_destinationInfo.Compare(other.m_destinationInfo)) != EqualTo)
13657     return result;
13658   if ((result = m_h245Address.Compare(other.m_h245Address)) != EqualTo)
13659     return result;
13660   if ((result = m_callIdentifier.Compare(other.m_callIdentifier)) != EqualTo)
13661     return result;
13662   if ((result = m_h245SecurityMode.Compare(other.m_h245SecurityMode)) != EqualTo)
13663     return result;
13664   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
13665     return result;
13666   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
13667     return result;
13668   if ((result = m_fastStart.Compare(other.m_fastStart)) != EqualTo)
13669     return result;
13670
13671   return PASN_Sequence::Compare(other);
13672 }
13673
13674
13675 PINDEX H225_Progress_UUIE::GetDataLength() const
13676 {
13677   PINDEX length = 0;
13678   length += m_protocolIdentifier.GetObjectLength();
13679   length += m_destinationInfo.GetObjectLength();
13680   if (HasOptionalField(e_h245Address))
13681     length += m_h245Address.GetObjectLength();
13682   length += m_callIdentifier.GetObjectLength();
13683   if (HasOptionalField(e_h245SecurityMode))
13684     length += m_h245SecurityMode.GetObjectLength();
13685   if (HasOptionalField(e_tokens))
13686     length += m_tokens.GetObjectLength();
13687   if (HasOptionalField(e_cryptoTokens))
13688     length += m_cryptoTokens.GetObjectLength();
13689   if (HasOptionalField(e_fastStart))
13690     length += m_fastStart.GetObjectLength();
13691   return length;
13692 }
13693
13694
13695 BOOL H225_Progress_UUIE::Decode(PASN_Stream & strm)
13696 {
13697   if (!PreambleDecode(strm))
13698     return FALSE;
13699
13700   if (!m_protocolIdentifier.Decode(strm))
13701     return FALSE;
13702   if (!m_destinationInfo.Decode(strm))
13703     return FALSE;
13704   if (HasOptionalField(e_h245Address) && !m_h245Address.Decode(strm))
13705     return FALSE;
13706   if (!m_callIdentifier.Decode(strm))
13707     return FALSE;
13708   if (HasOptionalField(e_h245SecurityMode) && !m_h245SecurityMode.Decode(strm))
13709     return FALSE;
13710   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
13711     return FALSE;
13712   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
13713     return FALSE;
13714   if (HasOptionalField(e_fastStart) && !m_fastStart.Decode(strm))
13715     return FALSE;
13716   if (!KnownExtensionDecode(strm, e_multipleCalls, m_multipleCalls))
13717     return FALSE;
13718   if (!KnownExtensionDecode(strm, e_maintainConnection, m_maintainConnection))
13719     return FALSE;
13720   if (!KnownExtensionDecode(strm, e_fastConnectRefused, m_fastConnectRefused))
13721     return FALSE;
13722
13723   return UnknownExtensionsDecode(strm);
13724 }
13725
13726
13727 void H225_Progress_UUIE::Encode(PASN_Stream & strm) const
13728 {
13729   PreambleEncode(strm);
13730
13731   m_protocolIdentifier.Encode(strm);
13732   m_destinationInfo.Encode(strm);
13733   if (HasOptionalField(e_h245Address))
13734     m_h245Address.Encode(strm);
13735   m_callIdentifier.Encode(strm);
13736   if (HasOptionalField(e_h245SecurityMode))
13737     m_h245SecurityMode.Encode(strm);
13738   if (HasOptionalField(e_tokens))
13739     m_tokens.Encode(strm);
13740   if (HasOptionalField(e_cryptoTokens))
13741     m_cryptoTokens.Encode(strm);
13742   if (HasOptionalField(e_fastStart))
13743     m_fastStart.Encode(strm);
13744   KnownExtensionEncode(strm, e_multipleCalls, m_multipleCalls);
13745   KnownExtensionEncode(strm, e_maintainConnection, m_maintainConnection);
13746   KnownExtensionEncode(strm, e_fastConnectRefused, m_fastConnectRefused);
13747
13748   UnknownExtensionsEncode(strm);
13749 }
13750
13751
13752 PObject * H225_Progress_UUIE::Clone() const
13753 {
13754 #ifndef PASN_LEANANDMEAN
13755   PAssert(IsClass(H225_Progress_UUIE::Class()), PInvalidCast);
13756 #endif
13757   return new H225_Progress_UUIE(*this);
13758 }
13759
13760
13761 //
13762 // Endpoint
13763 //
13764
13765 H225_Endpoint::H225_Endpoint(unsigned tag, PASN_Object::TagClass tagClass)
13766   : PASN_Sequence(tag, tagClass, 10, TRUE, 3)
13767 {
13768   m_priority.SetConstraints(PASN_Object::FixedConstraint, 0, 127);
13769 }
13770
13771
13772 #ifndef PASN_NOPRINTON
13773 void H225_Endpoint::PrintOn(ostream & strm) const
13774 {
13775   int indent = strm.precision() + 2;
13776   strm << "{\n";
13777   if (HasOptionalField(e_nonStandardData))
13778     strm << setw(indent+18) << "nonStandardData = " << setprecision(indent) << m_nonStandardData << '\n';
13779   if (HasOptionalField(e_aliasAddress))
13780     strm << setw(indent+15) << "aliasAddress = " << setprecision(indent) << m_aliasAddress << '\n';
13781   if (HasOptionalField(e_callSignalAddress))
13782     strm << setw(indent+20) << "callSignalAddress = " << setprecision(indent) << m_callSignalAddress << '\n';
13783   if (HasOptionalField(e_rasAddress))
13784     strm << setw(indent+13) << "rasAddress = " << setprecision(indent) << m_rasAddress << '\n';
13785   if (HasOptionalField(e_endpointType))
13786     strm << setw(indent+15) << "endpointType = " << setprecision(indent) << m_endpointType << '\n';
13787   if (HasOptionalField(e_tokens))
13788     strm << setw(indent+9) << "tokens = " << setprecision(indent) << m_tokens << '\n';
13789   if (HasOptionalField(e_cryptoTokens))
13790     strm << setw(indent+15) << "cryptoTokens = " << setprecision(indent) << m_cryptoTokens << '\n';
13791   if (HasOptionalField(e_priority))
13792     strm << setw(indent+11) << "priority = " << setprecision(indent) << m_priority << '\n';
13793   if (HasOptionalField(e_remoteExtensionAddress))
13794     strm << setw(indent+25) << "remoteExtensionAddress = " << setprecision(indent) << m_remoteExtensionAddress << '\n';
13795   if (HasOptionalField(e_destExtraCallInfo))
13796     strm << setw(indent+20) << "destExtraCallInfo = " << setprecision(indent) << m_destExtraCallInfo << '\n';
13797   if (HasOptionalField(e_alternateTransportAddresses))
13798     strm << setw(indent+30) << "alternateTransportAddresses = " << setprecision(indent) << m_alternateTransportAddresses << '\n';
13799   if (HasOptionalField(e_circuitInfo))
13800     strm << setw(indent+14) << "circuitInfo = " << setprecision(indent) << m_circuitInfo << '\n';
13801   if (HasOptionalField(e_featureSet))
13802     strm << setw(indent+13) << "featureSet = " << setprecision(indent) << m_featureSet << '\n';
13803   strm << setw(indent-1) << setprecision(indent-2) << "}";
13804 }
13805 #endif
13806
13807
13808 PObject::Comparison H225_Endpoint::Compare(const PObject & obj) const
13809 {
13810 #ifndef PASN_LEANANDMEAN
13811   PAssert(PIsDescendant(&obj, H225_Endpoint), PInvalidCast);
13812 #endif
13813   const H225_Endpoint & other = (const H225_Endpoint &)obj;
13814
13815   Comparison result;
13816
13817   if ((result = m_nonStandardData.Compare(other.m_nonStandardData)) != EqualTo)
13818     return result;
13819   if ((result = m_aliasAddress.Compare(other.m_aliasAddress)) != EqualTo)
13820     return result;
13821   if ((result = m_callSignalAddress.Compare(other.m_callSignalAddress)) != EqualTo)
13822     return result;
13823   if ((result = m_rasAddress.Compare(other.m_rasAddress)) != EqualTo)
13824     return result;
13825   if ((result = m_endpointType.Compare(other.m_endpointType)) != EqualTo)
13826     return result;
13827   if ((result = m_tokens.Compare(other.m_tokens)) != EqualTo)
13828     return result;
13829   if ((result = m_cryptoTokens.Compare(other.m_cryptoTokens)) != EqualTo)
13830     return result;
13831   if ((result = m_priority.Compare(other.m_priority)) != EqualTo)
13832     return result;
13833   if ((result = m_remoteExtensionAddress.Compare(other.m_remoteExtensionAddress)) != EqualTo)
13834     return result;
13835   if ((result = m_destExtraCallInfo.Compare(other.m_destExtraCallInfo)) != EqualTo)
13836     return result;
13837
13838   return PASN_Sequence::Compare(other);
13839 }
13840
13841
13842 PINDEX H225_Endpoint::GetDataLength() const
13843 {
13844   PINDEX length = 0;
13845   if (HasOptionalField(e_nonStandardData))
13846     length += m_nonStandardData.GetObjectLength();
13847   if (HasOptionalField(e_aliasAddress))
13848     length += m_aliasAddress.GetObjectLength();
13849   if (HasOptionalField(e_callSignalAddress))
13850     length += m_callSignalAddress.GetObjectLength();
13851   if (HasOptionalField(e_rasAddress))
13852     length += m_rasAddress.GetObjectLength();
13853   if (HasOptionalField(e_endpointType))
13854     length += m_endpointType.GetObjectLength();
13855   if (HasOptionalField(e_tokens))
13856     length += m_tokens.GetObjectLength();
13857   if (HasOptionalField(e_cryptoTokens))
13858     length += m_cryptoTokens.GetObjectLength();
13859   if (HasOptionalField(e_priority))
13860     length += m_priority.GetObjectLength();
13861   if (HasOptionalField(e_remoteExtensionAddress))
13862     length += m_remoteExtensionAddress.GetObjectLength();
13863   if (HasOptionalField(e_destExtraCallInfo))
13864     length += m_destExtraCallInfo.GetObjectLength();
13865   return length;
13866 }
13867
13868
13869 BOOL H225_Endpoint::Decode(PASN_Stream & strm)
13870 {
13871   if (!PreambleDecode(strm))
13872     return FALSE;
13873
13874   if (HasOptionalField(e_nonStandardData) && !m_nonStandardData.Decode(strm))
13875     return FALSE;
13876   if (HasOptionalField(e_aliasAddress) && !m_aliasAddress.Decode(strm))
13877     return FALSE;
13878   if (HasOptionalField(e_callSignalAddress) && !m_callSignalAddress.Decode(strm))
13879     return FALSE;
13880   if (HasOptionalField(e_rasAddress) && !m_rasAddress.Decode(strm))
13881     return FALSE;
13882   if (HasOptionalField(e_endpointType) && !m_endpointType.Decode(strm))
13883     return FALSE;
13884   if (HasOptionalField(e_tokens) && !m_tokens.Decode(strm))
13885     return FALSE;
13886   if (HasOptionalField(e_cryptoTokens) && !m_cryptoTokens.Decode(strm))
13887     return FALSE;
13888   if (HasOptionalField(e_priority) && !m_priority.Decode(strm))
13889     return FALSE;
13890   if (HasOptionalField(e_remoteExtensionAddress) && !m_remoteExtensionAddress.Decode(strm))
13891     return FALSE;
13892   if (HasOptionalField(e_destExtraCallInfo) && !m_destExtraCallInfo.Decode(strm))
13893     return FALSE;
13894   if (!KnownExtensionDecode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses))
13895     return FALSE;
13896   if (!KnownExtensionDecode(strm, e_circuitInfo, m_circuitInfo))
13897     return FALSE;
13898   if (!KnownExtensionDecode(strm, e_featureSet, m_featureSet))
13899     return FALSE;
13900
13901   return UnknownExtensionsDecode(strm);
13902 }
13903
13904
13905 void H225_Endpoint::Encode(PASN_Stream & strm) const
13906 {
13907   PreambleEncode(strm);
13908
13909   if (HasOptionalField(e_nonStandardData))
13910     m_nonStandardData.Encode(strm);
13911   if (HasOptionalField(e_aliasAddress))
13912     m_aliasAddress.Encode(strm);
13913   if (HasOptionalField(e_callSignalAddress))
13914     m_callSignalAddress.Encode(strm);
13915   if (HasOptionalField(e_rasAddress))
13916     m_rasAddress.Encode(strm);
13917   if (HasOptionalField(e_endpointType))
13918     m_endpointType.Encode(strm);
13919   if (HasOptionalField(e_tokens))
13920     m_tokens.Encode(strm);
13921   if (HasOptionalField(e_cryptoTokens))
13922     m_cryptoTokens.Encode(strm);
13923   if (HasOptionalField(e_priority))
13924     m_priority.Encode(strm);
13925   if (HasOptionalField(e_remoteExtensionAddress))
13926     m_remoteExtensionAddress.Encode(strm);
13927   if (HasOptionalField(e_destExtraCallInfo))
13928     m_destExtraCallInfo.Encode(strm);
13929   KnownExtensionEncode(strm, e_alternateTransportAddresses, m_alternateTransportAddresses);
13930   KnownExtensionEncode(strm, e_circuitInfo, m_circuitInfo);
13931   KnownExtensionEncode(strm, e_featureSet, m_featureSet);
13932
13933   UnknownExtensionsEncode(strm);
13934 }
13935
13936
13937 PObject * H225_Endpoint::Clone() const
13938 {
13939 #ifndef PASN_LEANANDMEAN
13940   PAssert(IsClass(H225_Endpoint::Class()), PInvalidCast);
13941 #endif
13942   return new H225_Endpoint(*this);
13943 }
13944
13945
13946 #endif // if ! H323_DISABLE_H225
13947
13948
13949 // End of h225.cxx